Clean architecture layer

🚀 Complete Business Module Generation

The Flexbase automatically generates complete, production-ready business modules in minutes instead of weeks, following enterprise architectural patterns.

⚡ What Gets Generated Automatically

Complete Infrastructure & Plumbing Code

Orders Module (30 minutes generation):
├── 🎯 Domain Models (Structure + Attributes)
├── 🌐 REST API Controllers (Full CRUD)
├── 📊 Database Integration (Auto-migrations)
├── 🔄 Message Bus Integration (Events/Commands)
├── 📝 DTOs & Validation (Input/Output)
├── 🗺️ AutoMapper Configuration (Quick SelectTo)
├── 🔧 Command/Query Handlers (Orchestration)
├── 📡 Event Publishers/Subscribers (Event Flow)
└── 🧪 Testing Infrastructure (Unit/Integration)

Developer Only Writes:

  • Business Attributes - Domain model attributes and validation rules

  • Quick Validation Logic - Custom business rule plugins

  • State Machine Logic - Business workflow transitions

  • Custom Mappings - Special projection requirements

Enterprise Architecture Patterns (Auto-Generated)

  • Clean Architecture: Domain, Application, Infrastructure, Presentation layers

  • CQRS: Separate Commands (write) and Queries (read) operations

  • Event-Driven: Automatic event publishing and handling

  • Repository Pattern: Database abstraction with multi-database support

  • Dependency Injection: Full IoC container integration

🔄 End-to-End Operation Flow

Insert Operation - Complete Journey

API Call → Controller → Service → Command → Handler → Domain → Database → Event → Subscriber

What Happens Automatically (Generated Plumbing):

  1. Input Validation - Framework validates all inputs using developer-defined attributes

  2. Business Flow - Generated handlers orchestrate the business process

  3. Database Persistence - Automatic save with transaction management

  4. Event Publishing - Side effects triggered automatically

  5. Response Generation - Structured API response

Developer Adds (Business Logic):

  • Custom Validation Rules - Business-specific validation logic

  • State Transitions - Business workflow state changes

  • Domain Events - Custom business events and side effects

Query Operation - Optimized Read Path

API Call → Controller → Query Handler → AutoMapper SelectTo → Database → Response

Generated Query Benefits:

  • Quick SelectTo - Complex queries with simple AutoMapper configuration

  • No Complex SELECT - Framework generates optimized database queries

  • Type Safety - Compile-time validation throughout

  • Database-Level Optimization - Only fetch required data

  • Developer Flexibility - Custom queries when needed

Developer Query Options:

// Option 1: Quick AutoMapper SelectTo (Generated)
public class GetOrders : FlexiQueryEnumerableBridge<GetOrdersDto>
{
    public override IEnumerable<GetOrdersDto> Fetch()
    {
        // Simple SelectTo - no complex SELECT statements
        return _repoFactory.GetRepo()
            .FindAll<Order>()
            .Include(o => o.Customer)
            .SelectTo<GetOrdersDto>()
            .ToList();
    }
}

// Option 2: Custom Query (Developer writes when needed)
public class GetOrdersWithCustomLogic : FlexiQueryEnumerableBridge<GetOrdersDto>
{
    public override IEnumerable<GetOrdersDto> Fetch()
    {
        // Developer can write custom complex queries
        return _repoFactory.GetRepo()
            .FindAll<Order>()
            .Where(o => o.CreatedDate >= DateTime.Now.AddDays(-30))
            .Join(_repoFactory.GetRepo().FindAll<Customer>(),
                  o => o.CustomerId,
                  c => c.Id,
                  (order, customer) => new { Order = order, Customer = customer })
            .Select(result => new GetOrdersDto
            {
                Id = result.Order.Id,
                CustomerName = result.Customer.Name,
                TotalAmount = result.Order.TotalAmount,
                // Custom projection logic
                StatusDisplay = GetStatusDisplay(result.Order.Status),
                DaysSinceCreated = (DateTime.UtcNow - result.Order.CreatedDate).Days
            })
            .ToList();
    }
}

📦 Generated Business Modules

1. Orders Module - E-Commerce Order Management

  • ✅ AddOrder - Create orders with full validation

  • ✅ AddItemToOrder - Add products to existing orders

  • ✅ Order Management - Complete CRUD operations

  • ✅ Order Queries - Retrieve order information with projections

2. Products Module - Product Catalog Management

  • ✅ AddProduct - Create new products

  • ✅ UpdateProduct - Modify existing products

  • ✅ Product Management - Full lifecycle management

  • ✅ Product Queries - Search and retrieve products

3. Payments Module - Payment Processing

  • ✅ MakePayment - Process payment transactions

  • ✅ PaymentConfirmationCallBack - Handle payment confirmations

  • ✅ Payment Management - Complete payment lifecycle

  • ✅ Payment Queries - Retrieve payment information

4. Customers Module - Customer Management

  • ✅ GetCustomers - Query customer information

  • ✅ Customer Management - Complete customer lifecycle

  • ✅ Customer Queries - Advanced search capabilities

🏗️ Architectural Benefits

1. Separation of Concerns

  • Presentation Layer: HTTP, validation, serialization

  • Application Layer: Business orchestration, transactions

  • Domain Layer: Business logic, rules, domain knowledge

  • Infrastructure Layer: Data persistence, external services

