effect-cqrs 0.0.0-stage → 0.2.0

package/dist/Causation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Causation.d.ts","sourceRoot":"","sources":["../src/Causation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,EAAE,OAAO,EAAE,MAAM,EAAY,MAAM,QAAQ,CAAA;AAClD,OAAO,EAAW,KAAK,WAAW,EAAE,MAAM,iBAAiB,CAAA;AAE3D,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAA;IAC9B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;CAC7B;AAED,4EAA4E;AAC5E,eAAO,MAAM,gBAAgB,0CAE3B,CAAA;AAEF,2FAA2F;AAC3F,eAAO,MAAM,aAAa,EAAE;IAC1B,CAAC,SAAS,EAAE,SAAS,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAA;IAC3F,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,SAAS,EAAE,SAAS,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAA;CAKxF,CAAA;AAED,mEAAmE;AACnE,eAAO,MAAM,SAAS,UAAW,WAAW,KAAG,SAG9C,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,QAAQ,UAAW,WAAW,MAAM,CAAC,EAAE,CAAC,EAAE,CAAC,UAAU,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAG,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAC7C,CAAA"}

package/dist/Causation.js

@@ -0,0 +1,32 @@
+/**
+ * Why an event was recorded. Every event carries two ids:
+ *
+ * - `correlationId` is shared by everything that follows from one original
+ *   request, across aggregates and view models.
+ * - `causationId` names what directly caused the command that recorded it: the
+ *   request, or the event a view model or saga was reacting to.
+ *
+ * They travel in the fiber's context rather than in payloads. A command run
+ * outside any causation starts a new correlation with a fresh id. Inside a view
+ * model handler the event being handled is the cause, so a chain of reactions
+ * can be drawn as a tree without passing ids around by hand.
+ */
+import { Context, Effect, Function } from "effect";
+import { eventId } from "./EventStore.js";
+/** The causation of commands run in this fiber, `undefined` outside any. */
+export const CurrentCausation = Context.Reference("effect-cqrs/Causation", {
+    defaultValue: () => undefined
+});
+/** Runs an effect with this causation, for instance the id of an incoming HTTP request. */
+export const withCausation = Function.dual(2, (effect, causation) => Effect.provideService(effect, CurrentCausation, causation));
+/** The causation of commands run in reaction to a stored event. */
+export const fromEvent = (event) => {
+    const id = eventId(event);
+    return { correlationId: event.correlationId ?? id, causationId: id };
+};
+/**
+ * Runs an effect in reaction to a stored event, so commands it runs record that
+ * event as their cause. View models do this for their handlers already.
+ */
+export const causedBy = (event) => (effect) => Effect.provideService(effect, CurrentCausation, fromEvent(event));
+//# sourceMappingURL=Causation.js.map

package/dist/Causation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Causation.js","sourceRoot":"","sources":["../src/Causation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAA;AAClD,OAAO,EAAE,OAAO,EAAoB,MAAM,iBAAiB,CAAA;AAO3D,4EAA4E;AAC5E,MAAM,CAAC,MAAM,gBAAgB,GAAG,OAAO,CAAC,SAAS,CAAwB,uBAAuB,EAAE;IAChG,YAAY,EAAE,GAAG,EAAE,CAAC,SAAS;CAC9B,CAAC,CAAA;AAEF,2FAA2F;AAC3F,MAAM,CAAC,MAAM,aAAa,GAGtB,QAAQ,CAAC,IAAI,CACf,CAAC,EACD,CAAU,MAA8B,EAAE,SAAoB,EAAE,EAAE,CAChE,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,gBAAgB,EAAE,SAAS,CAAC,CAC7D,CAAA;AAED,mEAAmE;AACnE,MAAM,CAAC,MAAM,SAAS,GAAG,CAAC,KAAkB,EAAa,EAAE;IACzD,MAAM,EAAE,GAAG,OAAO,CAAC,KAAK,CAAC,CAAA;IACzB,OAAO,EAAE,aAAa,EAAE,KAAK,CAAC,aAAa,IAAI,EAAE,EAAE,WAAW,EAAE,EAAE,EAAE,CAAA;AACtE,CAAC,CAAA;AAED;;;GAGG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,CAAC,KAAkB,EAAE,EAAE,CAAC,CAAU,MAA8B,EAA0B,EAAE,CAClH,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,gBAAgB,EAAE,SAAS,CAAC,KAAK,CAAC,CAAC,CAAA"}

package/dist/Checkpoints.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Remembers how far each view model has read.
+ *
+ * A checkpoint has to live as long as the view model it tracks: pair an
+ * in-memory view model with {@link layerMemory} so it rebuilds from the event
+ * store on restart, and a durable one with a durable checkpoint store.
+ */
+import { Context, Effect, Layer } from "effect";
+import type { EventStoreError } from "./EventStore.ts";
+declare const Checkpoints_base: Context.ServiceClass<Checkpoints, "effect-cqrs/Checkpoints", {
+    /** The last processed position, `0` when the view model never ran. */
+    get(viewModel: string): Effect.Effect<number, EventStoreError>;
+    set(viewModel: string, position: number): Effect.Effect<void, EventStoreError>;
+}>;
+export declare class Checkpoints extends Checkpoints_base {
+}
+export declare const layerMemory: Layer.Layer<Checkpoints>;
+export {};
+//# sourceMappingURL=Checkpoints.d.ts.map

