Skip to content
Cratis
Search
Ctrl
K
Cancel
Blog
GitHub
Discord
YouTube
Select theme
Dark
Light
Auto
Cratis Stack
Chronicle
Arc
Components
AuthProxy
Screenplay
Prologue
CLI
AI
Templates
Fundamentals
Contributing
Architecture
Overview
Start here
Tutorial
Tutorial
Overview
1. Your first full-stack slice
2. Make it trustworthy
3. Relate your slices
4. Make it live
5. Decide who can do what
Scenarios
Overview
Validate a command
Return a result or an error
Provide data to a command handler
Use current state in a command
Query data across slices
Execute a command from React
Test a command
Concepts and architecture
Why Arc
CQRS without event sourcing
Vertical slices
Understanding the proxy boundary
Understanding identity and access
HTTP contract
Glossary
Backend
Backend overview
C#
Overview
Coming from MediatR and MVC
Getting Started
Quickstart
Standalone ASP.NET Core setup
Your first command and query
Hosting overview
Arc.Core
Arc.Core
Overview
Getting Started
Quickstart
Endpoint Mapping
Static Files
Authentication
Authorization
OpenAPI Specifications
Invariant Culture
ASP.NET Core
Overview
Configuration
Authorization
Microsoft Identity
FromRequest Attribute
Swagger
Validation
Without Wrappers
Invariant Culture
Configuration
Commands
Overview
Model-bound commands
Overview
Authorization
Generated values
Controller-based commands
Validation
Command input binding
Pre-flight validation
Validation severity filtering
Command pipeline
Command operations
Overview
Implement an operation
Migrate a service-backed command
Execution and recovery reference
Response value handlers
Response examples
Command context
Command filters
Command execution scopes
Transactions (optional Chronicle integration)
Queries
Overview
Model-bound queries
Overview
Static methods
Dependency injection
Query arguments
Authorization
Return types
Paging
Observable queries
Controller-based queries
Overview
Route templates
Query arguments
Dependency injection
Return types
Paging
Observable queries
Validation
Query pipeline and result contract
Use the HTTP QUERY method
Use observable queries with cURL
Observable query hub protocol
Change streams
Read-model interception
Observable query emission guards
Query health endpoint
Authorizing commands and queries
Identity
Identity
Provider Flow
Identity Contracts
IdentityProvider Service
Development and Topologies
Migrating from the Identity Cookie
Tenancy
Overview
Tenancy End to End
Resolving Tenant IDs
Configuration
Tenant Context Access
Database Isolation
Connection Resolution
MongoDB
Overview
Getting Started
Quickstart
Serializers
Geospatial Types
Overview
Point
LineString
Polygon
Concepts
Naming Policies
Class Mapping
Convention Packs
Observing Collections
Watching Multiple Collections
Tenancy
Connection Resolution
Entity Framework
Overview
Getting Started
Quickstart
Base DbContext
Entity Mapping
Read Only DbContexts
Automatic Database hookup
Connection Resolution
Observing DbSet
Common Column Types
Adding Columns in Migrations
Property Extensions
JSON Conversion
ConceptAs Conversion
GUID Conversion
Geospatial Types
Point Conversion
LineString Conversion
Polygon Conversion
Proxy Generation
Overview
Getting Started
Quickstart
Configuration
Overview
Basic Options
Library Mode
Emit Interfaces
Proxy File Suffix
Type Exclusions
Namespace Roots
Assembly-to-Package Mappings
Routing
Output Behavior
Commands
Queries
Type Mapping
Validation
Identity Details
File Index Tracking
Linting Generated Proxies
Code Analysis
Code Analysis Rules
ARC0001 - Incorrect query method signature on ReadModel
ARC0002 - Missing [Command] attribute on command-like type
ARC0003 - Handle() must be on [Command] type
ARC0004 - [Command] type must have public Handle() method
ARC0005 - Value produced by Provide is not consumed by Handle
ARC0006 - Command-scoped read model can be missing
ARC0022 - Invalid generated value parameter type
ARC0023 - Generated value declared outside a command Handle method
ARC0024 - Generated value names must be non-empty and unique
ARC0025 - Provide supplies a generated value type
ARC0026 - Invalid explicit query declaration
ARC0027 - Generated value implements both generation contracts
ARC0028 - Move inline generation to a generated parameter
ARC0029 - Non-public static method is not exposed as a query
ARC0030 - Composite key requires accessor registration
ARC0031 - Command key properties are read through reflection
OpenAPI
Overview
Concepts
Commands
Queries
Enums
FromRequest Attribute
Model-Bound Operations
Introspection
Overview
Commands
Queries
Identity details schema
Attribute reference
Observability
Testing
Overview
Test decisions and the pipeline
Test command operations
Specify operation failure cases
Test operations with Chronicle
Test event-sourced commands
Command Scenarios
Pin generated values
Query Scenarios
Chronicle
Chronicle
Overview
Add event sourcing to an Arc slice
Cratis Package
Commands
Overview
Events
Event tags
Setting Subject
Returning EventSourceId
Causation
Transactional commands
Commands for occurrences
Concurrency
Fresh identifiers
Event source definitions
Event source definition scenarios
How definition routing works
Stream decisions
Completing streams
Resolving EventSourceId
Composite protected-key accessors
Choosing how a rule holds
Choosing how a rule holds
Getting started
Quickstart
Adopting read protection
Reads
Validators
Refusals
How it works
Scenarios
Scenarios
One entity
Unique and once
Two entities
One stream
Process stream
Gapless numbers
Rich aggregate
Editing conflict
Rules that need no guard
Less idiomatic Arc
Chronicle used directly
Test the race
Pitfalls
FAQ
Read Models
Overview
Read models in commands
Read models from other providers
When resolution fails
Validation
Aggregates
Overview
Defining an aggregate root
Aggregate roots in commands
React to an event
Reactors
Overview
Returning Commands as Side Effects
Tenancy
Compliance
Overview
PII
Subject
Code Analysis
Code Analysis Rules
ARCCHR0001 - Incorrect aggregate root event handler signature
ARCCHR0002 - Ambiguous command identity
ARCCHR0003 - Reactor must not reach the default event log
ARCCHR0004 - [EventType] repeats the type name as its id
ARCCHR0005 - Chronicle is used but not wired up
ARCCHR0006 - Reactor handler invoking ICommandPipeline.Execute does not say what replay should do
ARCCHR0007 - Command handler injects IEventLog
ARCCHR0008 - Command key marked with the data annotations Key attribute
ARCCHR0009 - Command property reads as a secret and should be marked [NotAudited]
ARCCHR0010 - Raw Guid response does not set the event source id
ARCCHR0011 - Plain read model in an Off command is unprotected
ARCCHR0012 - Immediate append bypasses protected decision
ARCCHR0013 - Use the event source definition
ARCCHR0014 - Observed event stream is not declared
ARCCHR0015 - Command handler must not return a nullable event
ARCCHR0016 - Concurrency flag ignored with exact scopes
ARCCHR0017 - Invalid [EventStreamId] template
ARCCHR0018 - Event stream id template only resolved for commands
ARCCHR0019 - Read-model fold may be exposed as a query
ARCCHR0020 - Wrapper event stream is not declared
ARCCHR0021 - Use event source definition routing
ARCCHR0022 - Command-key aggregate on a generated append target
ARCCHR0023 - Read-model lookup key is not proven
ARCCHR0024 - Read-model shape cannot be protected
ARCCHR0025 - Keyless command reads Chronicle state
ARCCHR0026 - Chronicle model read through a MongoDB collection
ARCCHR0027 - Refusal branch must return registered events or acknowledge
ARCCHR0028 - Chronicle read is not proven protected
ARCCHR0029 - Conflicting read protection
ARCCHR0031 - Invalid read-model lookup
ARCCHR0032 - Inert or redundant declaration
ARCCHR0033 - Aggregate and read-model parameter share a source
ARCCHR0034 - Method advisory does not cover parameters
ARCCHR0035 - Protected aggregate committed too early
ARCCHR0036 - Exact scope coverage is not proven
ARCCHR0037 - Read model stream is not on the command route
ARCCHR0038 - Stream read guard widens
Generating a principal for local development
Generating a Screenplay
Embedded event-model explorer
Other backend implementations
Kotlin and Java
Overview
Why Arc for Kotlin and Java
Coming from Spring MVC
Get started
Get started with Kotlin
Overview
Get started with Java
Commands
Command keys
Queries
Observable queries
Validation
Authentication and authorization
Tenancy
Development users and tenants
Pipeline filters
Execution scopes
Spring Data
Overview
Map JPA concepts
Map MongoDB concepts
Repositories in queries and commands
Observable storage snapshots
Read-model naming
Proxy Generation
Code Analysis
OpenAPI
Using the generated client
Observability
Testing
Chronicle
Reference
Reference
Overview
Annotations
Configuration
HTTP contract
Shared fluent validation
TypeScript proxy options matrix
Glossary
Feature parity
Troubleshooting and FAQ
TypeScript
Overview
Why Arc for TypeScript
Coming from Express and NestJS
Getting Started
Quickstart
Run the Tasks sample
Your first command
Continue in the browser
Create an application
Explore the Library sample
Vertical slices
Hosting overview
Arc.Core
Arc.Core and the standalone host
Build an application
Endpoint mapping
Static files and SPA fallback
Authentication
Authorization policies and schemes
Host adapters
Overview
Express
Fastify
Hono
Fetch API runtimes
WebSockets
Native principal
Configuration
Migrating to secure discovery defaults
Commands
Overview
Model-bound commands
Model-bound commands
Authorization
Command validation
Validation severity filtering
Command pipeline
Command outcomes
Command operations
Overview
Implementing operations
Reference
Response value handlers
Command context
Command filters
Command execution scopes
Low-level definitions
Calling commands from code
Queries
Overview
Model-bound queries
Model-bound queries
Query arguments
Paging and sorting
Query validation
Query pipeline
Query filters
Using the HTTP QUERY method
Observable queries
Subscribe to an observable query
Multiplexed observable queries
Observable emission guards
Query health
Using observable queries with curl
Query renderers
Read-model interception
Chronicle read consistency
Authorizing commands and queries
Concepts
Dependency injection
Identity
Identity details
How identity details are served
Identity contracts
Authenticate an API with Microsoft Entra ID
Accept AuthProxy or EasyAuth identity headers
Authenticate observable query transports
Show identity in a React frontend
Identity across services
Simulate a signed-in user locally
Development users and tenants
Tenancy
Overview
Tenancy end to end
Tenant resolvers
Storage isolation
MongoDB
Overview
Get started
Tenancy
Serializers
Naming policies
Paging
Observing collections
Joined observation
Change-stream watcher
Geospatial types
SQL with Drizzle
Overview
Get started
Column types and conversions
Map the schema and own migrations
Paging and sorting
Observe tables in process
Observe PostgreSQL across processes
Tenancy
Proxy Generation
Overview
Set up proxy generation
Use generated proxies in React
What the generator writes
Configuration
Generated artifact metadata
Type mapping
Validation rules
File index tracking
Low-level manifest
Code Analysis
Overview and .NET mapping
ARC0002 Missing command
ARC0003 External handler
ARC0004 Missing handler
ARC0005 Unused provided value
ARC0010 Unnecessary async handler
ARC0012 Built-in error
ARC0013 Not applicable
ARC0014 Generic query
ARC0015 Late concept conversion
ARC0019 Authorization conflict
ARCCHR0003 Reactor default log
ARCCHR0006 Reactor replay decision
ARCCHR0007 Command default log
ARCCHR0009 Sensitive command fields
ARCCHR0010 Guid response
Missing field
Declared field
Injection binding
Query binding
Query argument name (opt-in)
Misplaced decorator
Unexported artifact
Validator target
OpenAPI
OpenAPI
Concepts
Commands
Queries
Enums
Model-bound and low-level operations
How types appear in the document
Introspection
Overview
Commands
Queries
Identity details schema
Decorator reference
Observability
Testing
Overview
Test a command's decision
Test operations and compensation
Commands
node:test
Queries
Observable queries
Low-level definitions and HTTP
Chronicle commands
Chronicle kernel scenarios
Chronicle
Overview
Add event sourcing
Registration options
Cratis package
Commands
Returning events
Event metadata
Event source definitions
Subject
Concurrency
Causation and auditing
Transactional commands
Resolving the event source ID
Read models
Read models
Read models in commands
When resolution fails
Aggregates
Overview
Defining an aggregate root
Injecting into commands
Reactors
Reactors
Returning commands
Scoped activation (preview)
Compliance
Code analysis
Architecture
Troubleshooting
Reference
Reference
Overview
Capabilities
HTTP contract
Packages
Wire format
Diagnostics
Glossary
Contributing
Change a sample
Prepare and publish a release
Go
Overview
Go foundation
Get started
Hosting
Overview
Lifecycle
Middleware
Operation diagnostics
Hosting options
HTTP contract
Chi recipe
Gin recipe
Echo recipe
Discovery
Overview
Schemas
Concepts and JSON values
Overview
Int32 enums
Commands
Overview
Model-bound commands
Command authorization
Execute a command
Command context and keys
Command filters
Protected decision reads
Flat command operations
Command execution scopes
Validate commands
Validation severity filtering
Response value handlers
Command return shapes
Traditional action handlers
Queries
Overview
Query pipeline
Model-bound queries
Overview
Namespace methods and functions
Dependencies
Arguments
Return types
Paging and sorting
Authorization
Read-model interception
GET and HTTP QUERY readers
Query validation
Observable queries
Observable HTTP
Observable query hub
Emission guards
Collection change streams
Protected query health
Generate adapters and proxies
Overview
Constructor services
TypeScript proxies
Directives and signatures
Chronicle integration
Overview
Chronicle decision reads
MongoDB snapshots
Overview
Multiple instances
Command results
Query results
Testing
Validation and severity
Authentication handlers
Authorization policies
Identity details
Tenant selection and membership
Routes and identities
Execution metadata
Dependency injection and operation resources
Parity
Releases
Frontend
Overview
Core
Overview
Commands
Overview
Command Result
Validation
Command Contracts
Configuration
Validation And Results
Backend Integration
Validation
Overview
Rules And Fluent API
Command And Query Integration
Validation Results
Severity Filtering
Queries
Overview
Query Contracts
Configuration
Validation And Behavior
Backend Integration
Identity
Messaging
React
Overview
Getting started
Quickstart
Arc
Identity
Dialogs
Messaging
Commands
Overview
React Usage
Data Binding
Validation
Scope
Imperative Usage
CommandForm
Overview
Field Types
Overview
InputTextField
NumberField
TextAreaField
CheckboxField
RadioButtonField
RadioGroupField
RangeField
SelectField
Creating Custom Fields
Validation
Auto Server Validation
Customization
Layouts
Working with Hooks
Data Loading
Form Lifecycle
Advanced Patterns
Queries
Overview
Configuration
Core Query Usage
Paging
Observable Queries
Observable Query Diagnostics
Suspense Queries
Conditional Queries
Change Stream
Observable Query Multiplexing
Query Instance Caching
Scope
Vite Configuration
Proxy Generation
MVVM with React
Overview
MVVM Context
Using ViewModel
TSyringe
Dialogs
Browser
Messaging
Identity
Story Components
Overview
Components
Styling
Theme Support
Storybook
Operations and reference
Troubleshooting
Connection resolution contract
Capability matrix
Upgrading
Overview
Secure defaults
Migrate generated identifiers
Blog
GitHub
Discord
YouTube
Select theme
Dark
Light
Auto
Storybook
Community:
Discord