2. Enterprise Patterns Built-In

  • CQRS: Commands and Queries automatically separated

  • Domain-Driven Design: Rich domain models with business logic

  • Event-Driven Architecture: Automatic event publishing and handling

  • Repository Pattern: Database abstraction with multi-database support

3. Performance & Scalability

  • Asynchronous Processing: Non-blocking operations

  • Horizontal Scaling: Stateless design ready for load balancing

  • Database Optimization: Projection queries and connection pooling

  • Event-Driven: Loose coupling through events

🎯 Business Value

For Development Teams

  • 95% Faster Development - Complete infrastructure in 30 minutes vs 2-3 weeks

  • Focus on Business Logic - Developers write only attributes and validation rules

  • Consistent Patterns - Same structure across all modules

  • Zero Configuration - Auto-generated dependency injection and routing

  • Type Safety - Compile-time validation throughout

For Operations Teams

  • Reliable Deployments - Tested patterns and infrastructure

  • Easy Monitoring - Built-in logging and metrics

  • Scalable Architecture - Horizontal scaling ready

  • Multi-Database Support - SQL Server, MySQL, PostgreSQL

For Business

  • Faster Time-to-Market - Reduced development cycles

  • Lower Costs - 95% reduction in development time

  • Higher Quality - Enterprise-grade architecture out-of-the-box

  • Future-Proof - Easy to extend and modify

🚀 Key Capabilities

Auto-Generated Infrastructure

  • Complete REST APIs - Full CRUD operations with documentation

  • Database Integration - Auto-migrations for multiple databases

  • Message Bus Integration - Event-driven architecture

  • Validation Framework - Input validation and error handling

  • Audit Trail - Automatic change tracking

Developer Experience

  • IntelliSense Support - Full code completion

  • Refactoring Safety - IDE refactoring works across all layers

  • Easy Testing - Mock-friendly interfaces and clear boundaries

  • Consistent Code - Uniform patterns across all modules

Enterprise Features

  • Multi-Tenant Support - Database per tenant

  • Security Integration - Built-in authentication and authorization

  • Logging & Monitoring - Structured logging with correlation IDs

  • Error Handling - Consistent error management across all layers

📊 Performance Impact

Development Efficiency - Detailed Analysis

95% Reduction Calculation (Post-Requirements, Pre-Testing)

Traditional Enterprise Development Cycle:
├── Requirements Analysis: 2-3 days
├── Database Design: 1-2 days
├── API Design: 1-2 days
├── Domain Model Creation: 2-3 days
├── DTOs & Validation: 1-2 days
├── Controller Implementation: 2-3 days
├── Command/Query Handlers: 3-4 days
├── Repository Integration: 1-2 days
├── Message Bus Setup: 2-3 days
├── AutoMapper Configuration: 1-2 days
├── Error Handling: 1-2 days
├── Logging & Monitoring: 1-2 days
├── API Documentation: 1-2 days
├── Code Review & Refactoring: 2-3 days
└── Total: 20-35 days (4-7 weeks)

YourApplication Generated Approach:
├── Requirements Analysis: 2-3 days (same)
├── Domain Model Definition: 0.5 days (attributes only)
├── Code Generation: 0.5 days (30 minutes)
├── Custom Business Logic: 1-2 days (validation rules)
├── Custom Mappings: 0.5 days (if needed)
├── Code Review & Refactoring: 0.5 days (minimal)
└── Total: 5-7 days (1-1.5 weeks)

Time Savings: 15-28 days saved per module
Reduction: 75-80% of total development time

Why 95% Reduction in Core Development?

The 95% reduction applies specifically to the core development work (post-requirements, pre-testing):

Traditional Core Development (15-25 days):

  • Database schema design and migrations

  • API endpoint implementation

  • Domain model creation with attributes

  • DTO creation and validation

  • Command/Query handler implementation

  • Repository pattern implementation

  • Message bus integration

  • AutoMapper configuration

  • Error handling and logging setup

YourApplication Core Development (1-2 days):

  • Domain model attributes definition

  • Custom business validation rules

  • Optional custom mappings

Calculation: (15-25 days) → (1-2 days) = 90-95% reduction

Complete Enterprise Development Lifecycle Savings

Full Enterprise Development Cycle (Traditional vs YourApplication):

Phase 1: Requirements & Planning (Same for both approaches)
├── Business Requirements: 3-5 days
├── Technical Architecture: 2-3 days
├── Database Design: 2-3 days
├── API Specification: 2-3 days
└── Total: 9-14 days

Phase 2: Core Development (95% reduction with YourApplication)
├── Traditional Approach: 20-35 days
├── YourApplication Approach: 5-7 days
└── Savings: 15-28 days (75-80% reduction)

Phase 3: Testing & Quality Assurance
├── Unit Testing: 3-5 days (Traditional) vs 1-2 days (YourApplication)
├── Integration Testing: 2-3 days (same for both)
├── Performance Testing: 1-2 days (same for both)
├── Security Testing: 1-2 days (same for both)
└── Total: 7-12 days (Traditional) vs 5-9 days (YourApplication)

Phase 4: Deployment & DevOps
├── Environment Setup: 1-2 days (same for both)
├── CI/CD Pipeline: 1-2 days (same for both)
├── Production Deployment: 1 day (same for both)
└── Total: 3-5 days (same for both)

Phase 5: Documentation & Training
├── Technical Documentation: 2-3 days (Traditional) vs 0.5 days (YourApplication)
├── API Documentation: 1-2 days (Traditional) vs 0 days (YourApplication)
├── User Training: 1-2 days (same for both)
└── Total: 4-7 days (Traditional) vs 2-4 days (YourApplication)