package/dist/Checkpoints.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Checkpoints.d.ts","sourceRoot":"","sources":["../src/Checkpoints.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAA;AAC/C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAA;;IAGpD,sEAAsE;mBACvD,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC;mBAC/C,MAAM,YAAY,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,eAAe,CAAC;;AAHhF,qBAAa,WAAY,SAAQ,gBAIF;CAAG;AAElC,eAAO,MAAM,WAAW,EAAE,KAAK,CAAC,KAAK,CAAC,WAAW,CAM/C,CAAA"}

package/dist/Checkpoints.js

@@ -0,0 +1,18 @@
+/**
+ * Remembers how far each view model has read.
+ *
+ * A checkpoint has to live as long as the view model it tracks: pair an
+ * in-memory view model with {@link layerMemory} so it rebuilds from the event
+ * store on restart, and a durable one with a durable checkpoint store.
+ */
+import { Context, Effect, Layer } from "effect";
+export class Checkpoints extends Context.Service()("effect-cqrs/Checkpoints") {
+}
+export const layerMemory = Layer.sync(Checkpoints, () => {
+    const positions = new Map();
+    return Checkpoints.of({
+        get: (viewModel) => Effect.sync(() => positions.get(viewModel) ?? 0),
+        set: (viewModel, position) => Effect.sync(() => void positions.set(viewModel, position))
+    });
+});
+//# sourceMappingURL=Checkpoints.js.map

package/dist/Checkpoints.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Checkpoints.js","sourceRoot":"","sources":["../src/Checkpoints.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAA;AAG/C,MAAM,OAAO,WAAY,SAAQ,OAAO,CAAC,OAAO,EAI5C,CAAC,yBAAyB,CAAC;CAAG;AAElC,MAAM,CAAC,MAAM,WAAW,GAA6B,KAAK,CAAC,IAAI,CAAC,WAAW,EAAE,GAAG,EAAE;IAChF,MAAM,SAAS,GAAG,IAAI,GAAG,EAAkB,CAAA;IAC3C,OAAO,WAAW,CAAC,EAAE,CAAC;QACpB,GAAG,EAAE,CAAC,SAAS,EAAE,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;QACpE,GAAG,EAAE,CAAC,SAAS,EAAE,QAAQ,EAAE,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,KAAK,SAAS,CAAC,GAAG,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;KACzF,CAAC,CAAA;AACJ,CAAC,CAAC,CAAA"}

package/dist/EventStore.d.ts

