ECommerceApp/
├── src/
│   ├── ECommerceApp/                    # Main Web API Application
│   │   ├── Controllers/                 # API Controllers
│   │   ├── Program.cs                   # Application entry point
│   │   └── ECommerceApp.csproj
│   ├── ECommerceApp.Shared/             # Shared Kernel
│   │   ├── Events/                      # Domain Events
│   │   ├── Kernel/                      # Base entities, interfaces
│   │   └── ECommerceApp.Shared.csproj
│   └── Modules/
│       ├── Orders/                      # Orders Module
│       │   ├── Application/             # Use cases, commands, queries
│       │   ├── Domain/                  # Domain entities, events
│       │   ├── Infrastructure/          # Data access, repositories
│       │   ├── OrdersModule.cs          # Module registration
│       │   └── ECommerceApp.Modules.Orders.csproj
│       ├── Products/                    # Products Module
│       │   ├── Application/
│       │   ├── Domain/
│       │   ├── Infrastructure/
│       │   ├── ProductsModule.cs
│       │   └── ECommerceApp.Modules.Products.csproj
│       └── Customers/                   # Customers Module
│           ├── Domain/
│           ├── Infrastructure/
│           ├── CustomersModule.cs
│           └── ECommerceApp.Modules.Customers.csproj

public class Product : BaseEntity
{
    public string Name { get; private set; }
    public string Description { get; private set; }
    public decimal Price { get; private set; }
    public int StockQuantity { get; private set; }

    public void UpdatePrice(decimal newPrice)
    {
        if (newPrice <= 0)
            throw new ArgumentException("Price must be positive");
        
        Price = newPrice;
        // Raise domain event
        RaiseDomainEvent(new ProductPriceUpdatedEvent(Id, newPrice));
    }

    public void UpdateStock(int quantity)
    {
        if (StockQuantity + quantity < 0)
            throw new InvalidOperationException("Insufficient stock");
            
        StockQuantity += quantity;
        RaiseDomainEvent(new ProductStockUpdatedEvent(Id, StockQuantity));
    }
}

public class UpdateProductPriceCommand
{
    public Guid ProductId { get; set; }
    public decimal NewPrice { get; set; }
}

public class UpdateProductPriceHandler
{
    private readonly IProductRepository _repository;

    public async Task<Result> Handle(UpdateProductPriceCommand command)
    {
        var product = await _repository.GetByIdAsync(command.ProductId);
        if (product == null)
            return Result.Failure("Product not found");

        product.UpdatePrice(command.NewPrice);
        await _repository.UpdateAsync(product);
        
        return Result.Success();
    }
}

public class Order : BaseEntity
{
    public Guid CustomerId { get; private set; }
    public OrderStatus Status { get; private set; }
    public List<OrderItem> Items { get; private set; } = new();
    public decimal TotalAmount => Items.Sum(item => item.TotalPrice);

    public static Order Create(Guid customerId, List<OrderItem> items)
    {
        var order = new Order
        {
            CustomerId = customerId,
            Status = OrderStatus.Pending,
            Items = items
        };
        
        order.RaiseDomainEvent(new OrderCreatedEvent(order.Id, customerId));
        return order;
    }

    public void Confirm()
    {
        if (Status != OrderStatus.Pending)
            throw new InvalidOperationException("Only pending orders can be confirmed");
            
        Status = OrderStatus.Confirmed;
        RaiseDomainEvent(new OrderConfirmedEvent(Id));
    }
}

// ใน Orders Module
public interface IProductService
{
    Task<Product?> GetProductAsync(Guid productId);
    Task<bool> IsProductAvailableAsync(Guid productId, int quantity);
}

// ใน Products Module
public class ProductService : IProductService
{
    private readonly IProductRepository _repository;

    public async Task<Product?> GetProductAsync(Guid productId)
    {
        return await _repository.GetByIdAsync(productId);
    }

    public async Task<bool> IsProductAvailableAsync(Guid productId, int quantity)
    {
        var product = await _repository.GetByIdAsync(productId);
        return product != null && product.StockQuantity >= quantity;
    }
}

public class OrderConfirmedEvent : IDomainEvent
{
    public Guid OrderId { get; }
    public DateTime OccurredOn { get; }

    public OrderConfirmedEvent(Guid orderId)
    {
        OrderId = orderId;
        OccurredOn = DateTime.UtcNow;
    }
}

// Event Handler ใน Products Module
public class OrderConfirmedEventHandler : IEventHandler<OrderConfirmedEvent>
{
    public async Task Handle(OrderConfirmedEvent @event)
    {
        // Update inventory, send notifications, etc.
    }
}

git clone https://github.com/suriyasonp/modular-monolith-ecommerce.git
cd modular-monolith-ecommerce

# วิธีที่ 1: ใช้ script (แนะนำ)
./run.sh

# วิธีที่ 2: รันด้วยตนเอง
dotnet build
dotnet run --project src/ECommerceApp/ECommerceApp.csproj

./test-api.sh

# ดู Products ทั้งหมด
curl http://localhost:5000/api/products

