MonadicSharp.Persistence 1.0.0

MonadicSharp.Persistence

Result-aware repository and Unit of Work for EF Core 8 — NotFound, Conflict, and DatabaseError are typed Result<T> values, never null or unhandled exceptions.

Overview

MonadicSharp.Persistence brings Railway-Oriented Programming to the data access layer:

• IRepository<T, TId> — full read-write repository, all methods return Result<T>
• IReadRepository<T, TId> — read-only projection for CQRS-style separation
• IUnitOfWork — SaveChangesAsync returns Result<int>, concurrency conflicts are typed errors
• EfCoreRepository<T, TId> — EF Core 8 implementation
• EfCoreUnitOfWork — supports transactions via BeginTransactionAsync / CommitTransactionAsync
• QueryableExtensions — .ToResultAsync(), .FirstOrDefaultResultAsync(), .SingleResultAsync() for inline LINQ
• PersistenceError — typed error factory for all persistence failure scenarios

Installation

dotnet add package MonadicSharp.Persistence
dotnet add package Microsoft.EntityFrameworkCore.SqlServer  # or Npgsql, Sqlite, etc.

Quick Start

1. Define your DbContext as usual

public class AppDbContext : DbContext
{
    public DbSet<Order> Orders => Set<Order>();
    // ...
}

2. Register in DI

services.AddDbContext<AppDbContext>(opts =>
    opts.UseNpgsql(connectionString));

services
    .AddMonadicSharpPersistence<AppDbContext>()          // registers IUnitOfWork
    .AddMonadicSharpRepository<Order, Guid>();            // registers IRepository<Order, Guid>

3. Use in your services

public class OrderService(IRepository<Order, Guid> orders, IUnitOfWork uow)
{
    public async Task<Result<Order>> PlaceOrderAsync(CreateOrderDto dto)
    {
        var order = new Order(dto.CustomerId, dto.Items);

        var addResult = await orders.AddAsync(order);
        if (addResult.IsFailure) return addResult;

        var saveResult = await uow.SaveChangesAsync();
        return saveResult.IsSuccess
            ? Result<Order>.Success(order)
            : Result<Order>.Failure(saveResult.Error);
    }

    public async Task<Result<Order>> GetOrderAsync(Guid id) =>
        await orders.FindAsync(id);
    // Returns PersistenceError.NotFound if missing — no null checks needed
}

IRepository API

// Read
Task<Result<T>>                 FindAsync(TId id, ct)
Task<Result<T>>                 FirstOrDefaultAsync(predicate, ct)
Task<Result<IReadOnlyList<T>>>  ListAsync(predicate?, ct)
Task<Result<bool>>              AnyAsync(predicate, ct)
Task<Result<int>>               CountAsync(predicate?, ct)

// Write (changes not persisted until SaveChangesAsync)
Task<Result<T>>     AddAsync(T entity, ct)
Task<Result<Unit>>  AddRangeAsync(IEnumerable<T> entities, ct)
Result<T>           Update(T entity)
Task<Result<Unit>>  DeleteAsync(TId id, ct)
Result<Unit>        Delete(T entity)

IUnitOfWork API

Task<Result<int>>   SaveChangesAsync(ct)             // persists all pending changes
Task<Result<Unit>>  BeginTransactionAsync(ct)
Task<Result<Unit>>  CommitTransactionAsync(ct)
Task<Result<Unit>>  RollbackTransactionAsync(ct)

Transaction example

await uow.BeginTransactionAsync();

var addOrder = await orders.AddAsync(order);
var debitStock = await inventory.UpdateAsync(item);

if (addOrder.IsFailure || debitStock.IsFailure)
{
    await uow.RollbackTransactionAsync();
    return Result<Unit>.Failure(addOrder.Error ?? debitStock.Error!);
}

await uow.SaveChangesAsync();
await uow.CommitTransactionAsync();

QueryableExtensions

For custom queries that go beyond the repository interface:

var recentOrders = await dbContext.Orders
    .Where(o => o.CreatedAt > DateTime.UtcNow.AddDays(-7))
    .OrderByDescending(o => o.CreatedAt)
    .ToResultAsync(ct);

// Single entity
var order = await dbContext.Orders
    .SingleResultAsync(o => o.ExternalRef == externalId, ct);
// Returns PersistenceError.NotFound or PersistenceError.TooManyResults

// First or not-found
var latest = await dbContext.Orders
    .OrderByDescending(o => o.CreatedAt)
    .FirstOrDefaultResultAsync(ct);

Error Codes

License

MIT — part of MonadicSharp.Framework.