@@ -0,0 +1,132 @@
+/**
+ * The append-only log every aggregate and view model is built on.
+ *
+ * Each event belongs to a stream, identified by aggregate name and id, and has
+ * two coordinates: a `version` that orders it inside its stream and a `position`
+ * that orders it across the whole store. Writers use the version for optimistic
+ * concurrency, readers use the position as a durable cursor.
+ */
+import { Context, DateTime, Effect, Layer, Schema, Stream } from "effect";
+declare const EventStoreError_base: Schema.Class<EventStoreError, Schema.TaggedStruct<"EventStoreError", {
+    readonly operation: Schema.String;
+    readonly cause: Schema.Defect;
+}>, import("effect/Cause").YieldableError>;
+export declare class EventStoreError extends EventStoreError_base {
+}
+declare const ConcurrencyConflict_base: Schema.Class<ConcurrencyConflict, Schema.TaggedStruct<"ConcurrencyConflict", {
+    readonly aggregateName: Schema.String;
+    readonly aggregateId: Schema.String;
+    readonly expectedVersion: Schema.Int;
+}>, import("effect/Cause").YieldableError>;
+export declare class ConcurrencyConflict extends ConcurrencyConflict_base {
+}
+export declare const StoredEvent: Schema.Struct<{
+    readonly position: Schema.Int;
+    readonly aggregateName: Schema.String;
+    readonly aggregateId: Schema.String;
+    readonly version: Schema.Int;
+    readonly type: Schema.String;
+    /** The version of the event's schema the payload was written with. Events from before versions existed are `1`. */
+    readonly schemaVersion: Schema.Int;
+    readonly payload: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly timestamp: Schema.DateTimeUtcFromMillis;
+    /** Shared by everything that follows from one original request. */
+    readonly correlationId: Schema.NullOr<Schema.String>;
+    /** What directly caused the command that recorded the event: a request, a command or another event. */
+    readonly causationId: Schema.NullOr<Schema.String>;
+    /** What the command carried beside its payload, see `Metadata`. Events from before metadata existed have `{}`. */
+    readonly metadata: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+}>;
+export type StoredEvent = typeof StoredEvent.Type;
+export interface NewEvent {
+    readonly type: string;
+    readonly payload: Schema.Json;
+    /** Defaults to `1`. */
+    readonly schemaVersion?: number | undefined;
+}
+export interface AppendInput {
+    readonly aggregateName: string;
+    readonly aggregateId: string;
+    /** The stream version the writer based its decision on, `0` for a new stream. */
+    readonly expectedVersion: number;
+    readonly events: ReadonlyArray<NewEvent>;
+    readonly correlationId?: string | undefined;
+    readonly causationId?: string | undefined;
+    /** Recorded on every event of the append. Defaults to `{}`. */
+    readonly metadata?: Schema.JsonObject | undefined;
+}
+/**
+ * Identifies an event wherever it is stored, as the `causationId` of what it causes:
+ * `account/alice@4`. Name and id are URI-encoded, so a `/` or `@` inside one can't
+ * make two events look alike.
+ */
+export declare const eventId: (event: Pick<StoredEvent, "aggregateName" | "aggregateId" | "version">) => string;
+/** The columns every adapter stores for a new event, with the defaults filled in. */
+export declare const toStored: (input: AppendInput, event: NewEvent, index: number, position: number, timestamp: DateTime.Utc) => StoredEvent;
+/**
+ * Selects events by stream, type and time. Omitted fields match everything.
+ * `startTime` is inclusive and `finishTime` is exclusive, so adding one
+ * millisecond to a history timestamp selects up to and including that event.
+ */
+export interface EventFilter {
+    readonly aggregateNames?: ReadonlyArray<string> | undefined;
+    readonly aggregateIds?: ReadonlyArray<string> | undefined;
+    readonly eventTypes?: ReadonlyArray<string> | undefined;
+    readonly startTime?: DateTime.Utc | undefined;
+    readonly finishTime?: DateTime.Utc | undefined;
+    readonly afterPosition?: number | undefined;
+    /**
+     * For a filter on one stream: where to continue in it. Versions follow the stream's
+     * own index, so resuming there costs the same however far the log has moved on.
+     */
+    readonly afterVersion?: number | undefined;
+}
+/** A filter on exactly one stream, which a store can read through that stream's index. */
+export declare const isOneStream: ({ aggregateIds, aggregateNames }: EventFilter) => boolean;
+declare const EventStore_base: Context.ServiceClass<EventStore, "effect-cqrs/EventStore", {
+    /** Appends atomically, failing if the stream moved past `expectedVersion`. */
+    append(input: AppendInput): Effect.Effect<ReadonlyArray<StoredEvent>, ConcurrencyConflict | EventStoreError>;
+    /** Reads the events stored so far, ordered by position, then completes. */
+    read(filter?: EventFilter): Stream.Stream<StoredEvent, EventStoreError>;
+    /** Reads the events stored so far, then keeps following new ones. Never completes. */
+    subscribe(filter?: EventFilter): Stream.Stream<StoredEvent, EventStoreError>;
+    /** The position of the latest event, `0` when the store is empty. */
+    readonly head: Effect.Effect<number, EventStoreError>;
+    /**
+     * Emits the current latest position, then each newly appended one. Consumers
+     * can treat an element as "there may be something new": appends from other
+     * processes are not observed.
+     */
+    readonly changes: Stream.Stream<number>;
+}>;
+export declare class EventStore extends EventStore_base {
+}
+/** What a storage adapter implements. {@link make} builds the rest on top. */
+export interface Backend {
+    readonly append: EventStore["Service"]["append"];
+    readonly readBatch: (filter: EventFilter, afterPosition: number, limit: number) => Effect.Effect<ReadonlyArray<StoredEvent>, EventStoreError>;
+    readonly head: Effect.Effect<number, EventStoreError>;
+}
+export declare const make: (backend: Backend, options?: {
+    readonly batchSize?: number;
+} | undefined) => Effect.Effect<{
+    /** Appends atomically, failing if the stream moved past `expectedVersion`. */
+    append(input: AppendInput): Effect.Effect<ReadonlyArray<StoredEvent>, ConcurrencyConflict | EventStoreError>;
+    /** Reads the events stored so far, ordered by position, then completes. */
+    read(filter?: EventFilter): Stream.Stream<StoredEvent, EventStoreError>;
+    /** Reads the events stored so far, then keeps following new ones. Never completes. */
+    subscribe(filter?: EventFilter): Stream.Stream<StoredEvent, EventStoreError>;
+    /** The position of the latest event, `0` when the store is empty. */
+    readonly head: Effect.Effect<number, EventStoreError>;
+    /**
+     * Emits the current latest position, then each newly appended one. Consumers
+     * can treat an element as "there may be something new": appends from other
+     * processes are not observed.
+     */
+    readonly changes: Stream.Stream<number>;
+}, EventStoreError, never>;
+export declare const makeMemory: Effect.Effect<EventStore["Service"], EventStoreError>;
+/** Keeps events in process memory. They do not survive a restart. */
+export declare const layerMemory: Layer.Layer<EventStore, EventStoreError>;
+export {};
+//# sourceMappingURL=EventStore.d.ts.map

package/dist/EventStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EventStore.d.ts","sourceRoot":"","sources":["../src/EventStore.ts"],"names":[],"mappings":"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"}

package/dist/EventStore.js

