Muonroi.Services 1.0.0-alpha.16

Muonroi.Services

Generic EF Core CRUD base class with virtual hook points for schema-divergent multi-tenancy — inherit once, override only what differs per site.

Muonroi.Services provides MServiceBase<TEntity, TDto>, an abstract EF Core service base that ships fully-functional Create / Read / Update / Delete operations out of the box. Every operation calls a lifecycle hook sequence; sites override only the hooks that differ without touching the shared CRUD logic. Data access always uses DbContext.Set<TEntity>() so the base is agnostic to concrete DbSet property names across divergent schemas.

This is an implementation layer that couples to DbContext by design. It is not a vendor-neutral contract; there is no .Abstractions counterpart.

Installation

dotnet add package Muonroi.Services --prerelease

Quick Start

1. Define your entity (implements IEntityBase<TKey>) and DTO:

using Muonroi.Data.Abstractions.Entities;

public sealed class Product : IEntityBase<long>
{
    public long Id { get; set; }
    public string Name { get; set; } = string.Empty;
    public decimal Price { get; set; }
}

public sealed class ProductDto
{
    public long Id { get; set; }
    public string Name { get; set; } = string.Empty;
    public decimal Price { get; set; }
}

2. Implement IEntityMapper<TEntity, TDto> (or extend EntityMapperBase<TEntity, TDto> from Muonroi.Mapping.Abstractions):

using Muonroi.Mapping.Abstractions;

public sealed class ProductMapper : EntityMapperBase<Product, ProductDto>
{
    protected override void MapCoreToDto(Product entity, ProductDto dto)
    {
        dto.Id = entity.Id;
        dto.Name = entity.Name;
        dto.Price = entity.Price;
    }

    protected override void MapCoreToEntity(ProductDto dto, Product entity)
    {
        entity.Name = dto.Name;
        entity.Price = dto.Price;
    }
}

3. Inherit MServiceBase and override only the hooks you need:

using Muonroi.Mapping.Abstractions;
using Muonroi.Services;

public sealed class ProductService(AppDbContext context, IEntityMapper<Product, ProductDto> mapper)
    : MServiceBase<Product, ProductDto>(context, mapper)
{
    // Set a site-specific default before the entity is saved for the first time.
    protected override void ApplyDefaultValues(Product entity)
    {
        if (entity.Price <= 0)
            entity.Price = 0.99m;
    }
}

4. Register in DI and use:

builder.Services.AddDbContext<AppDbContext>(o =>
    o.UseInMemoryDatabase("my-db"));

builder.Services.AddScoped<IEntityMapper<Product, ProductDto>, ProductMapper>();
builder.Services.AddScoped<ProductService>();

// In a controller or minimal-API handler:
ProductDto created = await productService.CreateAsync(dto, ct);
ProductDto? found  = await productService.GetByIdAsync(created.Id, ct);

There is no AddXxx extension method — MServiceBase is a base class, not a framework component. Register each concrete service directly with AddScoped / AddTransient.

Features

• Full CRUD — CreateAsync, GetByIdAsync, GetByConditionAsync, UpdateAsync, DeleteAsync are provided and virtual (override when needed).
• Lifecycle hooks — six override points fired in order: ValidateAsync → ApplyDefaultValues → BeforeCreate → save → AfterCreate (and BeforeUpdate / AfterUpdate for updates).
• Schema-agnostic data access — all queries go through DbContext.Set<TEntity>(), not named DbSet properties; works across tenant schemas without modification.
• Guard-checked dependencies — Context and Mapper are validated non-null at construction time via MGuard.NotNull.
• Predicate queries — GetByConditionAsync(Expression<Func<TEntity, bool>>) executes a server-side WHERE clause and maps all matching rows to DTOs.

Configuration

No options class or appsettings section. Wire up:

API Reference

Samples

• Quickstart.Services — minimal ASP.NET Core API wiring MServiceBase over an in-memory EF Core context with an ApplyDefaultValues hook override and Swagger UI.

Compatibility

• Target framework: net8.0
• License: Apache-2.0 (OSS)

Related Packages

• Muonroi.Data.Abstractions — supplies IEntityBase / IEntityBase<TKey> that entity types must implement.
• Muonroi.Mapping.Abstractions — supplies IEntityMapper<TEntity, TDto> and EntityMapperBase<TEntity, TDto> used by the base constructor.

License

Apache-2.0. See LICENSE-APACHE.