Skip to content

The write side of the domain: a schema of events, a projection that folds them into state, and commands that inspect that state and decide on new events.

An aggregate is plain data. AggregateService gives it a store to run against, and Fixture runs it in tests.

Defined in: src/Aggregate.ts:176

An event as it was stored in the past, in an older version of its schema. Construct one directly to replay JSON taken from a database.

new Historical(options): Historical

Defined in: src/Aggregate.ts:180

Json

number

string

Historical

readonly payload: Json

Defined in: src/Aggregate.ts:179

readonly schemaVersion: number

Defined in: src/Aggregate.ts:178

readonly type: string

Defined in: src/Aggregate.ts:177

Defined in: src/Aggregate.ts:86

Name extends string

State

Events extends EventSchema<any>

Commands extends Record<string, AnyCommand>

V extends Versions<Events["Type"]> = { }

readonly commands: Commands

Defined in: src/Aggregate.ts:97

readonly events: Events

Defined in: src/Aggregate.ts:94

readonly initial: State

Defined in: src/Aggregate.ts:95

readonly name: Name

Defined in: src/Aggregate.ts:93

readonly projection: Projection<State, Events["Type"]>

Defined in: src/Aggregate.ts:96

readonly versions: V

Defined in: src/Aggregate.ts:98

command<CommandName, Payload, E, R>(name, options): Aggregate<Name, State, Events, Commands & Record<CommandName, Command<Payload, State, Events["Type"], E, R>>, V>

Defined in: src/Aggregate.ts:100

Returns a new aggregate that also accepts this command.

CommandName extends string

Payload extends PayloadSchema

E = never

R = never

CommandName

CommandHandler<State, Payload["Type"], Events["Type"], E, R>

Payload

Aggregate<Name, State, Events, Commands & Record<CommandName, Command<Payload, State, Events["Type"], E, R>>, V>


Defined in: src/Aggregate.ts:73

readonly handler: CommandHandler<any, any, any, any, any>

Defined in: src/Aggregate.ts:75

readonly payload: PayloadSchema

Defined in: src/Aggregate.ts:74


Defined in: src/Aggregate.ts:68

Payload extends PayloadSchema

State

Event

E

R

readonly handler: CommandHandler<State, Payload["Type"], Event, E, R>

Defined in: src/Aggregate.ts:70

readonly payload: Payload

Defined in: src/Aggregate.ts:69


Defined in: src/Aggregate.ts:43

readonly aggregateId: string

Defined in: src/Aggregate.ts:44

readonly version: number

Defined in: src/Aggregate.ts:45


Defined in: src/Aggregate.ts:29

Where an event sits in its stream and in the store.

readonly aggregateId: string

Defined in: src/Aggregate.ts:31

readonly aggregateName: string

Defined in: src/Aggregate.ts:30

readonly causationId: string | null

Defined in: src/Aggregate.ts:38

What directly caused the command that recorded the event.

readonly correlationId: string | null

Defined in: src/Aggregate.ts:36

Shared by everything that follows from one original request, see Causation.

readonly metadata: JsonObject

Defined in: src/Aggregate.ts:40

What the command carried beside its payload, such as the software version, see Metadata.

readonly position: number

Defined in: src/Aggregate.ts:33

readonly timestamp: Utc

Defined in: src/Aggregate.ts:34

readonly version: number

Defined in: src/Aggregate.ts:32


Defined in: src/Aggregate.ts:13

readonly _tag: string

Defined in: src/Aggregate.ts:14

Any = Aggregate<string, any, EventSchema<any>, Record<string, AnyCommand>, any>

Defined in: src/Aggregate.ts:109


CommandError<A, K> = A["commands"][K] extends Command<any, any, any, infer E, any> ? E : never

Defined in: src/Aggregate.ts:117

A extends Any

K extends CommandName<A> = CommandName<A>


CommandHandler<State, Payload, Event, E, R> = (state, payload, context) => Effect.Effect<Event | ReadonlyArray<Event>, E, R>

Defined in: src/Aggregate.ts:62

Decides on the events a command produces. It may run several times when concurrent writers collide, so it should only decide and leave side effects to view models. Returning an empty array records nothing.

State

Payload

Event

E

R

State

Payload

CommandContext

Effect.Effect<Event | ReadonlyArray<Event>, E, R>


CommandName<A> = keyof A["commands"] & string

Defined in: src/Aggregate.ts:115

A extends Any


Commands<A> = A["commands"]

Defined in: src/Aggregate.ts:114

A extends Any


Context<A> = A["commands"][CommandName<A>] extends Command<any, any, any, any, infer R> ? R : never

Defined in: src/Aggregate.ts:119

A extends Any


Event<A> = A["events"]["Type"]

Defined in: src/Aggregate.ts:113

A extends Any


EventSchema<Event> = Schema.Top & object

Defined in: src/Aggregate.ts:17

Event extends Tagged = Tagged

readonly DecodingServices: never

readonly EncodingServices: never

readonly Type: Event


Name<A> = A["name"]

Defined in: src/Aggregate.ts:111

A extends Any


Payload<A, K> = A["commands"][K]["payload"]["Type"]

Defined in: src/Aggregate.ts:116

A extends Any

K extends CommandName<A>


PayloadSchema = Schema.Top & object

Defined in: src/Aggregate.ts:23

readonly DecodingServices: never

readonly EncodingServices: never


Projection<State, Event> = { readonly [Tag in Event["_tag"]]: (state: State, event: Extract<Event, { _tag: Tag }>, meta: EventMeta) => State }

Defined in: src/Aggregate.ts:49

Exhaustive by event tag, so adding an event to the schema without folding it does not compile.

State

Event extends Tagged


State<A> = A["initial"]

Defined in: src/Aggregate.ts:112

A extends Any


Versions<Event> = { readonly [Tag in Event["_tag"]]?: Any<Extract<Event, { _tag: Tag }>> }

Defined in: src/Aggregate.ts:82

The older shapes of some events, keyed by tag. Each history has to end in the event’s current shape.

Event extends Tagged

evolve<A>(aggregate, state, event, meta): State<A>

Defined in: src/Aggregate.ts:159

Folds one event into the state.

A extends Any

A

State<A>

Event<A>

EventMeta

State<A>


historical<A, Tag, Version>(aggregate, tag, version, value): Historical

Defined in: src/Aggregate.ts:192

Encodes an event in an older version of its schema, as code from that time would have stored it. The value is checked against that version, so a test can’t seed a shape that never existed.

A extends Any

Tag extends string

Version extends number

A

Tag

Version

SchemaAt<NonNullable<A["versions"][Tag]>, Version>["Type"]

Historical


make<State>(): <Name, Events, V>(options) => Aggregate<Name, State, Events, { }, V>

Defined in: src/Aggregate.ts:147

The state is given explicitly, Aggregate.make<State>()({ ... }), so that the projection’s return values are checked against it rather than widened.

State

<Name, Events, V>(options) => Aggregate<Name, State, Events, { }, V>


schemaVersion(aggregate, tag): number

Defined in: src/Aggregate.ts:169

The schema version new events with this tag are written with.

Any

string

number