Skip to content
Cratis

Arc

Arc

CQRS application framework for ASP.NET Core

Arc is an opinionated CQRS application framework for ASP.NET Core with commands, queries, validation, authorization, and TypeScript proxy generation. Event sourcing is not required.

Start here

Section titled “Start here”

When commands, queries, validation, authorization, frontend contracts, and persistence each grow their own conventions, Arc gives them one application boundary. Start with current-state persistence or application services. Add Chronicle only where event sourcing fits, and add Components only where its React compositions fit.

Start an Arc host

Add the Arc package and configure an ASP.NET Core host.

 Commands and queries

Execute changes, expose reads, and generate the client contracts for both.

 Frontend contracts

Use the generated TypeScript runtime directly or compose it with React.

 Persistence choices

Keep current state in application services, MongoDB, or EF Core, or add Chronicle.
Why Arc The problem Arc solves, why it leans on CQRS and proxy generation, and how it keeps a full-stack app type-safe end to end.
Coming from MediatR and MVC Map controllers, DTOs, and MediatR handlers onto Arc's command and query model.
Samples Runnable event sourcing and CQRS samples for the Cratis stack, including full Arc applications.

Start an Arc host

Section titled “Start an Arc host”

Use the .NET SDK declared by Arc’s current global.json.

  1. Install the umbrella host package.

    Terminal window
    dotnet add package Cratis.Arc

  2. Configure and run the host.

    using Cratis.Arc;
    

    var builder = ArcApplication.CreateBuilder(args);
    builder.AddCratisArc();
    

    var app = builder.Build();
    app.UseCratisArc();
    await app.RunAsync();

  3. Confirm the application starts on the selected SDK/package profile.

Starting the host verifies the setup path only. Commands, queries, generated proxies, persistence integrations, and frontend packages each have additional configuration and version requirements.

Commands and queries

Section titled “Commands and queries”

Arc supports model-bound records and methods as well as controller-based endpoints. The command and query pipelines handle dependency injection, validation, authorization, filters, execution scopes, result conversion, and HTTP exposure.

Queries can return one result or use Arc’s observable-query APIs. The TypeScript generator creates clients for recognized commands, queries, referenced types, validation rules, and identity details. See the detailed product documentation for the exact transport, subscription, and lifecycle behavior.

Command pipeline Model intentions, validate and authorize them, provide dependencies, execute handlers, and convert typed results into HTTP responses.
Query pipeline Expose purpose-shaped reads with paging, sorting, filtering, result rendering, and diagnostics.
Observable-query APIs Work with documented query subscriptions, collection changes, subscription guards, and query health information.

Frontend contracts

Section titled “Frontend contracts”

@cratis/arc supplies the TypeScript command, query, validation, identity, and messaging runtime used by generated proxies. @cratis/arc.react adds hooks, command forms, dialogs, identity composition, and query components. The optional React/MVVM package adds view models, dependency injection, route parameters, and browser abstractions.

Explore Arc’s frontend packages to choose the TypeScript, React, or React/MVVM path. Components is separate: applications may use Arc without Components, and may use the generated TypeScript clients without Arc’s React packages.

Identity and tenancy

Section titled “Identity and tenancy”

Arc includes pluggable identity and access behavior, identity-detail providers, server-side authorization and role checks, and frontend identity context. Tenant resolution can use a header, query parameter, claim, subdomain, fixed value, or development setting before provider-specific database or namespace mapping.

Frontend visibility helpers do not replace server-side authorization. Tenant resolution also does not by itself establish isolation for an application or storage topology.

Persistence choices

Section titled “Persistence choices”

Arc.Core does not depend on Chronicle. Commands and queries can use application services or current-state persistence without an event log.

MongoDB Use Arc's serialization conventions, tenant-aware database resolution, resilient collection access, and observable change streams.
Entity Framework Core Discover read models, configure value conversions and mappings, run migrations, and observe supported SQL Server, PostgreSQL, or SQLite changes.
Chronicle Add event-sourced commands, projections, reducers, aggregates, reactors, concurrency behavior, tenant namespaces, and Chronicle-specific testing.

Inspection, contracts, and testing

Section titled “Inspection, contracts, and testing”

Arc can describe registered commands, queries, identity schemas, and OpenAPI operations at runtime. Repository packages also include analyzers, source generators, command-scenario testing, proxy-generation checks, Vite helpers, and Arc-specific ESLint rules.

Continue

Section titled “Continue”
Arc source and README

Repository structure, package roles, contribution guidance, and current limits.

 Arc packages

Published .NET package metadata and versions.

 Chronicle

The optional event-sourced runtime integration for Arc application behavior.

 Components

Optional React components aligned with Arc application patterns.