@@ -0,0 +1,156 @@
+/**
+ * The append-only log every aggregate and view model is built on.
+ *
+ * Each event belongs to a stream, identified by aggregate name and id, and has
+ * two coordinates: a `version` that orders it inside its stream and a `position`
+ * that orders it across the whole store. Writers use the version for optimistic
+ * concurrency, readers use the position as a durable cursor.
+ */
+import { Context, DateTime, Effect, Layer, Option, Ref, Schema, Stream, SubscriptionRef } from "effect";
+export class EventStoreError extends Schema.TaggedError()("EventStoreError", {
+    operation: Schema.String,
+    cause: Schema.Defect()
+}) {
+}
+export class ConcurrencyConflict extends Schema.TaggedError()("ConcurrencyConflict", {
+    aggregateName: Schema.String,
+    aggregateId: Schema.String,
+    expectedVersion: Schema.Int
+}) {
+}
+export const StoredEvent = Schema.Struct({
+    position: Schema.Int,
+    aggregateName: Schema.String,
+    aggregateId: Schema.String,
+    version: Schema.Int,
+    type: Schema.String,
+    /** The version of the event's schema the payload was written with. Events from before versions existed are `1`. */
+    schemaVersion: Schema.Int,
+    payload: Schema.Json,
+    timestamp: Schema.DateTimeUtcFromMillis,
+    /** Shared by everything that follows from one original request. */
+    correlationId: Schema.NullOr(Schema.String),
+    /** What directly caused the command that recorded the event: a request, a command or another event. */
+    causationId: Schema.NullOr(Schema.String),
+    /** What the command carried beside its payload, see `Metadata`. Events from before metadata existed have `{}`. */
+    metadata: Schema.JsonObject
+});
+/**
+ * Identifies an event wherever it is stored, as the `causationId` of what it causes:
+ * `account/alice@4`. Name and id are URI-encoded, so a `/` or `@` inside one can't
+ * make two events look alike.
+ */
+export const eventId = (event) => `${encodeURIComponent(event.aggregateName)}/${encodeURIComponent(event.aggregateId)}@${event.version}`;
+/** The columns every adapter stores for a new event, with the defaults filled in. */
+export const toStored = (input, event, index, position, timestamp) => ({
+    position,
+    aggregateName: input.aggregateName,
+    aggregateId: input.aggregateId,
+    version: input.expectedVersion + index + 1,
+    type: event.type,
+    schemaVersion: event.schemaVersion ?? 1,
+    payload: event.payload,
+    timestamp,
+    correlationId: input.correlationId ?? null,
+    causationId: input.causationId ?? null,
+    metadata: input.metadata ?? {}
+});
+/** A filter on exactly one stream, which a store can read through that stream's index. */
+export const isOneStream = ({ aggregateIds, aggregateNames }) => aggregateNames?.length === 1 && aggregateIds?.length === 1;
+export class EventStore extends Context.Service()("effect-cqrs/EventStore") {
+}
+export const make = Effect.fnUntraced(function* (backend, options) {
+    const batchSize = options?.batchSize ?? 500;
+    const latest = yield* SubscriptionRef.make(yield* backend.head);
+    const append = Effect.fn("EventStore.append")((input) => backend.append(input).pipe(Effect.tap((stored) => {
+        const last = stored.at(-1);
+        return last === undefined
+            ? Effect.void
+            : SubscriptionRef.update(latest, (position) => Math.max(position, last.position));
+    })));
+    const read = (filter = {}) => Stream.paginate({ afterPosition: filter.afterPosition ?? 0, afterVersion: filter.afterVersion ?? 0 }, ({ afterPosition, afterVersion }) => backend.readBatch({ ...filter, afterVersion }, afterPosition, batchSize).pipe(Effect.map((events) => {
+        const last = events.at(-1);
+        return [
+            events,
+            last === undefined || events.length < batchSize
+                ? Option.none()
+                : Option.some({ afterPosition: last.position, afterVersion: last.version })
+        ];
+    })));
+    const subscribe = (filter = {}) => Stream.unwrap(Effect.gen(function* () {
+        const cursor = yield* Ref.make({ position: filter.afterPosition ?? 0, version: filter.afterVersion ?? 0 });
+        return SubscriptionRef.changes(latest).pipe(Stream.filterEffect((position) => Effect.map(Ref.get(cursor), (seen) => position > seen.position)), Stream.flatMap((position) => Stream.unwrap(Effect.map(Ref.get(cursor), (seen) => read({ ...filter, afterPosition: seen.position, afterVersion: seen.version }))).pipe(Stream.tap((event) => Ref.set(cursor, { position: event.position, version: event.version })), 
+        // Events the filter skipped must not trigger another read.
+        Stream.ensuring(Ref.update(cursor, (seen) => seen.position >= position ? seen : { ...seen, position })))));
+    }));
+    return EventStore.of({
+        append,
+        read,
+        subscribe,
+        head: backend.head,
+        changes: SubscriptionRef.changes(latest)
+    });
+});
+const matches = (filter, event) => (filter.aggregateNames?.includes(event.aggregateName) ?? true) &&
+    (filter.aggregateIds?.includes(event.aggregateId) ?? true) &&
+    (filter.eventTypes?.includes(event.type) ?? true) &&
+    (filter.startTime === undefined || !DateTime.isLessThan(event.timestamp, filter.startTime)) &&
+    (filter.finishTime === undefined || DateTime.isLessThan(event.timestamp, filter.finishTime));
+/** The index of the first event past `position`, in events sorted by position. */
+const firstAfter = (events, position) => {
+    let low = 0;
+    let high = events.length;
+    while (low < high) {
+        const middle = (low + high) >>> 1;
+        if (events[middle].position <= position)
+            low = middle + 1;
+        else
+            high = middle;
+    }
+    return low;
+};
+const streamKey = (aggregateName, aggregateId) => JSON.stringify([aggregateName, aggregateId]);
+export const makeMemory = Effect.gen(function* () {
+    const events = [];
+    const streams = new Map();
+    // Every command reads one stream, which shouldn't cost a walk through the whole log.
+    const candidates = (filter) => isOneStream(filter)
+        ? streams.get(streamKey(filter.aggregateNames[0], filter.aggregateIds[0])) ?? []
+        : events;
+    return yield* make({
+        append: Effect.fnUntraced(function* (input) {
+            const timestamp = yield* DateTime.now;
+            const key = streamKey(input.aggregateName, input.aggregateId);
+            const stream = streams.get(key) ?? [];
+            const version = stream.length;
+            if (version !== input.expectedVersion) {
+                return yield* new ConcurrencyConflict({
+                    aggregateName: input.aggregateName,
+                    aggregateId: input.aggregateId,
+                    expectedVersion: input.expectedVersion
+                });
+            }
+            const stored = input.events.map((event, index) => toStored(input, event, index, events.length + index + 1, timestamp));
+            for (const event of stored) {
+                events.push(event);
+                stream.push(event);
+            }
+            streams.set(key, stream);
+            return stored;
+        }),
+        readBatch: (filter, afterPosition, limit) => Effect.sync(() => {
+            const source = candidates(filter);
+            const batch = [];
+            for (let index = firstAfter(source, afterPosition); index < source.length && batch.length < limit; index++) {
+                const event = source[index];
+                if (matches(filter, event))
+                    batch.push(event);
+            }
+            return batch;
+        }),
+        head: Effect.sync(() => events.length)
+    });
+});
+/** Keeps events in process memory. They do not survive a restart. */
+export const layerMemory = Layer.effect(EventStore, makeMemory);
+//# sourceMappingURL=EventStore.js.map