TOTAL ENTERPRISE CYCLE:
├── Traditional: 43-73 days (8.5-14.5 weeks)
├── YourApplication: 24-39 days (4.5-8 weeks)
└── Overall Savings: 19-34 days (4-7 weeks)
└── Overall Reduction: 44-47% of total development time

How Generated Code Saves Overall Effort

1. Reduced Testing Effort:

  • Consistent Patterns: Generated code follows identical patterns, reducing test complexity

  • Pre-tested Framework: Core functionality already tested by framework

  • Fewer Edge Cases: Standardized error handling reduces edge case testing

  • Auto-generated Tests: Framework can generate basic unit tests

2. Reduced Documentation Effort:

  • Auto-generated API Docs: Swagger/OpenAPI documentation created automatically

  • Consistent Architecture: Same patterns across modules reduce documentation needs

  • Self-documenting Code: Clear separation of concerns makes code self-explanatory

3. Reduced Maintenance Effort:

  • Consistent Code Quality: Generated code maintains consistent quality standards

  • Framework Updates: Infrastructure updates handled by framework

  • Reduced Technical Debt: Best practices built-in prevent common issues

  • Easier Debugging: Clear patterns make issues easier to identify and fix

4. Reduced Onboarding Effort:

  • Familiar Patterns: New developers quickly understand the structure

  • Reduced Learning Curve: Less custom code to learn

  • Standard Practices: Framework enforces enterprise best practices

5. Reduced Integration Effort:

  • Pre-configured Integration: Message bus, database, and API integration ready

  • Standardized Interfaces: Consistent API patterns across all modules

  • Built-in Security: Authentication and authorization patterns included

Real-World Enterprise Impact

For a 10-Module Enterprise Application:

Traditional Development:
├── Total Time: 430-730 days (1.5-2.5 years)
├── Team Size: 8-12 developers
├── Cost: $2-4 million
└── Risk: High (custom code complexity)

YourApplication Development:
├── Total Time: 240-390 days (8-13 months)
├── Team Size: 4-6 developers
├── Cost: $800K-1.5 million
└── Risk: Low (proven framework patterns)

Savings:
├── Time: 190-340 days (6-11 months)
├── Cost: $1.2-2.5 million
├── Team Size: 50% reduction
└── Risk: 70% reduction

Quality Improvements

  • Consistent Architecture - Every module follows identical patterns

  • Best Practices - Enterprise patterns built-in

  • Error Reduction - Framework prevents common mistakes

  • Maintainability - Clear separation of concerns

🎯 Bottom Line

YourApplication generates all infrastructure and plumbing code, delivering 95% reduction in core development time and 44-47% reduction in overall enterprise development lifecycle, while maintaining enterprise-grade quality and consistency.

Key Benefits:

  • ⚡ 95% faster core development - Complete infrastructure generated in 30 minutes

  • 🎯 Focus on business logic - Developers write only attributes and validation

  • 🏗️ Enterprise architecture out-of-the-box

  • 📊 44-47% overall time savings - Complete enterprise development cycle

  • 💰 50-60% cost reduction - Smaller teams, faster delivery

  • 📈 Consistent quality and patterns

  • 🚀 Ready to scale immediately

  • 🔒 70% risk reduction - Proven framework patterns

📦 Generated Business Modules

1. Orders Module - Complete E-Commerce Order Management

Generated Capabilities:

  • AddOrder - Create new orders with full validation

  • AddItemToOrder - Add products to existing orders

  • Order Management - Complete CRUD operations

  • Order Queries - Retrieve order information

Generated Infrastructure vs Developer Code:

Generated Plumbing Code (Framework):

// Auto-generated Command Handler - Orchestration
public partial class AddOrderHandler : IAddOrderHandler
{
    public virtual async Task Execute(AddOrderCommand cmd, IFlexServiceBusContext serviceBusContext)
    {
        _model = _flexHost.GetDomainModel<Order>().AddOrder(cmd);
        _repoFactory.GetRepo().InsertOrUpdate(_model);
        int records = await _repoFactory.GetRepo().SaveAsync();
        await this.Fire(EventCondition, serviceBusContext);
    }
}

// Auto-generated REST API Controller
[HttpPost]
[Route("AddOrder")]
public async Task<IActionResult> AddOrder([FromBody]AddOrderDto dto)
{
    return await RunService(201, dto, _processOrdersService.AddOrder);
}

Developer Writes (Business Logic):

// Developer adds business attributes and validation
public partial class Order : DomainModelBridge
{
    [Required]
    [StringLength(50)]
    public string CustomerId { get; set; }

    [Range(0.01, double.MaxValue)]
    public decimal TotalAmount { get; set; }

    // Developer adds custom business logic
    public virtual Order AddOrder(AddOrderCommand cmd)
    {
        // Custom validation logic
        if (cmd.Dto.TotalAmount > 10000)
        {
            throw new BusinessException("Order amount exceeds limit");
        }
        
        // Framework handles the rest
        this.Convert(cmd.Dto);
        this.SetAdded(cmd.Dto.GetGeneratedId());
        return this;
    }
}

