ForgeFusion.Core.Data.Common 1.1.3-beta

ForgeFusion Data Layer

Solution Structure (vNext)

The ForgeFusion solution is now modularized into several NuGet-ready libraries, grouped into three main categories:

• Core: The foundational libraries for business logic, data access, and extensibility.
• Accounts: Libraries focused on user, tenant, and identity management.
• Common: Shared utilities, base models, and cross-cutting concerns.
• Datastores: Specialized libraries for financials, products, inventory, transactions, and more.

This modular approach enables better separation of concerns, easier maintenance, and more flexible deployment.

Library Breakdown

1. Core Libraries

ForgeFusion.Core.Data.Common

• Purpose: Provides base models, interfaces, enums, and shared abstractions for all other libraries.
• Key Features:
  • Base entity classes (e.g., BaseModel, NomenclatureModel)
  • Common interfaces (e.g., ISoftDelete, IActiveToggle)
  • Shared enums and constants
  • Utility extensions
• Consumers: All other ForgeFusion libraries.

ForgeFusion.Core.Data.Extensions

• Purpose: Contains extension methods and helpers for EF Core, LINQ, and general .NET usage.
• Key Features:
  • Expression and ModelBuilder extensions
  • Query filter helpers
  • Reflection utilities
• Consumers: Used by data, storage, and repository libraries.

ForgeFusion.Core.Data.Repositories

• Purpose: Implements repository and unit-of-work patterns for data access.
• Key Features:
  • Generic repositories
  • Query and command abstractions
  • Integration with EF Core
• Consumers: Used by storage, financials, products, and other data libraries.

ForgeFusion.Core.Data.Storage

• Purpose: Provides the main EF Core DbContext and handles multi-tenancy, caching, and configuration.
• Key Features:
  • RootDbContext and tenant-aware context logic
  • Caching and configuration integration
  • Logging and diagnostics
• Consumers: Used by repositories, financials, products, and other data libraries.

2. Accounts Libraries

ForgeFusion.Entities.Core.Account

• Purpose: Defines entities and logic for user, tenant, and account management.
• Key Features:
  • Tenant, user, and role models
  • Account configuration and relationships
  • Identity and permission management
• Consumers: Used by storage, repositories, and other domain libraries.

3. Datastores Libraries

ForgeFusion.Core.Data.Financials

• Purpose: Models and logic for financial transactions, loans, and repayments.
• Key Features:
  • Loan, repayment, and invoice entities
  • Financial transaction logic
• Consumers: Used by storage, repositories, and reporting.

ForgeFusion.Core.Data.FinServices

• Purpose: Models for financial service providers, accounts, and listings.
• Key Features:
  • Service provider and account entities
  • Financial service listing logic
• Consumers: Used by financials, storage, and repositories.

ForgeFusion.Core.Data.Inventory

• Purpose: Inventory and stock management models.
• Key Features:
  • Product, stock, and inventory entities
  • Inventory transaction logic
• Consumers: Used by storage, repositories, and products.

ForgeFusion.Core.Data.Products

• Purpose: Product catalog, variants, and offer models.
• Key Features:
  • Product, variant, and offer entities
  • Discount and pricing logic
• Consumers: Used by inventory, storage, and repositories.

ForgeFusion.Core.Data.Trackers

• Purpose: Tracking and audit models for business processes.
• Key Features:
  • Change tracking
  • Audit trail entities
• Consumers: Used by storage and repositories.

ForgeFusion.Core.Data.Transactions

• Purpose: Transactional models for payments, logs, and business events.
• Key Features:
  • Payment, Mpesa log, and transaction entities
  • Transaction processing logic
• Consumers: Used by financials, storage, and repositories.

ForgeFusion.Core.Data.Entities.Traders

• Purpose: Models for trader entities (buyers, sellers, clusters, etc.).
• Key Features:
  • Buyer, seller, and cluster entities
  • Trader relationships and logic
• Consumers: Used by products, financials, and storage.

Dependency Diagram

graph TD

    %% Core
    subgraph Core
        Repositories["ForgeFusion.Core.Data.Repositories"]
        Storage["ForgeFusion.Core.Data.Storage"]
    end

    %% Accounts
    subgraph Accounts
        Accounts["ForgeFusion.Entities.Core.Account"]
    end

    %% Datastores
    subgraph Datastores
        Financials["ForgeFusion.Core.Data.Financials"]
        FinServices["ForgeFusion.Core.Data.FinServices"]
        Inventory["ForgeFusion.Core.Data.Inventory"]
        Products["ForgeFusion.Core.Data.Products"]
        Trackers["ForgeFusion.Core.Data.Trackers"]
        Transactions["ForgeFusion.Core.Data.Transactions"]
        Traders["ForgeFusion.Core.Data.Entities.Traders"]
    end

    %% Shared Components
    Common["ForgeFusion.Core.Data.Common"]
    Extensions["ForgeFusion.Core.Data.Extensions"]

    %% Relationships
    Common --> Extensions
    Extensions --> Repositories
    Extensions --> Storage
    Common --> Repositories
    Common --> Storage
    Common --> Accounts
    Common --> Financials
    Common --> FinServices
    Common --> Inventory
    Common --> Products
    Common --> Trackers
    Common --> Transactions
    Common --> Traders

    Accounts --> Storage
    Accounts --> Repositories
    Accounts --> Financials
    Accounts --> Products
    Accounts --> Transactions

    Storage --> Repositories
    Storage --> Financials
    Storage --> FinServices
    Storage --> Inventory
    Storage --> Products
    Storage --> Trackers
    Storage --> Transactions
    Storage --> Traders

    Repositories --> Financials
    Repositories --> FinServices
    Repositories --> Inventory
    Repositories --> Products
    Repositories --> Trackers
    Repositories --> Transactions
    Repositories --> Traders

    Financials --> FinServices
    Financials --> Traders
    Financials --> Products

    FinServices --> Traders

    Inventory --> Products
    Inventory --> Traders

    Products --> Traders

    Transactions --> Financials
    Transactions --> Traders

Summary Table

Guidance for Contributors

• Add new domain logic in the appropriate Datastore library.
• Use Common and Extensions for all shared logic and base types.
• Register new entities in Storage and Repositories as needed.
• Follow the dependency flow: Common → Extensions → Core → Datastores.