package/dist/EventStore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EventStore.js","sourceRoot":"","sources":["../src/EventStore.ts"],"names":[],"mappings":"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"}

package/dist/EventVersions.d.ts

@@ -0,0 +1,64 @@
+/**
+ * The older shapes of one event, so that events stored long ago still reach
+ * projections and view models in today's shape. The log is never rewritten:
+ * old payloads are upcast as they are read.
+ *
+ * ```ts
+ * const AccountOpenedV1 = Schema.Struct({ owner: Schema.String })
+ *
+ * const Account = Aggregate.make<State>()({
+ *   name: "account",
+ *   events: AccountEvent,
+ *   initial,
+ *   projection,
+ *   versions: {
+ *     AccountOpened: EventVersions.from(AccountOpenedV1).next(
+ *       AccountEvent.cases.AccountOpened,
+ *       ({ owner }) => ({ owner, currency: "CHF" })
+ *     )
+ *   }
+ * })
+ * ```
+ *
+ * The first schema is version 1, the shape events had before the history was
+ * declared, and every `next` adds a version. The last one must be the event's
+ * current schema, which is what new events are written with.
+ */
+import { Schema } from "effect";
+/** A schema that decodes and encodes without services, as stored payloads need. */
+export type VersionSchema = Schema.Top & {
+    readonly DecodingServices: never;
+    readonly EncodingServices: never;
+};
+/** What an upcast returns: the next version, without the `_tag` the event's name already gives. */
+export type Untagged<T> = T extends {
+    readonly _tag: string;
+} ? Omit<T, "_tag"> : T;
+export interface EventVersions<Schemas extends ReadonlyArray<VersionSchema>, Latest> {
+    /** Oldest first: `schemas[0]` is version 1. */
+    readonly schemas: Schemas;
+    /** `upcasts[i]` turns version `i + 1` into version `i + 2`. */
+    readonly upcasts: ReadonlyArray<(previous: any) => unknown>;
+    /** The type of the last version, which an aggregate checks against its event. */
+    readonly "~latest"?: Latest;
+    /** Adds a version, with the function that turns the previous one into it. */
+    next<Next extends VersionSchema>(schema: Next, upcast: (previous: Latest) => Untagged<Next["Type"]>): EventVersions<readonly [...Schemas, Next], Next["Type"]>;
+}
+/** Any history whose last version is `Latest`. */
+export type Any<Latest = any> = EventVersions<ReadonlyArray<VersionSchema>, Latest>;
+/** The schema of one version, or `never` when the history has no such version. */
+export type SchemaAt<H extends Any, V extends number> = H extends EventVersions<infer Schemas, any> ? [never, ...Schemas][V] extends infer S extends VersionSchema ? S : never : never;
+/** Starts a history at version 1. */
+export declare const from: <V1 extends VersionSchema>(schema: V1) => EventVersions<readonly [V1], V1["Type"]>;
+/** The version new events of this kind are written with. */
+export declare const current: (versions: Any | undefined) => number;
+/**
+ * Builds one decoder per old version, each going all the way to the current one.
+ * The chains are composed once with `Schema.decodeTo`, so reading an old event
+ * costs one decode however many versions it is behind.
+ *
+ * `decoders[v - 1]` decodes a JSON payload stored at version `v`. The current
+ * version has none, as the aggregate's own schema reads it.
+ */
+export declare const decoders: (tag: string, versions: Any) => ReadonlyArray<Schema.Decoder<unknown>>;
+//# sourceMappingURL=EventVersions.d.ts.map

