Kista

June 19, 2026 · View on GitHub

GitHub release GitHub license

Kista

Renamed: This project was renamed from Deveel.Repository to Kista on May 26, 2025. The name Kista is Old Norse for "chest" or "repository", better reflecting the project's purpose as a data access framework.

Kista is a lightweight .NET framework that provides a principled implementation of the Repository Pattern, designed to help developers build applications grounded in Domain-Driven Design (DDD) and SOLID principles.

The framework abstracts data access behind a clean, stable interface — keeping your domain model independent of any specific persistence technology — while integrating seamlessly with popular data-access libraries as the underlying backing store.

Why Kista?

At its core, Kista is about keeping your domain clean.

In Domain-Driven Design the repository is not merely a data-access helper: it is the boundary between the domain model and the infrastructure layer. It speaks the language of the domain (entities, aggregates, identities) while hiding every detail of how data is fetched or persisted.

This library was born from the need to have a consistent, framework-agnostic abstraction for this boundary, without forcing application developers to:

couple their domain logic to a specific ORM or database driver, or
re-implement the same boilerplate repository scaffolding in every project.

It was never the intention to build another ORM. Object-Relational Mappers (and document-mapper equivalents) such as Entity Framework Core, Dapper, or MongoFramework are excellent tools for mapping objects to storage. Kista uses them — it does not replace them.

Kista vs. ORMs

The table below highlights the key differences and shows how both layers coexist:

Concern	ORM (EF Core, Dapper, …)	Kista
Responsibility	Map objects ↔ database tables / documents	Provide a domain-oriented access interface
Speaks the language of	Database schema, SQL, drivers	Domain model (entities, aggregates)
Knows about	Tables, columns, change tracking, transactions	Collections of entities and their identities
Lives in layer	Infrastructure	Domain / Application boundary
Used by	Repositories and infrastructure code	Application services and domain services

In practice, you create a repository on top of an ORM — the ORM handles low-level persistence while Kista defines what the application can ask for. For example, Kista.EntityFramework wraps Entity Framework Core's DbContext behind the IRepository<TEntity> interface, giving the domain a stable contract that survives database migrations and EF Core upgrades. The same principle applies to Kista.MongoFramework (backed by MongoFramework / MongoDB) and any custom driver you care to write.

This is not a limitation — it is by design. Decoupling ORMs from domain logic is one of the most impactful architectural decisions you can make for long-term maintainability.

Libraries

The framework is organized into a kernel package (providing interfaces and abstractions) and a set of driver packages that wire those abstractions to concrete data sources.

Stable releases are published to NuGet.org.
Pre-release / unstable builds are available from the GitHub Packages feed (https://nuget.pkg.github.com/kista/index.json).

Package	Description	NuGet (stable)	Pre-Release (GitHub)
`Kista`	Kernel abstractions: interfaces, base types, and DI extensions
`Kista.InMemory`	Volatile, in-process repository — ideal for testing and prototyping
`Kista.EntityFramework`	Repository driver backed by Entity Framework Core
`Kista.MongoFramework`	Repository driver backed by MongoFramework / MongoDB
`Kista.MongoFramework.MultiTenant`	Multi-tenant MongoDB connection management via Finbuckle.MultiTenant
`Kista.DynamicLinq`	Filter / query support via System.Linq.Dynamic.Core
`Kista.Manager`	Business layer (EntityManager) with validation, normalization, event sourcing, and logging
`Kista.Manager.DynamicLinq`	Dynamic LINQ query extensions for the Entity Manager
`Kista.Manager.EasyCaching`	Second-level caching for the Entity Manager via EasyCaching
`Kista.Manager.AspNetCore`	ASP.NET Core integration for automatic HTTP request cancellation
`Kista.HealthChecks`	Health check abstractions for repository connectivity monitoring
`Kista.HealthChecks.EntityFramework`	Entity Framework Core health checks
`Kista.HealthChecks.MongoFramework`	MongoDB health checks
`Kista.HealthChecks.InMemory`	In-Memory health checks
`Kista.Manager.AspNetCore.HealthChecks`	ASP.NET Core endpoint integration for health checks
`Kista.Owners`	Decorator-based user scoping with automatic owner assignment and query filtering

Quick Start

1. Install a driver package

Pick the driver that matches your data source. The Core kernel package is pulled in automatically as a transitive dependency:

# Entity Framework Core
dotnet add package Kista.EntityFramework

# MongoDB
dotnet add package Kista.MongoFramework

# In-Memory (testing / prototyping)
dotnet add package Kista.InMemory

To consume an unstable pre-release build, add the GitHub Packages feed first:

dotnet nuget add source https://nuget.pkg.github.com/kista/index.json \
  --name kista-github --username <your-github-username> --password <your-pat>

2. Register the repository

Use the AddRepositoryContext() builder to configure your driver:

// Program.cs
builder.Services.AddRepositoryContext()
    .UseInMemory();

For Entity Framework Core or MongoDB, replace .UseInMemory() with the appropriate driver:

// Entity Framework Core
builder.Services.AddRepositoryContext()
    .UseEntityFramework<MyDbContext>();

// MongoDB
builder.Services.AddRepositoryContext()
    .UseMongoDB<MyMongoContext>();

After registration the following services are resolvable from the DI container (availability depends on the concrete repository's capabilities):

Interface	Description
`IRepository<TEntity>`	Core CRUD, single-entity look-up (`FindAsync`), and unsorted pagination (`GetPageAsync`)
`ITrackingRepository<TEntity>`	Change tracking and original value look-ups

Note: The legacy interfaces IQueryableRepository, IPageableRepository, and IFilterableRepository are deprecated. Query capabilities are now provided through protected members of Repository<TEntity, TKey>. For domain-specific queries, extend the base repository with custom methods. See the full documentation for details.

3. Consume the repository in your services

public class OrderService(IRepository<Order> orders)
{
    public Task<Order?> GetAsync(string id, CancellationToken ct)
        => orders.FindAsync(id, ct);

    public Task PlaceAsync(Order order, CancellationToken ct)
        => orders.AddAsync(order, ct);
}

4. Add Health Checks (Optional)

Monitor repository connectivity with built-in health checks:

// Install health check packages
dotnet add package Kista.HealthChecks
dotnet add package Kista.HealthChecks.EntityFramework  # or MongoFramework, InMemory

// Configure in Program.cs
builder.Services
    .AddRepositoryContext()
    .UseEntityFramework<MyDbContext>(ef => ef.WithHealthChecks());

builder.Services
    .AddHealthChecks()
    .AddKistaRepositories();

var app = builder.Build();
app.MapHealthChecks("/health");
app.Run();

For more details, see the Health Checks documentation.

For driver-specific configuration, multi-tenancy, and guidance on writing a custom repository, refer to the full documentation or browse it online at GitBook.

Documentation and Guides

Topic	Description
Getting Started	Installation, requirements, and first steps
Entity Framework Core driver	Storing entities via EF Core
MongoDB driver	Storing entities in MongoDB
In-Memory driver	In-process volatile storage
Entity Manager	Business layer with validation, caching, and events
Custom repositories	Write your own driver
Multi-Tenancy	Tenant-isolated repositories
User Entities	User-scoped entities with owner filtering
Health Checks	Repository connectivity monitoring

Full documentation is also available on GitBook.

Kista

Kista

Why Kista?

Kista vs. ORMs

Libraries

Quick Start

1. Install a driver package

2. Register the repository

3. Consume the repository in your services

4. Add Health Checks (Optional)

Documentation and Guides

Roadmap

Release Timeline

License

Contributing

Contributors