# สร้าง Customer ใหม่
curl -X POST http://localhost:5000/api/customers \
  -H "Content-Type: application/json" \
  -d '{
    "firstName": "สมชาย",
    "lastName": "ใจดี", 
    "email": "[email protected]",
    "address": {
      "street": "123 ถนนสุขุมวิท",
      "city": "กรุงเทพฯ",
      "state": "กทม",
      "zipCode": "10110",
      "country": "ไทย"
    }
  }'

# สร้าง Order ใหม่
curl -X POST http://localhost:5000/api/orders \
  -H "Content-Type: application/json" \
  -d '{
    "customerId": "customer-guid-here",
    "items": [
      {
        "productId": "product-guid-here",
        "quantity": 2
      }
    ]
  }'

// แยก bounded context ชัดเจน
namespace ECommerceApp.Modules.Orders.Domain
{
    public class Order { } // Order ใน Orders context
}

namespace ECommerceApp.Modules.Catalog.Domain  
{
    public class Product { } // Product ใน Catalog context
}

// ❌ ผิด: High-level module พึ่งพา low-level
public class OrderService
{
    private SqlOrderRepository _repository; // Direct dependency
}

// ✅ ถูก: Dependency Inversion
public class OrderService
{
    private readonly IOrderRepository _repository; // Interface dependency
}

public static class ModuleExtensions
{
    public static IServiceCollection AddOrdersModule(this IServiceCollection services)
    {
        services.AddScoped<IOrderRepository, SqlOrderRepository>();
        services.AddScoped<OrderService>();
        services.AddMediatR(typeof(OrdersModule));
        return services;
    }
}

// Interface-based communication สำหรับ immediate consistency
public interface IInventoryService
{
    Task<bool> IsAvailableAsync(Guid productId, int quantity);
    Task ReserveAsync(Guid productId, int quantity);
}

// Event-based communication สำหรับ eventual consistency
public class OrderConfirmedEvent : IDomainEvent
{
    public Guid OrderId { get; }
    public List<OrderItem> Items { get; }
}

[EventHandler]
public class UpdateInventoryHandler : IEventHandler<OrderConfirmedEvent>
{
    public async Task Handle(OrderConfirmedEvent @event)
    {
        // Update inventory asynchronously
    }
}

-- Orders schema
CREATE SCHEMA Orders;
CREATE TABLE Orders.Orders (...);
CREATE TABLE Orders.OrderItems (...);

-- Products schema  
CREATE SCHEMA Products;
CREATE TABLE Products.Products (...);
CREATE TABLE Products.Categories (...);

public class OrdersDbContext : DbContext
{
    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        optionsBuilder.UseSqlServer(connectionString, options =>
        {
            options.MigrationsHistoryTable("__OrdersMigrationsHistory", "Orders");
        });
    }
}

[Test]
public async Task CreateOrder_WithValidProducts_ShouldSucceed()
{
    // Arrange
    var productService = ServiceProvider.GetService<IProductService>();
    var orderService = ServiceProvider.GetService<IOrderService>();
    
    // Act
    var result = await orderService.CreateOrderAsync(customerId, orderItems);
    
    // Assert
    Assert.IsTrue(result.IsSuccess);
}

[Test]
public void ProductService_ShouldImplementIProductService()
{
    // Verify that ProductService implements all required interfaces
    var productService = new ProductService();
    Assert.IsInstanceOf<IProductService>(productService);
}

// Replace in-memory repositories with Entity Framework Core
services.AddDbContext<OrdersDbContext>(options =>
    options.UseSqlServer(connectionString));

services.AddScoped<IOrderRepository, EfOrderRepository>();

services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
    .AddJwtBearer(options => {
        options.TokenValidationParameters = new TokenValidationParameters
        {
            ValidateIssuer = true,
            ValidateAudience = true,
            ValidateLifetime = true,
            ValidateIssuerSigningKey = true
        };
    });

public class CreateOrderCommandValidator : AbstractValidator<CreateOrderCommand>
{
    public CreateOrderCommandValidator()
    {
        RuleFor(x => x.CustomerId).NotEmpty();
        RuleFor(x => x.Items).NotEmpty();
        RuleForEach(x => x.Items).SetValidator(new OrderItemValidator());
    }
}

public class GlobalExceptionMiddleware
{
    public async Task InvokeAsync(HttpContext context, RequestDelegate next)
    {
        try
        {
            await next(context);
        }
        catch (DomainException ex)
        {
            await HandleDomainExceptionAsync(context, ex);
        }
        catch (Exception ex)
        {
            await HandleGenericExceptionAsync(context, ex);
        }
    }
}

services.AddHealthChecks()
    .AddDbContextCheck<OrdersDbContext>("orders-db")
    .AddDbContextCheck<ProductsDbContext>("products-db")
    .AddUrlGroup(new Uri("https://external-api.com/health"), "external-api");

services.AddSerilog((context, config) =>
{
    config.ReadFrom.Configuration(context.Configuration)
          .Enrich.WithProperty("Module", "Orders")
          .WriteTo.Console()
          .WriteTo.File("logs/orders-.log", rollingInterval: RollingInterval.Day);
});

public class OrderMetrics
{
    private static readonly Counter OrdersCreated = Metrics
        .CreateCounter("orders_created_total", "Total number of orders created");
        
    public void IncrementOrdersCreated() => OrdersCreated.Inc();
}