// Developer can customize AutoMapper SelectTo when needed
public class OrderMapperConfiguration : FlexMapperProfile
{
    public OrderMapperConfiguration() : base()
    {
        CreateMap<Order, GetOrdersDto>()
            .ForMember(dest => dest.CustomerName, opt => opt.MapFrom(src => src.Customer.Name))
            .ForMember(dest => dest.StatusDisplay, opt => opt.MapFrom(src => GetStatusDisplay(src.Status)))
            .ForMember(dest => dest.DaysSinceCreated, opt => opt.MapFrom(src => (DateTime.UtcNow - src.CreatedDate).Days));
    }
}

2. Products Module - Product Catalog Management

Generated Capabilities:

  • AddProduct - Create new products

  • UpdateProduct - Modify existing products

  • Product Management - Full lifecycle management

  • Product Queries - Search and retrieve products

Architectural Benefits:

  • Consistent Patterns: Same architectural structure as Orders module

  • Reusable Components: Shared infrastructure and framework bridges

  • Type Safety: Strongly-typed DTOs and commands

  • Validation: Built-in input validation and error handling

3. Payments Module - Payment Processing

Generated Capabilities:

  • MakePayment - Process payment transactions

  • PaymentConfirmationCallBack - Handle payment confirmations

  • Payment Management - Complete payment lifecycle

  • Payment Queries - Retrieve payment information

Enterprise Features:

  • Event-Driven: Payment events for downstream processing

  • Audit Trail: Complete transaction logging

  • Error Handling: Robust error management

  • Integration Ready: External payment gateway integration

4. Customers Module - Customer Management

Generated Capabilities:

  • GetCustomers - Query customer information

  • Customer Management - Complete customer lifecycle

  • Customer Queries - Advanced search capabilities

📋 DTO Pattern & Clean Separation Architecture

DTO Structure and Clean Separation

The YourApplication solution implements a sophisticated DTO (Data Transfer Object) pattern that provides clean separation between different architectural layers, ensuring loose coupling and maintainability.

DTO Hierarchy and Organization:

// Input DTOs - API Layer to Application Layer
YourApplication.Application/ControlContracts/YourApplication.DTOs/
├── FeatureDtos/
│   ├── Orders/
│   │   ├── Input/
│   │   │   ├── AddOrder/AddOrderDto.cs
│   │   │   └── AddItemToOrder/AddItemToOrderDto.cs
│   │   └── Output/
│   ├── Products/
│   │   ├── Input/
│   │   │   ├── AddProduct/AddProductDto.cs
│   │   │   └── UpdateProduct/UpdateProductDto.cs
│   │   └── Output/
│   └── Payments/
│       ├── Input/
│       │   └── MakePayment/MakePaymentDto.cs
│       └── Output/
└── DomainDtos/
    ├── Order/OrderDto.cs
    ├── Product/ProductDto.cs
    ├── Payment/PaymentDto.cs
    └── OrderItem/OrderItemDto.cs

DTO Pattern Implementation:

// Input DTO - Clean API Contract
public partial class AddOrderDto : DtoBridge 
{
    // Auto-generated properties for API input
    // Validation attributes
    // Type safety
}

// Domain DTO - Business Entity Representation  
public partial class OrderDto : DtoBridge 
{
    // Domain model representation
    // Business logic encapsulation
    // Database-agnostic structure
}

// Output DTO - Query Results
public partial class GetCustomersDto : DtoBridge 
{
    // Optimized for read operations
    // Projection-specific properties
    // Performance-optimized structure
}

Clean Separation Benefits:

  1. API Layer Isolation:

    • Input DTOs shield domain models from API changes

    • Versioning support through DTO evolution

    • API-specific validation and formatting

  2. Domain Layer Protection:

    • Domain DTOs represent pure business concepts

    • No API or database concerns in domain

    • Business rules encapsulation

  3. Database Layer Abstraction:

    • Domain DTOs are database-agnostic

    • ORM mapping handled separately

    • Database schema changes don't affect domain

Handler-to-Domain Method Architecture

The solution follows a sophisticated architectural pattern where handlers orchestrate domain method calls, implementing several key enterprise patterns:

Command Handler Pattern:

public partial class AddOrderHandler : IAddOrderHandler
{
    // Dependency Injection - Clean Architecture
    protected readonly ILogger<AddOrderHandler> _logger;
    protected readonly IFlexHost _flexHost;           // Domain access
    protected readonly RepoFactory _repoFactory;      // Data access
    
    // Domain model instance
    protected Order? _model;
    protected FlexAppContextBridge? _flexAppContext;  // Context

    public virtual async Task Execute(AddOrderCommand cmd, IFlexServiceBusContext serviceBusContext)
    {
        // 1. Context Extraction
        _flexAppContext = cmd.Dto.GetAppContext();
        
        // 2. Repository Initialization
        _repoFactory.Init(cmd.Dto);
        
        // 3. Domain Method Invocation - CORE ARCHITECTURAL PATTERN
        _model = _flexHost.GetDomainModel<Order>().AddOrder(cmd);
        
        // 4. Persistence Layer
        _repoFactory.GetRepo().InsertOrUpdate(_model);
        int records = await _repoFactory.GetRepo().SaveAsync();
        
        // 5. Event Publishing
        await this.Fire(EventCondition, serviceBusContext);
    }
}

Domain Method Implementation:

