Vorn.Entities.Generators 8.2.0-rc3

Vorn.Entities.Generators

Vorn.Entities.Generators is a Roslyn source generator that emits dependency injection helpers for every aggregate described in your assembly. By annotating your domain project once, the generator produces extension methods that register MediatR handlers, caches, and interception services without hand-writing boilerplate.

Add the analyzer reference

Include the generator as an analyzer reference in the project that defines your entities and descriptors:

dotnet add package Vorn.Entities.Generators

📌 The package is a source generator, so it only needs to be referenced by the project that produces the entities. Downstream consumers (API, server, client) will use the generated extensions at compile time.

Opt-in per assembly

Decorate your assembly with [GenerateEntitiesRegistration] to activate generation.

using Vorn.Entities.Generators;

[assembly: GenerateEntitiesRegistration]

The generator scans the compilation for descriptor types decorated with [EntityDescriptorFor(typeof(TEntity))] where TEntity inherits from Vorn.Entities.Entity.

Describe descriptors

Use the descriptor attribute on your descriptor type so the generator can pair it with the entity:

[EntityDescriptorFor(typeof(Document))]
public sealed record DocumentDescriptor : EntityDescriptor
{
    public string? SearchText { get; init; }
}

You can repeat the attribute for every aggregate in the assembly. Abstract descriptors/entities are ignored automatically.

What gets generated

When descriptors are found, the generator emits an extension class named EntityManagementRegistrationOf<YourAssemblyName> (dots removed). The method wires common services:

public static class EntityManagementRegistrationOfDocumentsDomain
{
    public static void AddDocumentsDomainEntityHandlers(this IServiceCollection services)
    {
        services.AddMemoryCache();
        services.AddMediatR(cfg => cfg.RegisterServicesFromAssembly(typeof(EntityManagementRegistrationOfDocumentsDomain).Assembly));
        services.AddSingleton<IEntityCacheInvalidationService, EntityCacheInvalidationService>();
        services.AddSingleton<EntityManagementInterceptor>();
        services.AddScoped<IEntityUserService, EntityUserService>();
        services.AddScoped<IEntityTimeService, EntityTimeService>();
        services.AddTransient<IRequestHandler<AddEntityCommand<Document, DocumentDescriptor>, Document?>, AddEntityHandler<Document, DocumentDescriptor>>();
        // ...additional handlers per aggregate...
    }
}

The registrations cover every command/query handler (Add, Update, Remove, Get, Count) along with the cache implementations needed by the core library.

Consuming the generated code

Call the extension method from your host or composition root:

builder.Services.AddDocumentsDomainEntityHandlers();

Because the extension lives in the same assembly as your entities, it travels with the project wherever it is referenced. IDEs expose the generated file in the Analyzers → Documents node so you can inspect the output.

Tips

• Commit the attributes alongside your DTO/descriptor definitions so the generator immediately tracks new aggregates.
• If you need bespoke registrations (e.g., custom caching), you can still call the generated method and then override specific services.
• Combine with dotnet format/dotnet build in CI to catch analyzer errors early; the generator surfaces diagnostics if descriptor/entity types cannot be resolved.