Skip to content

Cratis Platform glossary for event sourcing and CQRS

Event sourcing comes with its own vocabulary, and the Cratis stack adds a few terms of its own. This page gives a short definition of each term across the stack, so the same word means the same thing on every page. Where a term has a fuller explanation, the name links to it. The products keep their own, more detailed glossaries: Chronicle, Arc, and Screenplay.

These are the core ideas behind Chronicle. The Concepts section explains how they fit together.

Term Definition
Event A fact — something that happened, named in the past tense (AccountOpened). Immutable and single-purpose. By convention an event has no nullable properties (Chronicle’s analyzers warn about them); an optional value usually means you need a second event.
Event type The schema and identity of an event — its shape and name.
Event source The thing an event happened to, identified by an id (an account, a book).
Event source definition A declared kind of event source (an account) with its named event streams and the dimensions that guard appends to each. The typed way to say where events go.
Event stream A named part of an event source’s history, such as an account’s monthly transactions. Identified by a stream type and a stream id.
Event sequence An ordered, append-only stream of events you can subscribe to. The event log is the primary one — your source of truth.
Sequence number An event’s position within a sequence.
Event store The database that holds event sequences.
Event sourcing Storing state as the full history of events, deriving current state by replaying them. See when to use it.
Namespace A partition of an event store, used for multi-tenancy.
Tenant An isolated set of data for one customer — see namespaces.
Workspace The place people work inside one product: the product-facing name for a tenant. The product owns its members and roles.
Organization The customer as a whole, across Cratis products. Holds sign-in policies, not members. Platform organizations are planned.
Identity Who or what caused an event.
Correlation Links events that belong to the same logical operation.
Causation The chain of steps that led to an event, such as the root process and the command that appended it. With Arc, the command’s name and property values are recorded in the chain, permanently.
Tags Labels on events for filtering and correlation — see also event metadata tags.
Aggregate A consistency boundary that encapsulates behavior and produces events.
Constraint A rule, such as uniqueness, that Chronicle checks when an event is appended and rejects the append if it fails.
Dynamic consistency boundary Enforcing a rule that depends on current state under concurrency, by checking the state the decision was based on when the events are appended. Chronicle supports DCB-style decision models and append conditions; each event belongs to one event source. See keeping decisions correct.
Concurrency scope The condition on one append: a position in the event log and a filter (event types, event source, stream). The kernel rejects the append if a matching event was written after the position. See concurrency.
Append condition What Chronicle checks together with an append: one or more concurrency scopes. Also called a guard when it comes from a read. See how guards are derived.
Decision read A read of a read model that notes the log position before it folds, so the state you decide on becomes an append condition.
Read protection Refusing reads that cannot guard a decision. In Chronicle it is the API that enforces this inside one unit of work. In Arc’s .NET backend it is a mode, Off, Measure or On, that turns the API on for your commands. See keeping decisions correct.
Protected read A read under read protection On that is read fresh and guarded, such as a read-model parameter on a command.
Advisory read A read that is allowed but guards nothing, because a stale value is acceptable. In Arc’s .NET backend it is marked [Unprotected("why")].
Measure The .NET Arc read protection mode between Off and On. Nothing changes for callers, and Arc records what On would do, so you can fix refused reads before turning it on.
Per-stream read model A read model that folds one stream of an event source, such as one account’s withdrawals in one month. The .NET declaration uses [EventStream<TSource>(stream)].
Stream decision In Arc’s .NET backend, a command reads the raw events of one stream through IStreamReads and returns StreamDecision.Append(...), which guards that stream at the tail it read.
Subject The person or entity whose personal data an event contains. PII is encrypted under a key per subject, which defaults to the event source id.
PII Personal data marked for encryption at append time so it can be erased by deleting the subject’s key. Marking syntax varies by client; .NET uses [PII]. See event sourcing and GDPR.

How events become the things you read and the actions you take.

Term Definition
Observer Anything that watches events and acts — a projection, reducer, or reactor.
Projection Builds a read model by mapping events declaratively.
Reducer Builds a read model by folding events imperatively.
Reactor Produces side effects (notifications, calls to other systems) in response to events. An event can be delivered to a reactor more than once, so side effects should be safe to repeat.
Replay Running an observer over events it has already processed, for example to rebuild a read model. Replay can re-deliver events to reactors. Where supported, a once-only handler skips replay; .NET marks it with [OnceOnly].
Read model A queryable view shaped for one screen or question, built from events.
Changeset The set of changes an observer applies for a single event.
Eventual consistency A read model that catches up shortly after an event is appended — the default.
Immediate consistency Read-after-write for a specific read: a passive model keyed by its event source id replays that source’s events on demand, or the caller waits for the append’s observers before reading a materialized model. Materialized projections update asynchronously, not inside the append. Fresh reads alone do not protect write-side decisions; use constraints or decision reads.

The terms Arc and Components add on top of Chronicle.

Term Definition
Command An intent to change state. Arc’s command declarations and handler APIs vary by backend. With Chronicle integration, a handler can return events for Arc to append; it can also return a response or nothing where supported.
Query A read of data, exposed to the frontend as a typed proxy.
Observable query A query that holds a live connection and pushes new results when the data changes.
CQRS Command Query Responsibility Segregation — separating the write side (commands) from the read side (queries). See it in C#, TypeScript, Kotlin and Java, and Elixir.
Proxy generation Arc emitting a typed TypeScript client from backend commands and queries. Configure generation for your chosen backend.
Concept A strongly-typed wrapper around a primitive (AccountId over Guid) so the compiler catches mix-ups.
Agentic development Letting AI coding agents design, change and operate a system whose state is an event log and whose behavior is checked by executable specifications.
Vertical slice Everything for one behavior — command, events, projection, UI, specs — kept together in one folder.
Event modeling Designing a system as one timeline of screens, commands, events and read models before writing code.
Spec-driven development Writing the event model and its Given/When/Then specifications first, then checking code, written by people or agents, against them.

New to all this? Start with Why developers choose Cratis, then the Chronicle tutorial.