// Domain Model with Business Logic
public partial class Order : DomainModelBridge
{
    public virtual Order AddOrder(AddOrderCommand cmd)
    {
        // 1. Input Validation
        Guard.AgainstNull("Order command cannot be empty", cmd);
        
        // 2. DTO to Domain Mapping
        this.Convert(cmd.Dto);
        
        // 3. Business Logic Application
        this.CreatedBy = cmd.Dto.GetAppContext()?.UserId;
        this.LastModifiedBy = cmd.Dto.GetAppContext()?.UserId;
        
        // 4. Domain State Management
        this.SetAdded(cmd.Dto.GetGeneratedId());
        
        // 5. Business Rules Enforcement
        // Custom business logic can be added here
        
        return this;
    }
}

Architectural Patterns Demonstrated:

  1. Command Pattern:

    • AddOrderCommand encapsulates request

    • Handler executes command

    • Domain model processes business logic

  2. Repository Pattern:

    • RepoFactory abstracts data access

    • Generic repository interface

    • Database-agnostic operations

  3. Domain-Driven Design:

    • Rich domain models with behavior

    • Business logic in domain layer

    • Ubiquitous language implementation

  4. CQRS (Command Query Responsibility Segregation):

    • Commands for write operations

    • Queries for read operations

    • Separate optimization paths

  5. Event-Driven Architecture:

    • Domain events for side effects

    • Loose coupling between modules

    • Asynchronous processing

AutoMapper Integration for DTO-Domain Mapping:

// AutoMapper Configuration
public class CoreMapperConfiguration : FlexMapperProfile
{
    public CoreMapperConfiguration() : base()
    {
        #region Input Mapping
        // DTO to Domain Model mapping
        CreateMap<AddOrderDto, Order>();
        CreateMap<AddProductDto, Product>();
        CreateMap<MakePaymentDto, Payment>();
        #endregion

        #region Output Mapping  
        // Domain Model to DTO mapping
        CreateMap<Order, OrderDto>();
        CreateMap<Product, ProductDto>();
        CreateMap<Payment, PaymentDto>();
        #endregion
    }
}

Mapping Benefits:

  1. Type Safety: Compile-time mapping validation

  2. Performance: Optimized object transformation

  3. Maintainability: Centralized mapping configuration

  4. Flexibility: Custom mapping rules support

Update Operations Pattern:

// Update Handler - Different Pattern for Existing Entities
public virtual async Task Execute(UpdateProductCommand cmd, IFlexServiceBusContext serviceBusContext)
{
    _flexAppContext = cmd.Dto.GetAppContext();
    _repoFactory.Init(cmd.Dto);
    
    // 1. Entity Retrieval
    _model = _repoFactory.GetRepo().FindAll<Product>()
        .Where(m => m.Id == cmd.Dto.Id)
        .FirstOrDefault();
    
    if (_model != null)
    {
        // 2. Domain Method Invocation
        _model.UpdateProduct(cmd);
        
        // 3. Persistence
        _repoFactory.GetRepo().InsertOrUpdate(_model);
        int records = await _repoFactory.GetRepo().SaveAsync();
        
        // 4. Event Publishing
        await this.Fire(EventCondition, serviceBusContext);
    }
}

Data Flow Architecture:

graph TB
    subgraph "API Layer"
        Controller[OrdersController]
        InputDTO[AddOrderDto]
        OutputDTO[OrderDto]
    end
    
    subgraph "Application Layer"
        Command[AddOrderCommand]
        Handler[AddOrderHandler]
        Service[ProcessOrdersService]
    end
    
    subgraph "Domain Layer"
        DomainModel[Order Domain Model]
        BusinessLogic[AddOrder Method]
        DomainDTO[OrderDto]
    end
    
    subgraph "Infrastructure Layer"
        Repository[Repository Factory]
        Database[(Database)]
        MessageBus[Event Bus]
    end
    
    Controller --> InputDTO
    InputDTO --> Command
    Command --> Handler
    Handler --> DomainModel
    DomainModel --> BusinessLogic
    BusinessLogic --> DomainDTO
    Handler --> Repository
    Repository --> Database
    Handler --> MessageBus
    DomainDTO --> OutputDTO
    OutputDTO --> Controller

Key Architectural Benefits:

  1. Clean Separation of Concerns:

    • Each layer has distinct responsibilities

    • DTOs provide clear boundaries

    • Domain logic isolated from infrastructure

  2. Testability:

    • Each layer can be tested independently

    • Mock-friendly interfaces

    • Clear dependency injection

  3. Maintainability:

    • Changes in one layer don't affect others

    • Clear data transformation points

    • Consistent patterns across modules

  4. Scalability:

    • Each layer can be scaled independently

    • Event-driven architecture for loose coupling

    • Database-agnostic design

🗄️ Domain Model-Driven Database Migrations

Revolutionary Migration Strategy

The YourApplication solution implements a groundbreaking approach where domain models automatically generate database schemas and migrations, eliminating the traditional manual database design process and dramatically improving developer and DevOps efficiency.

Migration Architecture Overview:

// Domain Model Definition
public partial class Order : DomainModelBridge
{
    // Domain properties automatically become database columns
    // Business logic drives schema design
    // Framework handles all database mapping
}

// Automatic Migration Generation
public class ApplicationEFDbContext : FlexEFDbContext
{
    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        base.OnModelCreating(modelBuilder);
        // Framework automatically configures all domain models
        // No manual DbSet definitions required
        // Automatic relationship mapping
    }
}

Multi-Database Migration Support:

// SQL Server Migration Context
public class ApplicationEFDbMigrationContext : ApplicationEFDbContext
{
    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        var connectionString = _configuration.GetSection("FlexBase")["AppDbConnection"];
        optionsBuilder.UseSqlServer(connectionString);
    }
}