package/dist/EventVersions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EventVersions.d.ts","sourceRoot":"","sources":["../src/EventVersions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,OAAO,EAAE,MAAM,EAAgB,MAAM,QAAQ,CAAA;AAE7C,mFAAmF;AACnF,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,GAAG,GAAG;IACvC,QAAQ,CAAC,gBAAgB,EAAE,KAAK,CAAA;IAChC,QAAQ,CAAC,gBAAgB,EAAE,KAAK,CAAA;CACjC,CAAA;AAED,mGAAmG;AACnG,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI,CAAC,SAAS;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAAC,CAAC,EAAE,MAAM,CAAC,GAAG,CAAC,CAAA;AAMnF,MAAM,WAAW,aAAa,CAAC,OAAO,SAAS,aAAa,CAAC,aAAa,CAAC,EAAE,MAAM;IACjF,+CAA+C;IAC/C,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,+DAA+D;IAC/D,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,CAAC,QAAQ,EAAE,GAAG,KAAK,OAAO,CAAC,CAAA;IAC3D,iFAAiF;IACjF,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAA;IAC3B,6EAA6E;IAC7E,IAAI,CAAC,IAAI,SAAS,aAAa,EAC7B,MAAM,EAAE,IAAI,EACZ,MAAM,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,GACnD,aAAa,CAAC,SAAS,CAAC,GAAG,OAAO,EAAE,IAAI,CAAC,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,CAAA;CAC5D;AAED,kDAAkD;AAClD,MAAM,MAAM,GAAG,CAAC,MAAM,GAAG,GAAG,IAAI,aAAa,CAAC,aAAa,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC,CAAA;AAEnF,kFAAkF;AAClF,MAAM,MAAM,QAAQ,CAAC,CAAC,SAAS,GAAG,EAAE,CAAC,SAAS,MAAM,IAAI,CAAC,SAAS,aAAa,CAAC,MAAM,OAAO,EAAE,GAAG,CAAC,GAC/F,CAAC,KAAK,EAAE,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC,SAAS,MAAM,CAAC,SAAS,aAAa,GAAG,CAAC,GAAG,KAAK,GACxE,KAAK,CAAA;AAWT,qCAAqC;AACrC,eAAO,MAAM,IAAI,GAAI,EAAE,SAAS,aAAa,UAAU,EAAE,KAAG,aAAa,CAAC,SAAS,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,CACrE,CAAA;AAE9B,4DAA4D;AAC5D,eAAO,MAAM,OAAO,aAAc,GAAG,GAAG,SAAS,KAAG,MAAuC,CAAA;AAE3F;;;;;;;GAOG;AACH,eAAO,MAAM,QAAQ,QAAS,MAAM,YAAY,GAAG,KAAG,aAAa,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,CAgBxF,CAAA"}

package/dist/EventVersions.js

@@ -0,0 +1,55 @@
+/**
+ * The older shapes of one event, so that events stored long ago still reach
+ * projections and view models in today's shape. The log is never rewritten:
+ * old payloads are upcast as they are read.
+ *
+ * ```ts
+ * const AccountOpenedV1 = Schema.Struct({ owner: Schema.String })
+ *
+ * const Account = Aggregate.make<State>()({
+ *   name: "account",
+ *   events: AccountEvent,
+ *   initial,
+ *   projection,
+ *   versions: {
+ *     AccountOpened: EventVersions.from(AccountOpenedV1).next(
+ *       AccountEvent.cases.AccountOpened,
+ *       ({ owner }) => ({ owner, currency: "CHF" })
+ *     )
+ *   }
+ * })
+ * ```
+ *
+ * The first schema is version 1, the shape events had before the history was
+ * declared, and every `next` adds a version. The last one must be the event's
+ * current schema, which is what new events are written with.
+ */
+import { Schema, SchemaGetter } from "effect";
+const build = (schemas, upcasts) => ({
+    schemas,
+    upcasts,
+    next: (schema, upcast) => build([...schemas, schema], [...upcasts, upcast])
+});
+/** Starts a history at version 1. */
+export const from = (schema) => build([schema], []);
+/** The version new events of this kind are written with. */
+export const current = (versions) => versions?.schemas.length ?? 1;
+/**
+ * Builds one decoder per old version, each going all the way to the current one.
+ * The chains are composed once with `Schema.decodeTo`, so reading an old event
+ * costs one decode however many versions it is behind.
+ *
+ * `decoders[v - 1]` decodes a JSON payload stored at version `v`. The current
+ * version has none, as the aggregate's own schema reads it.
+ */
+export const decoders = (tag, versions) => versions.schemas.slice(0, -1).map((schema, index) => versions.schemas.slice(index + 1).reduce((chain, next, step) => chain.pipe(Schema.decodeTo(Schema.toType(next), {
+    // Adding the tag lets the last step decode into the tagged event, and a
+    // schema in between without one drops it again.
+    decode: SchemaGetter.transform((previous) => ({
+        ...versions.upcasts[index + step](previous),
+        _tag: tag
+    })),
+    // A payload is only ever written in its current version.
+    encode: SchemaGetter.forbidden(() => `${tag} can only be written in its current version`)
+})), Schema.toCodecJson(schema)));
+//# sourceMappingURL=EventVersions.js.map

