Majal.EntityFrameworkCore 1.0.0-alpha.43

<div align="center"> <img src="assets/logo.svg" alt="Majal Logo" width="200" /> </div>

<div align="center" style="margin-top: 20px;">

</div>

Overview

Majal is a C# source generator library that helps you implement Domain-Driven Design (DDD) patterns with minimal boilerplate. It provides source generators for:

• Entities (with equality and comparison helpers)
• Aggregates (domain events publishing)
• Value Objects (with equality and comparison helpers)
• Archivables (Soft-deletion)
• Auditables (Creation/Update tracking)
• Translatables (Multi-language support)
• Ordinals (Sort order)
• DTOs (generated from a type's factory method, with reverse conversion back to the domain type)

The library ships as a set of Roslyn analyzer/source generator packages that can be referenced from any .NET project.

NuGet Packages

The core generators live in Majal. EF Core integration and DTO generation are separate, opt-in packages so you only take the dependencies you need:

<PackageReference Include="Majal" Version="<VERSION>" />


<PackageReference Include="Majal.EntityFrameworkCore" Version="<VERSION>" />


<PackageReference Include="Majal.DataTransferObjects" Version="<VERSION>" />

Each package contains its generators and the required analyzer DLLs.

Building the Project

The solution targets .NET Standard 2.0 and can be built with the .NET CLI:

# Restore packages
dotnet restore

# Build the generators
dotnet build src/Majal/Majal.csproj -c Release

The generated analyzer DLL will be placed in src/Majal/bin/Debug/netstandard2.0/ (or Release folder).

To build the samples against locally generated packages, run this from the repository root:

./scripts/build.ps1

The script writes the packages to .artifacts, restores the sample from that local feed, and builds it in Release configuration.

Running Tests

The repository contains four test projects: Majal.Tests (generator/analyzer unit tests), Majal.FunctionalTests (compiled runtime behavior), Majal.DataTransferObjects.Tests (DTO generator unit tests), and Majal.EntityFrameworkCore.Tests (EF Core interceptor/convention/value-converter integration tests against a real SQLite database). Run them all with:

dotnet test Majal.slnx

Samples

• samples/EShop -- an ASP.NET Core + Wolverine.Http API exercising every Majal generator feature (entities, aggregates, value objects, translatables, archivables, auditables, ordinals, and [DtoFor<T>] including polymorphic and flattened DTOs) over EF Core/SQLite.
• samples/EShop.Web -- a Nuxt UI front end for the EShop API, calling it through nuxt-api-party's server-side proxy.

Run the API first (dotnet run --project samples/EShop), then the web app (bun install && bun run dev from samples/EShop.Web).

EF Core Integration

Majal's EF Core package centralizes the registration of value-object conventions, translatable filters, archivable filters, and save-change interceptors through MajalDbContext<TLocale>.

public sealed class AppDbContext(
    DbContextOptions<AppDbContext> options,
    ILocaleProvider<CultureInfo> localeProvider)
    : MajalDbContext<CultureInfo>(options, localeProvider.GetCurrentLocale())
{
    public DbSet<Product> Products => Set<Product>();

    protected override void ConfigureConventions(ModelConfigurationBuilder builder)
    {
        base.ConfigureConventions(builder);
        builder.Properties<CultureInfo>().HaveConversion<CultureInfoValueConverter>();
    }
}

This keeps the context setup consistent and removes the need to manually register the generated conventions and interceptors in each DbContext.

Documentation

• Getting Started
• Aggregates Guide
• Entities Guide
• Value Objects Guide
• Archivables Guide
• Auditables Guide
• Translatables Guide
• Ordinals Guide
• DTOs Guide
• EF Core Integration

Contributing

Contributions are welcome! Feel free to open issues or submit pull requests.

License

This project is licensed under the MIT License.