// MySQL Migration Context  
public class ApplicationEFDbMigrationContext : ApplicationEFDbContext
{
    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        var connectionString = _configuration.GetSection("FlexBase")["AppDbConnection"];
        optionsBuilder.UseMySql(connectionString, ServerVersion.AutoDetect(connectionString));
    }
}

// PostgreSQL Migration Context
public class ApplicationEFDbMigrationContext : ApplicationEFDbContext
{
    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        var connectionString = _configuration.GetSection("FlexBase")["AppDbConnection"];
        optionsBuilder.UseNpgsql(connectionString);
    }
}

Developer Efficiency Benefits

1. Zero Manual Database Design:

// Traditional Approach (Manual):
// 1. Design database schema in SQL Management Studio
// 2. Create tables manually
// 3. Define relationships
// 4. Create indexes
// 5. Write migration scripts
// 6. Test migrations
// 7. Deploy to different environments
// Time: 2-4 hours per module

// YourApplication Approach (Automatic):
// 1. Define domain model
// 2. Run migration command
// 3. Framework generates everything
// Time: 5 minutes per module

2. Automatic Schema Generation:

  • Tables: Created from domain models automatically

  • Columns: Generated from domain properties

  • Relationships: Inferred from domain associations

  • Indexes: Auto-generated for performance

  • Constraints: Applied based on domain rules

  • Audit Fields: Automatically added (CreatedBy, LastModifiedBy, etc.)

3. Multi-Database Consistency:

# Single command generates migrations for all databases
dotnet ef migrations add InitialCreate --project YourApplication.Migrations.SqlServer
dotnet ef migrations add InitialCreate --project YourApplication.Migrations.MySql  
dotnet ef migrations add InitialCreate --project YourApplication.Migrations.PostgreSql

DevOps Efficiency Benefits

1. Automated Migration Pipeline:

# CI/CD Pipeline Example
stages:
  - generate_migrations:
      script:
        - dotnet ef migrations add $CI_COMMIT_SHA --project YourApplication.Migrations.SqlServer
        - dotnet ef migrations add $CI_COMMIT_SHA --project YourApplication.Migrations.MySql
        - dotnet ef migrations add $CI_COMMIT_SHA --project YourApplication.Migrations.PostgreSql
      artifacts:
        paths:
          - **/Migrations/
  
  - deploy_migrations:
      script:
        - dotnet ef database update --project YourApplication.Migrations.SqlServer
        - dotnet ef database update --project YourApplication.Migrations.MySql
        - dotnet ef database update --project YourApplication.Migrations.PostgreSql

2. Environment Consistency:

  • Development: Auto-generated schema matches production

  • Staging: Identical database structure across environments

  • Production: Zero manual intervention required

  • Multi-Tenant: Automatic tenant database creation

3. Rollback Safety:

// Automatic rollback support
dotnet ef database update PreviousMigration --project YourApplication.Migrations.SqlServer
dotnet ef migrations remove --project YourApplication.Migrations.SqlServer

Time and Energy Savings

Development Time Comparison:

Task
Traditional Approach
YourApplication Approach
Time Saved

Database Design

2-4 hours

5 minutes

95%

Migration Creation

1-2 hours

2 minutes

98%

Multi-DB Setup

4-6 hours

10 minutes

97%

Schema Updates

1-3 hours

3 minutes

98%

Testing Migrations

2-4 hours

5 minutes

96%

Deployment

1-2 hours

5 minutes

95%

Total per Module

11-21 hours

30 minutes

97%

DevOps Benefits:

  1. Zero Manual Database Scripts:

    • No SQL scripts to write or maintain

    • No manual database configuration

    • No environment-specific database setup

  2. Automatic Multi-Database Support:

    • Single domain model generates multiple database schemas

    • Consistent structure across all database types

    • No database-specific migration scripts

  3. Version Control Integration:

    • Migrations are code-first and version controlled

    • Easy to track schema changes

    • Rollback capabilities built-in

  4. Environment Parity:

    • Identical database structure across all environments

    • No environment-specific database issues

    • Consistent deployment process

Advanced Migration Features

1. Seed Data Integration:

// Automatic seed data generation
public partial class Product : DomainModelBridge
{
    // Domain model includes seed data
    // Automatically populated during migration
    // Test data generation
}

2. Multi-Tenant Migration Support:

// Tenant-specific migrations
public class TenantMigrationContext : ApplicationTenantEFDbContext
{
    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        var connectionString = _configuration.GetSection("FlexBase")["AppDbTenantConnection"];
        optionsBuilder.UseMySql(connectionString, ServerVersion.AutoDetect(connectionString));
    }
}

3. Custom Migration Configuration:

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    base.OnModelCreating(modelBuilder);
    
    // Custom indexes
    modelBuilder.Entity<Order>()
        .HasIndex(o => o.CreatedDate)
        .HasDatabaseName("IX_Orders_CreatedDate");
    
    // Custom constraints
    modelBuilder.Entity<Product>()
        .HasCheckConstraint("CK_Product_Price", "Price > 0");
}

Real-World Impact

For Development Teams:

  • Focus on Business Logic: Developers focus on domain models, not database schemas

  • Faster Iterations: Schema changes take minutes, not hours

  • Reduced Errors: Framework prevents common database design mistakes

  • Consistent Patterns: All modules follow identical database patterns

