CoreOne.ModelPatch.Abstract 1.0.1

CoreOne.ModelPatch.Abstract

The abstractions package for CoreOne.ModelPatch — providing the interfaces, models, and core types needed to build and extend partial update (PATCH) pipelines for EF Core entities.

Install this package when you want to reference the CoreOne.ModelPatch contracts without taking a dependency on the full implementation — for example, in a shared domain or plugin library.

📦 Installation

dotnet add package CoreOne.ModelPatch.Abstract

Requirements: net9.0 or net10.0

What's Included

Delta Types

Delta and Delta<T> are case-insensitive dictionaries that hold only the properties you explicitly include in a partial update. The generic version gives you compile-time type safety.

// Untyped — useful for dynamic scenarios
var delta = new Delta();
delta["Name"] = "Alice";
delta["Email"] = "alice@example.com";

// Typed — tied to a specific entity
var typed = new Delta<User>();
typed["Name"] = "Alice";

DeltaCollection<T> is a list of Delta<T> for batch operations.

IDataModelService<TContext>

The primary service interface your application uses to apply patches. Inject this to avoid a hard dependency on the implementation assembly.

public class UserService(IDataModelService<AppDbContext> patchService)
{
    public Task<PatchResult> PatchUser(Delta<User> delta, CancellationToken ct)
        => patchService.Patch(delta, ct);
}

Methods:

Plugin Interfaces

Implement these to inject custom logic into the patch pipeline.

Both interfaces expose an Order property (higher = runs first). Implement them and register with DI:

// Custom pre-patch plugin
public class AuditPlugin : IPrePatchPlugin
{
    public int Order => 500;

    public ValueTask<IResult> Execute(ModelProcessContext context, CancellationToken ct)
    {
        context.Delta["UpdatedAt"] = DateTime.UtcNow;
        return ValueTask.FromResult(Result.Ok);
    }
}

// Register
services.TryAddEnumerable(ServiceDescriptor.Scoped<IPrePatchPlugin, AuditPlugin>());

IKeyGenerator

Implement this to provide custom primary key generation for your entities.

// Use the strongly-typed generic form
public class SequentialIdGenerator : IKeyGenerator<int>
{
    private static int _counter = 0;

    public int Create() => Interlocked.Increment(ref _counter);

    public KeyModel CreateKey() => new KeyModel(Create());
}

Register per entity type in ModelOptions:

services.Configure<ModelOptions>(o =>
    o.KeyGenerators[typeof(MyEntity)] = new SequentialIdGenerator());

ModelOptions

Controls patching behavior. Configure via services.Configure<ModelOptions>(...) or pass directly.

PatchResult

Returned by every patch call. Inspect it to determine what was created, updated, or left unchanged.

var result = await patchService.Patch(delta, ct);

if (result.ResultType == ResultType.Success)
{
    Console.WriteLine($"Created: {result.Created}");
    Console.WriteLine($"Updated: {result.Updated}");

    // Retrieve a specific patched entity
    var user = result.Get<User>();
}

PatchRestrictAttribute

Apply to entity properties to control whether they may be included in a patch delta.

public class User
{
    public Guid Id { get; set; }
    public string Name { get; set; }

    // Cannot be changed via patch — silently dropped from delta
    [PatchRestrict(PatchRestrictionType.DenyUpdateSilently)]
    public DateTime CreatedAt { get; set; }

    // If present in delta, the entire patch fails with a 400-like error
    [PatchRestrict(PatchRestrictionType.DenyUpdateBadRequest)]
    public string Role { get; set; }
}

ModelProcessContext

Passed to every plugin. Gives access to the current delta, entity type, entity instance, and CRUD state.

public ValueTask<IResult> Execute(ModelProcessContext context, CancellationToken ct)
{
    // The partial update data
    var delta = context.Delta;

    // The CLR type being patched
    var entityType = context.Type;

    // The tracked EF Core entity (may be null before it's resolved)
    var entity = context.Model;

    // Whether this is a Create or Update
    var state = context.State; // CrudType.Created | CrudType.Updated
    return ValueTask.FromResult(Result.Ok);
}

Related Packages

License

MIT — see LICENSE on GitHub.