Nerv.Repository 1.0.1

Nerv.Repository

A lightweight, flexible and extensible implementation of the Repository and Unit of Work patterns using Entity Framework Core.
Designed for clean architecture, testability, and ease of integration across any .NET application.

✨ Features

• Generic IRepository<T> and IReadOnlyRepository<T>
• IUnitOfWork with transaction support
• Audit support (CreatedOn, UpdatedOn, DeletedOn, CreatedBy, etc.)
• Soft delete support
• Actor context integration for automatic user tracking
• Global DbContextBase with auto-audit and soft-delete filters
• Pagination and filtering utilities
• Ready-to-use in-memory tests

📦 Installation

dotnet add package Nerv.Repository

🛠️ Usage

1. Define your entity

public class User : Entity<Guid>
{
    public string Name { get; set; }
}

2. Configure your DbContext

public class AppDbContext : DbContextBase<Guid>
{
    public AppDbContext(DbContextOptions<AppDbContext> options, ActorContext<Guid> actor)
        : base(options, actor) { }
}

3. Register dependencies

var builder = WebApplication.CreateBuilder(args);

// Register IHttpContextAccessor (needed to access HTTP context)
builder.Services.AddHttpContextAccessor();

// Register everything using the AddRepositoryPattern extension
builder.Services.AddRepositoryPattern<AppDbContext, Guid>(
    options => 
    {
        var connectionString = builder.Configuration.GetConnectionString("DefaultConnection");
        options.UseSqlServer(connectionString);
    },
    provider =>
    {
        // This is the actor factory, resolved per request
        var httpContextAccessor = provider.GetRequiredService<IHttpContextAccessor>();
        var httpContext = httpContextAccessor.HttpContext;

        var userIdClaim = httpContext?.User?.FindFirst("sub")?.Value;

        Guid userId = userIdClaim != null 
            ? Guid.Parse(userIdClaim)
            : Guid.Empty; // fallback if not authenticated

        return new ActorContext<Guid> { UserId = userId };
    }
);

4. Use in your services

You only need to inject IUnitOfWork in your services. All repositories are accessed through it:

public class UserService
{
    private readonly IUnitOfWork _unitOfWork;

    public UserService(IUnitOfWork unitOfWork)
    {
        _unitOfWork = unitOfWork;
    }

    public async Task CreateUserAsync(string name)
    {
        var user = new User { Id = Guid.NewGuid(), Name = name };

        var userRepo = _unitOfWork.GetRepository<User>();
        await userRepo.AddAsync(user);
        await _unitOfWork.SaveChangesAsync();
    }
}

🔍 ActorContext for audit

All changes are tracked by ActorContext<TUserId>:

public class ActorContext<TUserId>
{
    public TUserId UserId { get; set; }
}

🧪 Testing

You can test your repositories and unit of work using the in-memory SQLite provider.

public class UserTests
{
    [Fact]
    public async Task Add_Should_Persist_User()
    {
        using var fixture = RepositoryFixture.Create();
        var user = new User { Id = Guid.NewGuid(), Name = "Test" };
        await fixture.Repository.AddAsync(user);
        await fixture.UnitOfWork.SaveChangesAsync();

        var result = await fixture.Repository.GetByIdAsync(user.Id);
        Assert.NotNull(result);
    }
}

🧱 Project Structure

src/
  Nerv.Repository/
    Abstractions/
    Contexts/
    Extensions/
    LogEntities/
tests/
  Nerv.Repository.Tests/
    Context/
    Entities/
    Fixtures/
    Repositories/
    UnitOfWork/

📄 License

This project is licensed under the MIT License.

🤝 Contributing

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

🔗 Related Projects

• Entity Framework Core