Boutquin.Domain 0.7.0

Boutquin.Domain

A .NET domain layer library providing DDD building blocks, guard clauses, result types, JSON converters, and ASP.NET Core middleware for modular monolith applications.

Solution Structure

The solution contains three library projects and a test project:

Domain Project

Abstractions

The building blocks for Domain-Driven Design:

• Entity<TEntityId> — Abstract base class with identity-based equality, domain event buffering, and ORM-compatible constructors.
• Result / Result<TValue> — Functional error handling — return success/failure instead of throwing exceptions.
• Error — Immutable record representing a domain error with code and name.
• IEntity — Interface for entities that generate domain events.
• IDomainEvent — Marker interface for domain events (implements INotification).
• IUnitOfWork — Defines the persistence boundary (SaveChangesAsync).

Helpers

• Guard — Static utility class for parameter validation with two API styles: expression-based (auto-extracts parameter names) and CallerArgumentExpression-based (zero overhead).
• GuardCondition — Fluent chaining helper for Guard.Against().With<TException>().
• StronglyTypedId<TValue> — Abstract record for wrapping primitives as domain-specific ID types, preventing primitive obsession.

Extensions

• StringExtensions — IsNullOrEmpty, IsNullOrWhiteSpace, ToUppercaseFirst, ToLowerCaseFirst, Compare, CompareOrdinal, Format.
• DateTimeExtensions — ConvertTimeZone for converting between time zones.
• EnumExtensions — GetDescription for retrieving [Description] attribute values.
• ResultExtensions — Match methods for functional-style pattern matching on Result types.
• JsonElementExtensions — ToObject<T> for deserializing JsonElement to typed objects.
• DecimalArrayExtensions — Variance and StandardDeviation for decimal arrays.

Converters

• DateOnlyConverter / DateOnlyDictionaryConverterFactory — Custom System.Text.Json converters for DateOnly values and dictionaries with DateOnly keys (works around a System.Text.Json limitation).

Exceptions

• DomainExceptions — Self-describing exception hierarchy mapping to HTTP status codes (400–503), plus non-HTTP exceptions for data validation (EmptyOrNullArrayException, InsufficientDataException, etc.).

Boutquin.AspNetCore Project

• CustomExceptionHandlerMiddleware — Catches unhandled exceptions and produces RFC 7807 ProblemDetails JSON responses with application/problem+json content type.
• ModuleExtensions — Module discovery, registration, and endpoint mapping for modular monolith applications. Includes an injectable assembly resolver for testability.
• IModule — Interface for self-registering application modules (RegisterModule + MapEndpoints).

Boutquin.Validation Project

• ValidationException — Exception wrapping FluentValidation failures with structured error data. Integrates with the middleware to produce grouped error responses.

Quick Start

// 1. Define a domain entity with strongly typed ID:
public record OrderId(Guid Value) : StronglyTypedId<Guid>(Value);

public sealed class Order : Entity<OrderId>
{
    public Order(OrderId id) : base(id) { }

    public void Place()
    {
        // Business logic...
        RaiseDomainEvent(new OrderPlacedEvent(Id));
    }
}

// 2. Use the Result pattern for operations that can fail:
public Result<Order> GetOrder(OrderId id)
{
    var order = repository.Find(id);
    return order is not null
        ? Result.Success(order)
        : Result.Failure<Order>(new Error("Order.NotFound", "Order not found"));
}

// 3. Register modules in Startup:
builder.Services.RegisterModules();
var app = builder.Build();
app.UseCustomExceptionHandler();
app.MapEndpoints();

// 4. Throw domain exceptions — middleware handles the rest:
throw new NotFoundException("Order 42 was not found.");
// -> 404 ProblemDetails JSON response

Architecture

See ARCHITECTURE.md for how the components fit together — layers, interface hierarchy, data flow, and component navigation.

Contributing

See CONTRIBUTING.md for guidelines on reporting bugs, suggesting enhancements, and submitting pull requests. This project adheres to the Contributor Covenant Code of Conduct.

License

This project is licensed under the Apache 2.0 License. See the LICENSE file for more information.