package/dist/EventVersions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EventVersions.js","sourceRoot":"","sources":["../src/EventVersions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAA;AAqC7C,MAAM,KAAK,GAAG,CACZ,OAAgB,EAChB,OAAkD,EACH,EAAE,CAAC,CAAC;IACnD,OAAO;IACP,OAAO;IACP,IAAI,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC,KAAK,CAAC,CAAC,GAAG,OAAO,EAAE,MAAM,CAAU,EAAE,CAAC,GAAG,OAAO,EAAE,MAAM,CAAC,CAAQ;CAC5F,CAAC,CAAA;AAEF,qCAAqC;AACrC,MAAM,CAAC,MAAM,IAAI,GAAG,CAA2B,MAAU,EAA4C,EAAE,CACrG,KAAK,CAAC,CAAC,MAAM,CAAU,EAAE,EAAE,CAAC,CAAA;AAE9B,4DAA4D;AAC5D,MAAM,CAAC,MAAM,OAAO,GAAG,CAAC,QAAyB,EAAU,EAAE,CAAC,QAAQ,EAAE,OAAO,CAAC,MAAM,IAAI,CAAC,CAAA;AAE3F;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,CAAC,GAAW,EAAE,QAAa,EAA0C,EAAE,CAC7F,QAAQ,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,CAClD,QAAQ,CAAC,OAAO,CAAC,KAAK,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,MAAM,CACtC,CAAC,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE,CACpB,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE;IAC9C,wEAAwE;IACxE,gDAAgD;IAChD,MAAM,EAAE,YAAY,CAAC,SAAS,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC;QAC5C,GAAI,QAAQ,CAAC,OAAO,CAAC,KAAK,GAAG,IAAI,CAAE,CAAC,QAAQ,CAAY;QACxD,IAAI,EAAE,GAAG;KACV,CAAC,CAAC;IACH,yDAAyD;IACzD,MAAM,EAAE,YAAY,CAAC,SAAS,CAAC,GAAG,EAAE,CAAC,GAAG,GAAG,6CAA6C,CAAC;CAC1F,CAAC,CAAC,EACL,MAAM,CAAC,WAAW,CAAC,MAAM,CAAC,CACA,CAC7B,CAAA"}

package/dist/Fixture.d.ts

