Arc

Arc

CQRS application framework for ASP.NET Core, Spring Boot, and Node.js

Arc is an opinionated CQRS application framework with commands, queries, validation, authorization, and TypeScript proxy generation. Write the backend in C#, Kotlin or Java, or the TypeScript source preview; each can generate a typed frontend client. Event sourcing is not required.

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 Arc to an ASP.NET Core, Spring Boot, or TypeScript 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 (C#) Map controllers, DTOs, and MediatR handlers onto Arc's command and query model.

Coming from Spring MVC (Kotlin and Java) Map @RestController handlers and DTOs 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

Arc runs on ASP.NET Core and Spring Boot; a third implementation for TypeScript on Node.js is a source preview with no published npm package or full parity yet. Choose a backend below and check its capabilities before relying on a shared example. The shared HTTP contract is verified for C# and JVM; TypeScript’s coverage is documented separately.

C# on ASP.NET Core Install Cratis.Arc, configure the host, and reach the first command and query checkpoint. Arc.Core is a lighter alternative host.

Kotlin or Java on Spring Boot Apply the io.cratis.arc Gradle plugin, declare a command and a read model, and call them. A Java walkthrough sits alongside it.

TypeScript source preview on Node.js Build an Arc host from source; inspect the capability reference before using preview APIs.

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

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 in C# and on the JVM. TypeScript implements a subset of these capabilities; consult its capability reference. The scenario recipes show the same task, such as validating a command, with backend examples where the capability is available.

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 (C#) Model intentions, validate and authorize them, provide dependencies, execute handlers, and convert typed results into HTTP responses.

Command pipeline (Kotlin and Java) The same command model on Spring Boot: KSP-generated handlers, dependency resolution, validation and typed results.

Query pipeline (C#) Expose purpose-shaped reads with paging, sorting, filtering, result rendering, and diagnostics.

Query pipeline (Kotlin and Java) Model-bound read models with GET, RFC QUERY, HTTP snapshots, SSE and WebSocket hosting on Spring Boot.

Observable-query APIs (C#) Work with documented query subscriptions, collection changes, subscription guards, and query health information.

Observable-query APIs (Kotlin and Java) Subscribe to collection changes over SSE or WebSocket, and the same observable-query lifecycle on the JVM host.

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, dialog infrastructure, identity composition, and query components. The composed CommandDialog used in the tutorial comes from the separate @cratis/components package. 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

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 — see tenancy on C# or tenancy on Kotlin and Java.

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

Arc does not depend on Chronicle. Commands and queries can use application services or current-state persistence without an event log. Each backend integrates with the data access its own ecosystem already uses.

MongoDB (C#) Arc's serialization conventions, tenant-aware database resolution, resilient collection access, and observable change streams.

Entity Framework Core (C#) Discover read models, configure value conversions and mappings, run migrations, and observe SQL Server, PostgreSQL or SQLite changes.

Spring Data (Kotlin and Java) Inject JPA or MongoDB repositories into queries and commands, with Arc paging, tenant routing, transactions and observable change streams.

Chronicle (C#) Add event-sourced commands, concurrency behavior, tenant namespaces and reactor side effects.

Chronicle (Kotlin and Java) The same event-sourced commands, concurrency behavior, tenant namespaces and reactor side effects on Spring Boot.

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.

• Inspect registered application contracts (C#) — commands, queries and identity schemas are also introspectable on Kotlin and Java; a dedicated guide is not yet published
• Generate OpenAPI descriptions: C# or Kotlin and Java
• Test command behavior: C#, Kotlin and Java, or TypeScript preview
• Review analyzer rules: C# Roslyn analyzers or Kotlin KSP diagnostics

Check the combination you use

These are separate packages and integration surfaces. Their existence does not establish compatibility with every frontend, runtime, persistence provider, browser, or product version. Check the package manifests and the evidence for the combination you evaluate.

Continue

Arc source and README

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

Arc packages (C#)

Published .NET package metadata and versions.

Arc packages (Kotlin and Java)

Published Maven Central package metadata and versions.

Chronicle

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

Components

Optional React components aligned with Arc application patterns.