Skip to main content

Finance Domain Documentation Index

Overview​

This section contains comprehensive domain documentation for all aggregates, business rules, and domain services across the Finance Module. The domain layer represents the core business logic and is completely independent of infrastructure concerns across all finance sub-modules.

Finance Domain Architecture​

The Finance Module follows Domain-Driven Design (DDD) principles with these key concepts distributed across sub-modules:

  • Core Aggregates: Business entities with strong consistency boundaries
  • Shared Value Objects: Immutable objects used across multiple modules
  • Domain Services: Stateless services encapsulating complex business logic
  • Domain Events: Events published when important business rules are triggered
  • Cross-Module Integration: Event-driven communication between sub-modules

Domain Organization by Sub-Module​

General Ledger Domain​

Core accounting domain with multi-dimensional transaction processing.

Core Aggregates​

  • Ledger Aggregate

    • Ledger configuration and fiscal setup
    • Chart of accounts management
    • Account structure assignment and validation

  • DimensionHierarchy Aggregate

    • Account structure definitions
    • Constraint tree management
    • Activation lifecycle and overlap prevention

  • DimensionCombination Aggregate

    • Immutable dimensional account combinations
    • Hash-based deduplication
    • Display value generation

  • LedgerJournalHeader Aggregate (Pending Documentation)

    • Journal lifecycle management
    • Posting and reversal logic
    • Balance validation and fiscal period checks

Key Domain Services​

  • AccountStructureResolutionService

    • MainAccount-based structure resolution
    • Constraint evaluation logic

  • ConstraintOverlapDetectionService

    • Prevents ambiguous account structures
    • Golden Rule enforcement

  • DimensionCombinationDomainService

    • Combination creation and reuse logic
    • Hash generation and uniqueness

Financial Dimensions Domain​

Shared dimensional infrastructure used across all finance modules.

Core Aggregates​

  • DimensionAttribute Aggregate (Pending Documentation)

    • Dimension definition and metadata
    • Custom vs entity-backed dimension types
    • Validation rules and constraints

  • DimensionAttributeValue Aggregate (Pending Documentation)

    • Individual dimension values
    • Suspension and activation lifecycle
    • Group dimension support

  • DimensionAttributeValueSet Aggregate (Pending Documentation)

    • Default dimension collections
    • Hash-based uniqueness for reuse
    • Master data integration

Key Domain Services​

  • DimensionValueResolverService

    • String value to ID resolution
    • Get-or-create pattern implementation

  • DimensionAttributeValueSetDomainService (Planned)

    • Set creation and hash generation
    • Uniqueness validation

Accounts Receivable Domain Planned​

Customer management and receivables processing.

Planned Aggregates​

  • Customer Aggregate

    • Customer master data with default dimensions
    • Credit management and payment terms
    • Integration with CRM module

  • CustomerInvoice Aggregate

    • Invoice generation and posting
    • Line-level dimensional classification
    • Payment application tracking

  • CustomerPayment Aggregate

    • Payment processing and allocation
    • Multi-invoice payment application
    • Cash discount handling

Planned Domain Services​

  • InvoicePostingService

    • Journal entry generation from invoices
    • Dimensional inheritance from customer defaults

  • PaymentApplicationService

    • Automatic and manual payment allocation
    • Over/under payment handling

Accounts Payable Domain Planned​

Vendor management and payables processing.

Planned Aggregates​

  • Vendor Aggregate

    • Vendor master data with default dimensions
    • Payment terms and vendor categories
    • Integration with procurement modules

  • VendorInvoice Aggregate

    • Purchase invoice processing
    • Three-way matching logic
    • Approval workflow integration

  • VendorPayment Aggregate

    • Payment processing and vendor allocation
    • Payment method handling
    • Check printing and electronic payments

Planned Domain Services​

  • ThreeWayMatchingService

    • PO, receipt, and invoice matching logic
    • Tolerance validation and exception handling

  • VendorPaymentService

    • Payment proposal generation
    • Payment grouping and optimization

Cross-Module Business Rules​

Universal Finance Rules​

Golden Rule: Dimensional Consistency​

Rule: All financial transactions must use consistent dimensional structures within the same ledger.

Scope: All finance modules Enforcement:

  • General Ledger: Account structure resolution
  • AR/AP: Inherit customer/vendor default dimensions
  • Validation at transaction creation

Double-Entry Accounting Principle​

Rule: Every financial transaction must maintain the fundamental accounting equation (Assets = Liabilities + Equity).

Scope: All modules generating journal entries Enforcement:

  • Journal balance validation before posting
  • Automatic offset entry generation where applicable
  • Cross-module transaction integrity

Fiscal Period Compliance​

Rule: Transactions can only be posted to open fiscal periods.

Scope: All modules with posting capabilities Enforcement:

  • Period validation at posting time
  • Period-end closing procedures
  • Audit trail for period status changes

Currency Consistency​

Rule: Multi-currency transactions must maintain proper exchange rate tracking and reporting currency conversion.

Scope: All modules handling monetary amounts Enforcement:

  • Exchange rate validation at transaction entry
  • Reporting currency conversion tracking
  • Revaluation procedures for foreign currency balances