@@ -0,0 +1,106 @@
+/**
+ * Tests an aggregate in isolation: given these events, when this command runs,
+ * what happens? The moleculer-cqrs `CQRSFixture`, as a chain that runs when it
+ * is yielded:
+ *
+ * ```ts
+ * yield* Fixture.make(Todo)
+ *   .givenEvents([created])
+ *   .when("deleteTodo", { message: "Done" })
+ *   .expectEvent("TodoDeleted")
+ *   .inspectState((state) => assert.strictEqual(state.status, "deleted"))
+ * ```
+ *
+ * Commands run through the real {@link AggregateService} on an in-memory store,
+ * so payload validation and event encoding are exercised too.
+ *
+ * The history can include events stored in older versions of their schema, made
+ * with `Aggregate.historical`, which then go through the same upcasting as events
+ * read from a real store.
+ */
+import { Arbitrary, Effect, Schema } from "effect";
+import * as Aggregate from "./Aggregate.ts";
+import * as AggregateService from "./AggregateService.ts";
+declare const ExpectationFailed_base: Schema.Class<ExpectationFailed, Schema.TaggedStruct<"ExpectationFailed", {
+    readonly message: Schema.String;
+    readonly expected: Schema.Unknown;
+    readonly actual: Schema.Unknown;
+}>, import("effect/Cause").YieldableError>;
+/** Raised as a defect, so a command's error channel only holds what the command can do. */
+export declare class ExpectationFailed extends ExpectationFailed_base {
+}
+export interface Outcome<A extends Aggregate.Any> {
+    readonly events: ReadonlyArray<Aggregate.Event<A>>;
+    readonly state: Aggregate.State<A>;
+    readonly version: number;
+    /** Continues from here, with this outcome's events as the new history. */
+    readonly fixture: Fixture<A>;
+}
+/** An event to compare with, or only its tag when the rest doesn't matter. */
+export type ExpectedEvent<A extends Aggregate.Any> = Aggregate.Event<A> | Aggregate.Event<A>["_tag"];
+/** An event in today's shape, or one stored in an older version of its schema. */
+export type GivenEvent<A extends Aggregate.Any> = Aggregate.Event<A> | Aggregate.Historical;
+/** One generated step of {@link Fixture.checkInvariants}. */
+export type Step<A extends Aggregate.Any> = {
+    readonly [K in Aggregate.CommandName<A>]: {
+        readonly command: K;
+        readonly payload: Aggregate.Payload<A, K>;
+    };
+}[Aggregate.CommandName<A>];
+export interface InvariantOptions<A extends Aggregate.Any> {
+    /** Must hold for the given state and after every command that succeeds. */
+    readonly invariant: (state: Aggregate.State<A>) => boolean;
+    /**
+     * How to generate each command's payload. By default it comes from the payload
+     * schema. `false` leaves a command out.
+     */
+    readonly commands?: {
+        readonly [K in Aggregate.CommandName<A>]?: Arbitrary.Arbitrary<Aggregate.Payload<A, K>> | false;
+    } | undefined;
+    /** The longest sequence of commands to try. Defaults to 20. */
+    readonly maxCommands?: number | undefined;
+    /** Passed on to `Arbitrary.checkEffect`, for the number of runs or a seed. */
+    readonly check?: Arbitrary.CheckOptions | undefined;
+}
+/**
+ * The steps so far. Nothing runs until it is yielded or run as an Effect, which
+ * produces the {@link Outcome} of the last command.
+ */
+export interface Scenario<A extends Aggregate.Any, E, R> extends Effect.Effect<Outcome<A>, E, R> {
+    /** Runs another command on top of the previous one. */
+    when<K extends Aggregate.CommandName<A>>(command: K, payload: Aggregate.Payload<A, K>): Scenario<A, E | Aggregate.CommandError<A, K> | AggregateService.CommandFailure, R | Aggregate.Context<A>>;
+    /** Runs a command that is expected to fail and returns the error. Dies if it succeeds. */
+    whenFails<K extends Aggregate.CommandName<A>>(command: K, payload: Aggregate.Payload<A, K>): Effect.Effect<Aggregate.CommandError<A, K> | AggregateService.CommandFailure, E, R | Aggregate.Context<A>>;
+    /** Expects the last command to have emitted exactly this event. */
+    expectEvent(event: ExpectedEvent<A>): Scenario<A, E, R>;
+    /** Expects the last command to have emitted exactly these events, in order. */
+    expectEvents(events: ReadonlyArray<ExpectedEvent<A>>): Scenario<A, E, R>;
+    /** Passes the current state to a callback, which throws to fail the test. */
+    inspectState(check: (state: Aggregate.State<A>) => void): Scenario<A, E, R>;
+}
+export interface Fixture<A extends Aggregate.Any> {
+    /** Replaces the history the next command runs against. */
+    given(events: ReadonlyArray<GivenEvent<A>>): Fixture<A>;
+    /** Like `given`, starting from an empty history by default and optionally switching aggregate id. */
+    givenEvents(events?: ReadonlyArray<GivenEvent<A>>, aggregateId?: string): Fixture<A>;
+    /** The state after the given events, without running a command. */
+    readonly state: Effect.Effect<Aggregate.State<A>, AggregateService.ReadError, Aggregate.Context<A>>;
+    /** Passes the state after the given events to a callback, which throws to fail the test. */
+    inspectState(check: (state: Aggregate.State<A>) => void): Scenario<A, AggregateService.ReadError, Aggregate.Context<A>>;
+    when<K extends Aggregate.CommandName<A>>(command: K, payload: Aggregate.Payload<A, K>): Scenario<A, Aggregate.CommandError<A, K> | AggregateService.CommandFailure, Aggregate.Context<A>>;
+    /** Runs a command that is expected to fail and returns the error. Dies if it succeeds. */
+    whenFails<K extends Aggregate.CommandName<A>>(command: K, payload: Aggregate.Payload<A, K>): Effect.Effect<Aggregate.CommandError<A, K> | AggregateService.CommandFailure, never, Aggregate.Context<A>>;
+    /**
+     * Runs random sequences of commands from the given history and checks that the
+     * invariant holds after each one that succeeds. Commands that fail are part of
+     * the game and are skipped. A violation dies with {@link ExpectationFailed},
+     * holding the shortest sequence found that breaks it.
+     */
+    checkInvariants(options: InvariantOptions<A>): Effect.Effect<void, never, Aggregate.Context<A>>;
+}
+export declare const make: <A extends Aggregate.Any>(aggregate: A, options?: {
+    readonly aggregateId?: string;
+    readonly events?: ReadonlyArray<GivenEvent<A>>;
+}) => Fixture<A>;
+export {};
+//# sourceMappingURL=Fixture.d.ts.map