For DevOps Teams:

  • Simplified Deployments: No manual database configuration

  • Environment Consistency: Identical databases across all environments

  • Automated Pipelines: Database migrations integrated into CI/CD

  • Reduced Support: Fewer database-related issues and tickets

For Business:

  • Faster Time-to-Market: Database setup no longer a bottleneck

  • Lower Costs: Reduced development and maintenance time

  • Higher Quality: Consistent, tested database schemas

  • Scalability: Easy to add new modules and features

Migration Command Examples:

# Generate new migration
dotnet ef migrations add AddOrderModule --project YourApplication.Migrations.SqlServer

# Update database
dotnet ef database update --project YourApplication.Migrations.SqlServer

# Generate script for manual deployment
dotnet ef migrations script --project YourApplication.Migrations.SqlServer

# Remove last migration
dotnet ef migrations remove --project YourApplication.Migrations.SqlServer

# Generate for specific environment
dotnet ef migrations add ProductionRelease --project YourApplication.Migrations.SqlServer --environment Production

🏗️ Architectural Benefits Demonstrated

1. Rapid Development Acceleration

Code Generation Efficiency:

  • 90% Less Boilerplate: Framework generates complete CRUD operations

  • Consistent Patterns: Every module follows identical architectural patterns

  • Zero Configuration: Auto-generated dependency injection and routing

  • Instant API: REST endpoints created automatically

Development Time Comparison:

Traditional Development: 2-3 days per module
YourApplication Generated: 30 minutes per module
Time Savings: 95% reduction in development time

2. Enterprise-Grade Architecture Out-of-the-Box

Clean Architecture Implementation:

// Each module automatically implements:
├── Domain Layer (Business Logic)
│   ├── Domain Models with behavior
│   ├── Business rules and validation
│   └── Domain events
├── Application Layer (Use Cases)
│   ├── Command Handlers (CQRS)
│   ├── Query Handlers (CQRS)
│   └── Application Services
├── Infrastructure Layer
│   ├── Repository Pattern
│   ├── Message Bus Integration
│   └── Database Abstraction
└── Presentation Layer
    ├── REST API Controllers
    ├── DTOs and Validation
    └── Error Handling

CQRS Pattern Implementation:

  • Commands: AddOrderCommand, AddProductCommand, MakePaymentCommand

  • Queries: GetCustomers, GetOrders, GetProducts

  • Separation: Clear distinction between read and write operations

  • Scalability: Independent scaling of read/write workloads

3. Framework Integration Benefits

Sumeru.Flex Framework Integration:

// Automatic Framework Bridge Implementation
public partial class OrdersController : FlexControllerBridge<OrdersController>
{
    // Auto-generated base functionality
    // Built-in error handling
    // Automatic logging
    // Request/Response transformation
}

// Domain Model Integration
public partial class Order : DomainModelBridge
{
    // Built-in audit fields
    // Automatic ID generation
    // Row state management
    // Validation framework
}

Built-in Enterprise Features:

  • Logging: Structured logging with correlation IDs

  • Validation: FluentValidation integration

  • Mapping: AutoMapper configuration

  • Auditing: Automatic audit trail creation

  • Security: Built-in security patterns

4. Database and Messaging Integration

Multi-Database Support:

// Automatic Repository Factory
_repoFactory.Init(cmd.Dto);
_repoFactory.GetRepo().InsertOrUpdate(_model);
await _repoFactory.GetRepo().SaveAsync();

// Supported Databases:
// - SQL Server
// - MySQL  
// - PostgreSQL
// - Multi-tenant configurations

Message Bus Integration:

// Event-Driven Architecture
await this.Fire(EventCondition, serviceBusContext);

// Supported Message Buses:
// - RabbitMQ
// - Azure Service Bus
// - SQL Server Transport
// - Learning Transport (Development)

5. Type Safety and Developer Experience

Strongly-Typed Contracts:

// Auto-generated DTOs
public partial class AddOrderDto : DtoBridge { }
public partial class OrderDto : DtoBridge { }

// Auto-generated Commands
public class AddOrderCommand : FlexCommandBridge<AddOrderDto, FlexAppContextBridge> { }

// Auto-generated Handlers
public partial class AddOrderHandler : IAddOrderHandler { }

IntelliSense and Compile-Time Safety:

  • Full IntelliSense: Complete code completion

  • Compile-Time Validation: Catch errors before runtime

  • Refactoring Safety: IDE refactoring works across all layers

  • Type Consistency: Same types across all layers

6. Scalability and Performance

Horizontal Scaling Ready:

  • Stateless Design: All handlers are stateless

  • Load Balancing: Built-in support for multiple instances

  • Database Sharding: Multi-tenant database support

  • Message Queuing: Asynchronous processing

Performance Optimizations:

  • Repository Pattern: Optimized data access

  • Connection Pooling: Automatic connection management

  • Caching Ready: Framework prepared for caching implementation

  • Async/Await: Full async support throughout

🎯 Business Value Demonstration

1. Time-to-Market Acceleration

Module Creation Speed:

Complete Business Module (Orders/Products/Payments):
├── Domain Models: Auto-generated
├── Command Handlers: Auto-generated  
├── Query Handlers: Auto-generated
├── REST Controllers: Auto-generated
├── DTOs and Validation: Auto-generated
├── Database Integration: Auto-generated
├── Message Bus Integration: Auto-generated
└── Testing Infrastructure: Auto-generated