Domain Events & Integration​

Domain Event Categories​

Entity Lifecycle Events​

Published within individual modules for internal consistency:

// General Ledger
public record LedgerJournalPostedDomainEvent(LedgerJournalHeader Journal);
public record DimensionCombinationCreatedDomainEvent(DimensionCombination Combination);

// Financial Dimensions  
public record DimensionAttributeCreatedDomainEvent(DimensionAttribute Attribute);
public record DimensionValueSetCreatedDomainEvent(DimensionAttributeValueSet ValueSet);

// Accounts Receivable (Planned)
public record CustomerInvoicePostedDomainEvent(CustomerInvoice Invoice);
public record CustomerPaymentAppliedDomainEvent(CustomerPayment Payment);

Integration Events​

Published for cross-module communication:

// From General Ledger to other modules
public record JournalPostedIntegrationEvent(
    Guid JournalId,
    string DocumentNumber,
    decimal TotalAmount,
    DateTime PostedDate);

// From Financial Dimensions to other modules
public record DimensionCombinationCreatedIntegrationEvent(
    Guid CombinationId,
    string DisplayValue,
    IReadOnlyList<DimensionSegment> Segments);

// From AR/AP to General Ledger (Planned)
public record InvoiceReadyForPostingIntegrationEvent(
    Guid InvoiceId,
    IReadOnlyList<JournalEntryRequest> JournalEntries);

Event Flow Patterns​

Journal Posting Workflow​

Cross-Module Dimension Inheritance​

Domain Service Interactions​

Typical Cross-Module Flow​

Service Dependency Graph​

Testing Domain Logic​

Testing Categories by Module​

General Ledger Domain Tests​

[TestFixture]
public class LedgerJournalHeaderTests
{
    [Test]
    public void Post_Should_Raise_Domain_Event_When_Valid()
    {
        // Test journal posting logic and event publication
    }
    
    [Test]
    public void Post_Should_Throw_When_Fiscal_Period_Closed()
    {
        // Test fiscal period validation
    }
}

[TestFixture]
public class AccountStructureResolutionServiceTests
{
    [Test]
    public async Task Should_Resolve_Correct_Structure_For_MainAccount()
    {
        // Test MainAccount-based structure resolution
    }
}

Cross-Module Integration Tests​

[TestFixture]
public class CrossModuleIntegrationTests
{
    [Test]
    public async Task Customer_Default_Dimensions_Should_Flow_To_GL()
    {
        // Test dimension inheritance from AR to GL
    }
    
    [Test]
    public async Task Posted_Invoice_Should_Create_GL_Entries()
    {
        // Test AR invoice posting to GL
    }
}

Domain Service Testing Patterns​

[TestFixture]
public class DimensionValueResolverServiceTests
{
    [Test]
    public async Task Should_Create_New_Value_When_Not_Exists()
    {
        // Test get-or-create pattern
    }
    
    [Test]
    public async Task Should_Reuse_Existing_Value_When_Exists()
    {
        // Test value reuse logic
    }
}

Performance Considerations​

Aggregate Design Patterns​

Size Management​

  • Large Aggregates: LedgerJournalHeader with many lines - use lazy loading
  • Frequently Accessed: DimensionCombination - optimize for read performance
  • Cache-Friendly: DimensionAttribute metadata - design for caching

Event Processing Optimization​

  • Synchronous Events: Domain events within transaction boundaries
  • Asynchronous Events: Integration events via message bus
  • Batch Processing: Bulk operations for large data volumes

Cross-Module Performance​

// Efficient dimension resolution caching
public class CachedAccountStructureResolutionService
{
    private readonly IMemoryCache _cache;
    
    public async Task<DimensionHierarchy> ResolveAsync(string mainAccount)
    {
        var cacheKey = $"structure:{mainAccount}";
        return await _cache.GetOrCreateAsync(cacheKey, factory);
    }
}

Future Domain Enhancements​

Planned Cross-Module Features​

  • Advanced Workflow Engine: Configurable approval workflows across modules
  • Real-time Analytics: Event-sourced analytics for financial KPIs
  • Multi-Company Consolidation: Cross-company transaction processing
  • Advanced Audit Trail: Complete financial audit trail across modules

Domain Model Evolution​

  • Event Sourcing: Consider for audit-heavy processes
  • Microservices: Potential bounded context evolution
  • AI Integration: Machine learning for transaction classification
  • Blockchain: Immutable audit trail capabilities

Internal References​

External References​

  • Domain-Driven Design - Evans, Eric (Aggregate design patterns)
  • Implementing Domain-Driven Design - Vernon, Vaughn (Practical implementation)
  • Microservices Patterns - Richardson, Chris (Distributed system patterns)
  • Enterprise Integration Patterns - Hohpe & Woolf (Integration approaches)

Last Updated: [Current Date] | Version: 1.0 | Status: Active Development

Priority Documentation Needed:

  1. LedgerJournalHeader Aggregate documentation
  2. Financial Dimensions aggregate documentation
  3. Cross-module integration event specifications
  4. Performance optimization guidelines