Nera.Lib.Domain

A comprehensive .NET 9 library providing domain-driven design (DDD) building blocks for Nera applications. This library includes essential domain modeling constructs such as entities, value objects, aggregates, domain events, and CQRS patterns.

Features

🏗️ Domain Building Blocks

• Entities: Base classes for domain entities with built-in auditing and tracking
• Value Objects: Immutable objects distinguished by their state
• Aggregates: Aggregate root implementation with domain event support
• Domain Events: Event-driven architecture support with MediatR integration

🔄 CQRS Support

• Command Handlers: Base classes for command processing
• Query Handlers: Base classes for query processing
• Behaviors: Logging and validation pipeline behaviors
• Domain Event Handlers: Reactive event processing

📦 Repository Patterns

• Generic Repository: Standard CRUD operations
• Read/Write Separation: Separate read and write repositories
• Specification Pattern: Query specification support
• Unit of Work: Transaction management

🎯 Additional Features

• Auditable Entities: Automatic tracking of creation and modification
• Multi-tenant Support: Built-in tenant isolation
• Pagination: Standardized pagination utilities
• Filters & Sorting: Query filtering and ordering capabilities
• Outbox Pattern: Reliable event publishing

Installation

Install the package via NuGet Package Manager:

dotnet add package Nera.Lib.Domain

Or via Package Manager Console:

Install-Package Nera.Lib.Domain

Quick Start

1. Creating an Entity

using Nera.Lib.Domain.Entities; public class Product : BaseEntity<Guid> { public string Name { get; private set; } public decimal Price { get; private set; } public Product(string name, decimal price) { Name = name; Price = price; } public void UpdatePrice(decimal newPrice) { if (newPrice <= 0) throw new ArgumentException("Price must be positive"); Price = newPrice; // Domain event will be automatically tracked AddDomainEvent(new ProductPriceChangedEvent(Id, newPrice)); } }

2. Creating a Value Object

using Nera.Lib.Domain.ValueObjects; public class Money : ValueObject { public decimal Amount { get; } public string Currency { get; } public Money(decimal amount, string currency) { Amount = amount; Currency = currency; } protected override IEnumerable<object> GetEqualityComponents() { yield return Amount; yield return Currency; } }

3. Creating an Aggregate Root

using Nera.Lib.Domain.Aggregates; public class Order : AggregateRoot<Guid> { private readonly List<OrderItem> _items = new(); public string OrderNumber { get; private set; } public OrderStatus Status { get; private set; } public IReadOnlyList<OrderItem> Items => _items.AsReadOnly(); public Order(string orderNumber) { OrderNumber = orderNumber; Status = OrderStatus.Draft; AddDomainEvent(new OrderCreatedEvent(Id, orderNumber)); } public void AddItem(Product product, int quantity) { var item = new OrderItem(product.Id, quantity, product.Price); _items.Add(item); AddDomainEvent(new OrderItemAddedEvent(Id, item.ProductId, quantity)); } }

4. Using CQRS

using Nera.Lib.Domain.CQRS; // Command public record CreateProductCommand(string Name, decimal Price) : ICommand<Guid>; // Command Handler public class CreateProductHandler : BaseCommandHandler<CreateProductCommand, Guid> { private readonly IRepository<Product> _repository; public CreateProductHandler(IRepository<Product> repository) { _repository = repository; } protected override async Task<Guid> ExecuteAsync( CreateProductCommand request, CancellationToken cancellationToken) { var product = new Product(request.Name, request.Price); await _repository.AddAsync(product, cancellationToken); return product.Id; } }

5. Repository Usage

using Nera.Lib.Domain.Repositories; public interface IProductRepository : IRepository<Product> { Task<IEnumerable<Product>> GetByPriceRangeAsync(decimal min, decimal max); } public class ProductRepository : IProductRepository { // Implementation using your preferred ORM }

Architecture Components

Entity Hierarchy

IEntity<TKey> ├── BaseEntity<TKey> │ ├── AuditableEntity<TKey> │ └── Entity<TKey> └── AggregateRoot<TKey>

Event System

• Domain Events: Business events that occur within aggregates
• Event Publisher: Publishes events to registered handlers
• Event Handlers: Process domain events reactively

Repository Pattern

• IReadRepository: Read-only operations
• IWriteRepository: Write operations
• IRepository: Combined read/write interface
• ISpecification: Query specifications

Configuration

Dependency Injection

// Program.cs or Startup.cs services.AddScoped<IRepository<Product>, ProductRepository>(); services.AddScoped<IUnitOfWork, UnitOfWork>(); // Register MediatR for CQRS services.AddMediatR(cfg => cfg.RegisterServicesFromAssembly(typeof(Program).Assembly));

Entity Framework Integration

public class ApplicationDbContext : DbContext { public DbSet<Product> Products { get; set; } protected override void OnModelCreating(ModelBuilder modelBuilder) { // Configure your entities modelBuilder.ApplyConfigurationsFromAssembly(typeof(ApplicationDbContext).Assembly); } }

Best Practices

1. Domain Events: Use domain events for cross-aggregate communication
2. Value Objects: Prefer value objects for concepts without identity
3. Aggregates: Keep aggregates small and focused
4. Repository: Use specifications for complex queries
5. CQRS: Separate read and write operations for better performance

Dependencies

• .NET 9.0: Target framework
• MediatR.Contracts: For CQRS pattern implementation
• Nera.Lib.Core: Core utilities and extensions

Contributing

1. Fork the repository
2. Create a feature branch (git checkout -b feature/amazing-feature)
3. Commit your changes (git commit -m 'Add some amazing feature')
4. Push to the branch (git push origin feature/amazing-feature)
5. Open a Pull Request

License

This project is licensed under the MIT License - see the LICENSE file for details.

Support

For support and questions, please:

• Create an issue in the repository
• Contact the Nextera Systems team
• Review the documentation and examples

Authors

Nextera Systems - Initial work and maintenance

---

Part of the Nera Libraries ecosystem for building robust, scalable applications.