Total Development Time: 30 minutes
Traditional Development Time: 2-3 weeks

2. Consistency and Quality

Architectural Consistency:

  • Identical Patterns: Every module follows the same structure

  • Best Practices: Enterprise patterns built-in

  • Code Quality: Consistent, readable, maintainable code

  • Documentation: Auto-generated XML documentation

Error Reduction:

  • Type Safety: Compile-time error detection

  • Validation: Built-in input validation

  • Error Handling: Consistent error management

  • Logging: Comprehensive logging and monitoring

3. Maintainability and Extensibility

Easy Maintenance:

  • Clear Separation: Well-defined layer boundaries

  • Single Responsibility: Each class has one purpose

  • Dependency Injection: Easy to test and modify

  • Configuration: Centralized configuration management

Simple Extensions:

// Adding new business logic is straightforward
public virtual Order AddOrder(AddOrderCommand cmd)
{
    // Existing generated code...
    
    // Add custom business logic
    if (cmd.Dto.TotalAmount > 1000)
    {
        this.ApplyDiscount(0.1); // 10% discount for large orders
    }
    
    return this;
}

4. Team Productivity

Developer Onboarding:

  • Familiar Patterns: Standard enterprise patterns

  • Self-Documenting: Clear code structure

  • Consistent Style: Uniform coding standards

  • Quick Learning: New developers productive immediately

Parallel Development:

  • Module Independence: Teams can work on different modules

  • Clear Interfaces: Well-defined module boundaries

  • Shared Infrastructure: Common framework and utilities

  • Version Control: Clean, organized code structure

🔧 Technical Implementation Highlights

1. Auto-Generated Infrastructure

Complete Module Structure:

OrdersModule/
├── Domain/
│   ├── Order.cs (Domain Model)
│   ├── AddOrder.cs (Business Logic)
│   └── Order_SeedData.cs (Test Data)
├── Application/
│   ├── AddOrderHandler.cs (Command Handler)
│   ├── AddItemToOrderHandler.cs (Command Handler)
│   └── ProcessOrdersService.cs (Application Service)
├── Presentation/
│   ├── OrdersController.cs (REST API)
│   ├── AddOrderDto.cs (Input DTO)
│   └── OrderDto.cs (Output DTO)
├── Infrastructure/
│   ├── OrderMapperConfiguration.cs (AutoMapper)
│   └── Repository Integration (Database)
└── Messaging/
    ├── AddOrderCommand.cs (Command)
    └── Event Integration (NServiceBus)

2. Framework Integration Benefits

Sumeru.Flex Framework Features:

  • FlexControllerBridge: Automatic controller base functionality

  • FlexCommandBridge: Command pattern implementation

  • FlexQueryBridge: Query pattern implementation

  • DomainModelBridge: Domain model base functionality

  • DtoBridge: DTO base functionality

Built-in Enterprise Features:

  • Audit Trail: Automatic CreatedBy, LastModifiedBy tracking

  • Row State Management: Added, Modified, Deleted state tracking

  • ID Generation: Automatic unique ID generation

  • Context Management: Request context and user information

  • Validation Framework: Built-in validation patterns

3. Database and Messaging Integration

Repository Pattern:

// Automatic repository management
_repoFactory.Init(cmd.Dto);
_repoFactory.GetRepo().InsertOrUpdate(_model);
int records = await _repoFactory.GetRepo().SaveAsync();

Message Bus Integration:

// Event-driven architecture
await this.Fire(EventCondition, serviceBusContext);

📊 Performance and Scalability Benefits

1. Performance Optimizations

Built-in Performance Features:

  • Async/Await: Full asynchronous programming support

  • Connection Pooling: Automatic database connection management

  • Repository Pattern: Optimized data access patterns

  • Lazy Loading: On-demand data loading

  • Caching Ready: Framework prepared for caching implementation

2. Scalability Features

Horizontal Scaling:

  • Stateless Design: All components are stateless

  • Load Balancing: Built-in support for multiple instances

  • Database Sharding: Multi-tenant database support

  • Message Queuing: Asynchronous processing and decoupling

Microservices Ready:

  • Independent Modules: Each module can be deployed separately

  • Clear Boundaries: Well-defined module interfaces

  • Event-Driven: Loose coupling through events

  • API Gateway Ready: RESTful API design

🎯 Conclusion

The YourApplication solution demonstrates a powerful approach to enterprise application development that:

Accelerates Development:

  • 95% reduction in development time for new modules

  • Consistent patterns across all business modules

  • Zero configuration for basic functionality

  • Instant API generation

Ensures Quality:

  • Enterprise-grade architecture out-of-the-box

  • Type safety and compile-time validation

  • Built-in best practices and patterns

  • Comprehensive error handling and logging

Enables Scalability:

  • Horizontal scaling ready

  • Microservices architecture support

  • Event-driven design for loose coupling

  • Multi-database and messaging support

Improves Maintainability:

  • Clear separation of concerns

  • Consistent code structure

  • Easy testing and debugging

  • Simple extensions and modifications

This framework provides a solid foundation for building enterprise applications that are fast to develop, easy to maintain, and ready to scale - enabling teams to focus on business logic rather than infrastructure concerns.

This demonstration showcases the actual generated capabilities of the Application created with Flexbase and highlights how the architectural patterns and framework integration provide significant business value through accelerated development, consistent quality, and enterprise-grade scalability.

PreviousArchitecture OverviewNextCommon Configurations

Last updated