@ddd-ts-kit/kernel 0.9.0 → 0.10.0

package/dist/application/event-sourcing/stored-event-data.js

@@ -0,0 +1,82 @@
+import { isStoredData } from './is-stored-data.js';
+import { isStoredList } from './is-stored-list.js';
+import { UnreadableEventError } from './unreadable-event-error.js';
+/**
+ * The data of a stored event as `decode` reads it. Each read names the field and the type it
+ * expects, and refuses a field that is absent or of another type with an UnreadableEventError:
+ * a corrupt row or a forgotten upcaster stops the load instead of building a wrong aggregate.
+ */
+export class StoredEventData {
+    data;
+    where;
+    constructor(data, where) {
+        this.data = data;
+        this.where = where;
+    }
+    text(field) {
+        const value = this.data[field];
+        if (typeof value !== 'string') {
+            throw this.unreadable(field, 'a text');
+        }
+        return value;
+    }
+    optionalText(field) {
+        return this.data[field] === undefined || this.data[field] === null ? undefined : this.text(field);
+    }
+    number(field) {
+        const value = this.data[field];
+        if (typeof value !== 'number') {
+            throw this.unreadable(field, 'a number');
+        }
+        return value;
+    }
+    flag(field) {
+        const value = this.data[field];
+        if (typeof value !== 'boolean') {
+            throw this.unreadable(field, 'a boolean');
+        }
+        return value;
+    }
+    /** A date, kept as its ISO text. */
+    instant(field) {
+        const date = new Date(this.text(field));
+        if (Number.isNaN(date.getTime())) {
+            throw this.unreadable(field, 'an instant');
+        }
+        return date;
+    }
+    optionalInstant(field) {
+        return this.optionalText(field) === undefined ? undefined : this.instant(field);
+    }
+    texts(field) {
+        return this.list(field).map((item, index) => {
+            if (typeof item !== 'string') {
+                throw this.unreadable(`${field}[${index}]`, 'a text');
+            }
+            return item;
+        });
+    }
+    record(field) {
+        return this.nested(this.data[field], field);
+    }
+    records(field) {
+        return this.list(field).map((item, index) => this.nested(item, `${field}[${index}]`));
+    }
+    list(field) {
+        const value = this.data[field];
+        if (!isStoredList(value)) {
+            throw this.unreadable(field, 'a list');
+        }
+        return value;
+    }
+    nested(value, field) {
+        if (!isStoredData(value)) {
+            throw this.unreadable(field, 'an object');
+        }
+        return new StoredEventData(value, `${this.where}, ${field}`);
+    }
+    unreadable(field, expected) {
+        return new UnreadableEventError(`${this.where}: "${field}" is not ${expected}`);
+    }
+}
+//# sourceMappingURL=stored-event-data.js.map

package/dist/application/event-sourcing/stored-event-data.js.map

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

package/dist/application/event-sourcing/stored-event-spec.d.ts

@@ -0,0 +1,20 @@
+import type { DomainEvent } from '../../domain/domain-event.js';
+import type { EventEnvelope } from './event-envelope.js';
+import type { StoredEventData } from './stored-event-data.js';
+import type { Upcaster } from './upcaster.js';
+/**
+ * How one domain event is kept in a stream. `encode` answers the data of the current `version`
+ * under a named type (`NoShowNotedData`): that type is the stored shape, and a stored shape never
+ * changes. A change of shape is a new version, with the upcaster from the previous one:
+ * `upcasters: { 1: (data) => ({ ...data, reason: '' }) }` reads a version 1 as a version 2.
+ */
+export interface StoredEventSpec<E extends DomainEvent, Data extends object> {
+    /** The version of the shape `encode` writes, from 1. */
+    readonly version: number;
+    encode(event: E): Data;
+    /** Builds the event back from data of the current version: older data is upcast first. */
+    decode(data: StoredEventData, envelope: EventEnvelope): E;
+    /** By the version each one reads: one upcaster from every version below `version`. */
+    readonly upcasters?: Readonly<Record<number, Upcaster>>;
+}
+//# sourceMappingURL=stored-event-spec.d.ts.map

package/dist/application/event-sourcing/stored-event-spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stored-event-spec.d.ts","sourceRoot":"","sources":["../../../src/application/event-sourcing/stored-event-spec.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAChE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAE9C;;;;;GAKG;AACH,MAAM,WAAW,eAAe,CAAC,CAAC,SAAS,WAAW,EAAE,IAAI,SAAS,MAAM;IACzE,wDAAwD;IACxD,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,MAAM,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC;IACvB,0FAA0F;IAC1F,MAAM,CAAC,IAAI,EAAE,eAAe,EAAE,QAAQ,EAAE,aAAa,GAAG,CAAC,CAAC;IAC1D,sFAAsF;IACtF,QAAQ,CAAC,SAAS,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC;CACzD"}

package/dist/application/event-sourcing/stored-event-spec.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=stored-event-spec.js.map

package/dist/application/event-sourcing/stored-event-spec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stored-event-spec.js","sourceRoot":"","sources":["../../../src/application/event-sourcing/stored-event-spec.ts"],"names":[],"mappings":""}

package/dist/application/event-sourcing/stored-event-type.d.ts

@@ -0,0 +1,14 @@
+import type { DomainEvent } from '../../domain/domain-event.js';
+import type { EventEnvelope } from './event-envelope.js';
+import type { StoredData } from './stored-data.js';
+import type { StoredEventData } from './stored-event-data.js';
+import type { Upcaster } from './upcaster.js';
+/** One stored event as `defineStoredEvent` declared it, ready for the serializer. */
+export interface StoredEventType<E extends DomainEvent> {
+    readonly version: number;
+    readonly upcasters: Readonly<Record<number, Upcaster>>;
+    /** Refuses an event of another class than the declared one. */
+    encode(event: DomainEvent): StoredData;
+    decode(data: StoredEventData, envelope: EventEnvelope): E;
+}
+//# sourceMappingURL=stored-event-type.d.ts.map

package/dist/application/event-sourcing/stored-event-type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stored-event-type.d.ts","sourceRoot":"","sources":["../../../src/application/event-sourcing/stored-event-type.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAChE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAE9C,qFAAqF;AACrF,MAAM,WAAW,eAAe,CAAC,CAAC,SAAS,WAAW;IACpD,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,SAAS,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC;IACvD,+DAA+D;IAC/D,MAAM,CAAC,KAAK,EAAE,WAAW,GAAG,UAAU,CAAC;IACvC,MAAM,CAAC,IAAI,EAAE,eAAe,EAAE,QAAQ,EAAE,aAAa,GAAG,CAAC,CAAC;CAC3D"}

package/dist/application/event-sourcing/stored-event-type.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=stored-event-type.js.map

package/dist/application/event-sourcing/stored-event-type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stored-event-type.js","sourceRoot":"","sources":["../../../src/application/event-sourcing/stored-event-type.ts"],"names":[],"mappings":""}

package/dist/application/event-sourcing/stored-event-types.d.ts

@@ -0,0 +1,9 @@
+import type { DomainEvent } from '../../domain/domain-event.js';
+import type { StoredEventType } from './stored-event-type.js';
+/** The stored events of one aggregate, by the name each carries: every event of the union is declared. */
+export type StoredEventTypes<E extends DomainEvent> = {
+    readonly [Name in E['name']]: StoredEventType<Extract<E, {
+        readonly name: Name;
+    }>>;
+};
+//# sourceMappingURL=stored-event-types.d.ts.map

package/dist/application/event-sourcing/stored-event-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stored-event-types.d.ts","sourceRoot":"","sources":["../../../src/application/event-sourcing/stored-event-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAChE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAE9D,0GAA0G;AAC1G,MAAM,MAAM,gBAAgB,CAAC,CAAC,SAAS,WAAW,IAAI;IACpD,QAAQ,EAAE,IAAI,IAAI,CAAC,CAAC,MAAM,CAAC,GAAG,eAAe,CAAC,OAAO,CAAC,CAAC,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAA;KAAE,CAAC,CAAC;CACnF,CAAC"}

package/dist/application/event-sourcing/stored-event-types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=stored-event-types.js.map

package/dist/application/event-sourcing/stored-event-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stored-event-types.js","sourceRoot":"","sources":["../../../src/application/event-sourcing/stored-event-types.ts"],"names":[],"mappings":""}

package/dist/application/event-sourcing/stored-event.d.ts

@@ -0,0 +1,12 @@
+import type { EventToAppend } from './event-to-append.js';
+import type { StoredData } from './stored-data.js';
+/** An event as the store gives it back, placed in its stream and in the whole store. */
+export interface StoredEvent extends EventToAppend {
+    readonly stream: string;
+    /** Its rank in its stream, from 1: the stream reads in this order. */
+    readonly version: number;
+    /** Its rank in the store, from 1, in the order the appends committed: what a subscription remembers. */
+    readonly position: number;
+    readonly metadata: StoredData;
+}
+//# sourceMappingURL=stored-event.d.ts.map

package/dist/application/event-sourcing/stored-event.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stored-event.d.ts","sourceRoot":"","sources":["../../../src/application/event-sourcing/stored-event.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEnD,wFAAwF;AACxF,MAAM,WAAW,WAAY,SAAQ,aAAa;IAChD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,sEAAsE;IACtE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,wGAAwG;IACxG,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,QAAQ,EAAE,UAAU,CAAC;CAC/B"}

package/dist/application/event-sourcing/stored-event.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=stored-event.js.map

package/dist/application/event-sourcing/stored-event.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stored-event.js","sourceRoot":"","sources":["../../../src/application/event-sourcing/stored-event.ts"],"names":[],"mappings":""}

package/dist/application/event-sourcing/stored-json.d.ts

@@ -0,0 +1,5 @@
+/** A value an event store keeps as it is: plain JSON. */
+export type StoredJson = string | number | boolean | null | readonly StoredJson[] | {
+    readonly [key: string]: StoredJson;
+};
+//# sourceMappingURL=stored-json.d.ts.map

package/dist/application/event-sourcing/stored-json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stored-json.d.ts","sourceRoot":"","sources":["../../../src/application/event-sourcing/stored-json.ts"],"names":[],"mappings":"AAAA,yDAAyD;AACzD,MAAM,MAAM,UAAU,GAClB,MAAM,GACN,MAAM,GACN,OAAO,GACP,IAAI,GACJ,SAAS,UAAU,EAAE,GACrB;IAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,GAAG,UAAU,CAAA;CAAE,CAAC"}

package/dist/application/event-sourcing/stored-json.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=stored-json.js.map

package/dist/application/event-sourcing/stored-json.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stored-json.js","sourceRoot":"","sources":["../../../src/application/event-sourcing/stored-json.ts"],"names":[],"mappings":""}

package/dist/application/event-sourcing/stored-snapshot.d.ts

@@ -0,0 +1,11 @@
+import type { StoredData } from './stored-data.js';
+/** The state of a stream at a version, kept to shorten its replay. A snapshot can always be thrown away. */
+export interface StoredSnapshot {
+    readonly stream: string;
+    /** The number of events of the stream the state reflects. */
+    readonly version: number;
+    /** The version of the shape of `data`: a snapshot of another shape is ignored and the stream replayed. */
+    readonly schemaVersion: number;
+    readonly data: StoredData;
+}
+//# sourceMappingURL=stored-snapshot.d.ts.map

package/dist/application/event-sourcing/stored-snapshot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stored-snapshot.d.ts","sourceRoot":"","sources":["../../../src/application/event-sourcing/stored-snapshot.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEnD,4GAA4G;AAC5G,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,6DAA6D;IAC7D,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,0GAA0G;IAC1G,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;CAC3B"}

package/dist/application/event-sourcing/stored-snapshot.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=stored-snapshot.js.map

package/dist/application/event-sourcing/stored-snapshot.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stored-snapshot.js","sourceRoot":"","sources":["../../../src/application/event-sourcing/stored-snapshot.ts"],"names":[],"mappings":""}

package/dist/application/event-sourcing/subject-key.d.ts

@@ -0,0 +1,10 @@
+/** The key the personal data of one data subject is sealed with. Destroying it erases that data everywhere it was sealed. */
+export interface SubjectKey {
+    /** Written next to every value sealed with it, so a later key of the same subject never opens an older value. */
+    readonly id: string;
+    /** The data subject: whose personal data the key seals. */
+    readonly subject: string;
+    /** 32 bytes, base64. */
+    readonly material: string;
+}
+//# sourceMappingURL=subject-key.d.ts.map

package/dist/application/event-sourcing/subject-key.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subject-key.d.ts","sourceRoot":"","sources":["../../../src/application/event-sourcing/subject-key.ts"],"names":[],"mappings":"AAAA,6HAA6H;AAC7H,MAAM,WAAW,UAAU;IACzB,iHAAiH;IACjH,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,2DAA2D;IAC3D,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,wBAAwB;IACxB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B"}

package/dist/application/event-sourcing/subject-key.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=subject-key.js.map

package/dist/application/event-sourcing/subject-key.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"subject-key.js","sourceRoot":"","sources":["../../../src/application/event-sourcing/subject-key.ts"],"names":[],"mappings":""}

package/dist/application/event-sourcing/unreadable-event-error.d.ts

@@ -0,0 +1,5 @@
+/** A stored event, or a snapshot, that cannot be read as its declaration says: a field missing or of another type, a version without upcaster. */
+export declare class UnreadableEventError extends Error {
+    constructor(message: string);
+}
+//# sourceMappingURL=unreadable-event-error.d.ts.map

package/dist/application/event-sourcing/unreadable-event-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unreadable-event-error.d.ts","sourceRoot":"","sources":["../../../src/application/event-sourcing/unreadable-event-error.ts"],"names":[],"mappings":"AAAA,kJAAkJ;AAClJ,qBAAa,oBAAqB,SAAQ,KAAK;IAC7C,YAAY,OAAO,EAAE,MAAM,EAG1B;CACF"}

package/dist/application/event-sourcing/unreadable-event-error.js

@@ -0,0 +1,8 @@
+/** A stored event, or a snapshot, that cannot be read as its declaration says: a field missing or of another type, a version without upcaster. */
+export class UnreadableEventError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'UnreadableEventError';
+    }
+}
+//# sourceMappingURL=unreadable-event-error.js.map

package/dist/application/event-sourcing/unreadable-event-error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unreadable-event-error.js","sourceRoot":"","sources":["../../../src/application/event-sourcing/unreadable-event-error.ts"],"names":[],"mappings":"AAAA,kJAAkJ;AAClJ,MAAM,OAAO,oBAAqB,SAAQ,KAAK;IAC7C,YAAY,OAAe;QACzB,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,IAAI,CAAC,IAAI,GAAG,sBAAsB,CAAC;IACrC,CAAC;CACF"}

package/dist/application/event-sourcing/upcaster.d.ts

@@ -0,0 +1,4 @@
+import type { StoredData } from './stored-data.js';
+/** Turns the data of a stored event from one version of its shape into the next one. Pure: the stored event is never rewritten. */
+export type Upcaster = (data: StoredData) => StoredData;
+//# sourceMappingURL=upcaster.d.ts.map

package/dist/application/event-sourcing/upcaster.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"upcaster.d.ts","sourceRoot":"","sources":["../../../src/application/event-sourcing/upcaster.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEnD,mIAAmI;AACnI,MAAM,MAAM,QAAQ,GAAG,CAAC,IAAI,EAAE,UAAU,KAAK,UAAU,CAAC"}

package/dist/application/event-sourcing/upcaster.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=upcaster.js.map

package/dist/application/event-sourcing/upcaster.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"upcaster.js","sourceRoot":"","sources":["../../../src/application/event-sourcing/upcaster.ts"],"names":[],"mappings":""}

package/dist/application/persistence/append-changes.d.ts

@@ -0,0 +1,18 @@
+import type { DomainEvent } from '../../domain/domain-event.js';
+import type { EventSourcedAggregate } from '../../domain/event-sourcing/event-sourced-aggregate.js';
+export interface StreamChanges {
+    /** The version the stream must still have. */
+    readonly expected: number;
+    /** What the aggregate recorded since it was loaded, in order. */
+    readonly events: readonly DomainEvent[];
+}
+/**
+ * Optimistic concurrency for an event-sourced aggregate: hands what it recorded since it was
+ * loaded to `append`, with the version its stream must still have. Once `append` resolves, the
+ * aggregate is at the new version with nothing left to store, and can be saved again; when it
+ * rejects (a ConcurrencyError: somebody else appended first), the aggregate is left as it was.
+ * An aggregate that recorded nothing still hands its version over, with no event: the store
+ * refuses it when the stream moved meanwhile, so a stale copy is never taken for a current one.
+ */
+export declare function appendChanges<E extends DomainEvent, S>(aggregate: EventSourcedAggregate<E, S>, append: (changes: StreamChanges) => Promise<void>): Promise<void>;
+//# sourceMappingURL=append-changes.d.ts.map

package/dist/application/persistence/append-changes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"append-changes.d.ts","sourceRoot":"","sources":["../../../src/application/persistence/append-changes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAChE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,wDAAwD,CAAC;AAGpG,MAAM,WAAW,aAAa;IAC5B,8CAA8C;IAC9C,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,iEAAiE;IACjE,QAAQ,CAAC,MAAM,EAAE,SAAS,WAAW,EAAE,CAAC;CACzC;AAED;;;;;;;GAOG;AACH,wBAAsB,aAAa,CAAC,CAAC,SAAS,WAAW,EAAE,CAAC,EAC1D,SAAS,EAAE,qBAAqB,CAAC,CAAC,EAAE,CAAC,CAAC,EACtC,MAAM,EAAE,CAAC,OAAO,EAAE,aAAa,KAAK,OAAO,CAAC,IAAI,CAAC,GAChD,OAAO,CAAC,IAAI,CAAC,CAOf"}

package/dist/application/persistence/append-changes.js

@@ -0,0 +1,17 @@
+import { unstoredEvents } from '../../domain/event-sourcing/unstored-events.js';
+/**
+ * Optimistic concurrency for an event-sourced aggregate: hands what it recorded since it was
+ * loaded to `append`, with the version its stream must still have. Once `append` resolves, the
+ * aggregate is at the new version with nothing left to store, and can be saved again; when it
+ * rejects (a ConcurrencyError: somebody else appended first), the aggregate is left as it was.
+ * An aggregate that recorded nothing still hands its version over, with no event: the store
+ * refuses it when the stream moved meanwhile, so a stale copy is never taken for a current one.
+ */
+export async function appendChanges(aggregate, append) {
+    const unstored = unstoredEvents.get(aggregate) ?? [];
+    const events = [...unstored];
+    await append({ expected: aggregate.version, events });
+    unstored.splice(0, events.length);
+    aggregate.version += events.length;
+}
+//# sourceMappingURL=append-changes.js.map

package/dist/application/persistence/append-changes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"append-changes.js","sourceRoot":"","sources":["../../../src/application/persistence/append-changes.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAE,MAAM,gDAAgD,CAAC;AAShF;;;;;;;GAOG;AACH,MAAM,CAAC,KAAK,UAAU,aAAa,CACjC,SAAsC,EACtC,MAAiD;IAEjD,MAAM,QAAQ,GAAG,cAAc,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC;IACrD,MAAM,MAAM,GAAG,CAAC,GAAG,QAAQ,CAAC,CAAC;IAE7B,MAAM,MAAM,CAAC,EAAE,QAAQ,EAAE,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,CAAC,CAAC;IACtD,QAAQ,CAAC,MAAM,CAAC,CAAC,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC;IAClC,SAAS,CAAC,OAAO,IAAI,MAAM,CAAC,MAAM,CAAC;AACrC,CAAC"}

package/dist/application/ports/checkpoint-store.d.ts

@@ -0,0 +1,14 @@
+/**
+ * How far each subscription to an event store has applied the store. Kept in the database of what
+ * the subscription writes, a checkpoint commits with what it applied.
+ */
+export declare abstract class CheckpointStore {
+    /** The last position the subscriber applied, 0 when it applied nothing yet. */
+    abstract position(subscriber: string): Promise<number>;
+    /**
+     * Moves the checkpoint from `from` to `to`, and refuses with a ConcurrencyError when it is no
+     * longer at `from`: another run of the same subscriber applied the same events first.
+     */
+    abstract advance(subscriber: string, from: number, to: number): Promise<void>;
+}
+//# sourceMappingURL=checkpoint-store.d.ts.map

package/dist/application/ports/checkpoint-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkpoint-store.d.ts","sourceRoot":"","sources":["../../../src/application/ports/checkpoint-store.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,8BAAsB,eAAe;IAKnC,+EAA+E;IAC/E,QAAQ,CAAC,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAEvD;;;OAGG;IACH,QAAQ,CAAC,OAAO,CAAC,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC/E"}

package/dist/application/ports/checkpoint-store.js

@@ -0,0 +1,10 @@
+/**
+ * How far each subscription to an event store has applied the store. Kept in the database of what
+ * the subscription writes, a checkpoint commits with what it applied.
+ */
+export class CheckpointStore {
+    static {
+        Object.defineProperty(this, 'tokenKey', { value: 'kernel.CheckpointStore' });
+    }
+}
+//# sourceMappingURL=checkpoint-store.js.map

package/dist/application/ports/checkpoint-store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkpoint-store.js","sourceRoot":"","sources":["../../../src/application/ports/checkpoint-store.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,OAAgB,eAAe;IACnC;QACE,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,UAAU,EAAE,EAAE,KAAK,EAAE,wBAAwB,EAAE,CAAC,CAAC;IAC/E,CAAC;CAUF"}

package/dist/application/ports/event-store.d.ts

@@ -0,0 +1,24 @@
+import type { Appended } from '../event-sourcing/appended.js';
+import type { EventToAppend } from '../event-sourcing/event-to-append.js';
+import type { StoredEvent } from '../event-sourcing/stored-event.js';
+/**
+ * Where event-sourced aggregates keep their streams: one stream per aggregate, read in order,
+ * and the whole store read in the order the appends committed, for the subscriptions. Stored
+ * events are never changed. Only repository adapters and subscriptions use it: the domain and the
+ * use cases never read a stream.
+ */
+export declare abstract class EventStore {
+    /**
+     * Appends the events to the stream if it still has `expectedVersion` events (0: the stream does
+     * not exist yet), and refuses with a ConcurrencyError otherwise: somebody else appended since it
+     * was read. Joins the transaction of the current unit of work when the store is transactional.
+     */
+    abstract append(stream: string, expectedVersion: number, events: readonly EventToAppend[]): Promise<Appended>;
+    /** The events of the stream after version `after` (default 0: all of them), in their order. */
+    abstract readStream(stream: string, after?: number): Promise<readonly StoredEvent[]>;
+    /** Up to `limit` events of the whole store after position `after`, in the order of their positions. */
+    abstract readAll(after: number, limit: number): Promise<readonly StoredEvent[]>;
+    /** The position of the last event stored, 0 when there is none. */
+    abstract head(): Promise<number>;
+}
+//# sourceMappingURL=event-store.d.ts.map

package/dist/application/ports/event-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-store.d.ts","sourceRoot":"","sources":["../../../src/application/ports/event-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,+BAA+B,CAAC;AAC9D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AAC1E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mCAAmC,CAAC;AAErE;;;;;GAKG;AACH,8BAAsB,UAAU;IAK9B;;;;OAIG;IACH,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,aAAa,EAAE,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;IAE9G,+FAA+F;IAC/F,QAAQ,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,WAAW,EAAE,CAAC,CAAC;IAErF,uGAAuG;IACvG,QAAQ,CAAC,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,WAAW,EAAE,CAAC,CAAC;IAEhF,mEAAmE;IACnE,QAAQ,CAAC,IAAI,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;CAClC"}

package/dist/application/ports/event-store.js

@@ -0,0 +1,12 @@
+/**
+ * Where event-sourced aggregates keep their streams: one stream per aggregate, read in order,
+ * and the whole store read in the order the appends committed, for the subscriptions. Stored
+ * events are never changed. Only repository adapters and subscriptions use it: the domain and the
+ * use cases never read a stream.
+ */
+export class EventStore {
+    static {
+        Object.defineProperty(this, 'tokenKey', { value: 'kernel.EventStore' });
+    }
+}
+//# sourceMappingURL=event-store.js.map

package/dist/application/ports/event-store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-store.js","sourceRoot":"","sources":["../../../src/application/ports/event-store.ts"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH,MAAM,OAAgB,UAAU;IAC9B;QACE,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,UAAU,EAAE,EAAE,KAAK,EAAE,mBAAmB,EAAE,CAAC,CAAC;IAC1E,CAAC;CAiBF"}

package/dist/application/ports/snapshot-store.d.ts

@@ -0,0 +1,8 @@
+import type { StoredSnapshot } from '../event-sourcing/stored-snapshot.js';
+/** The last snapshot of each stream. Only the event-sourced repository uses it. */
+export declare abstract class SnapshotStore {
+    abstract find(stream: string): Promise<StoredSnapshot | undefined>;
+    /** Keeps the snapshot unless the stream already has one of a later version. */
+    abstract save(snapshot: StoredSnapshot): Promise<void>;
+}
+//# sourceMappingURL=snapshot-store.d.ts.map

package/dist/application/ports/snapshot-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot-store.d.ts","sourceRoot":"","sources":["../../../src/application/ports/snapshot-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sCAAsC,CAAC;AAE3E,mFAAmF;AACnF,8BAAsB,aAAa;IAKjC,QAAQ,CAAC,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,GAAG,SAAS,CAAC,CAAC;IAEnE,+EAA+E;IAC/E,QAAQ,CAAC,IAAI,CAAC,QAAQ,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACxD"}

package/dist/application/ports/snapshot-store.js

@@ -0,0 +1,7 @@
+/** The last snapshot of each stream. Only the event-sourced repository uses it. */
+export class SnapshotStore {
+    static {
+        Object.defineProperty(this, 'tokenKey', { value: 'kernel.SnapshotStore' });
+    }
+}
+//# sourceMappingURL=snapshot-store.js.map

package/dist/application/ports/snapshot-store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot-store.js","sourceRoot":"","sources":["../../../src/application/ports/snapshot-store.ts"],"names":[],"mappings":"AAEA,mFAAmF;AACnF,MAAM,OAAgB,aAAa;IACjC;QACE,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,UAAU,EAAE,EAAE,KAAK,EAAE,sBAAsB,EAAE,CAAC,CAAC;IAC7E,CAAC;CAMF"}

package/dist/application/ports/subject-key-store.d.ts

@@ -0,0 +1,17 @@
+import type { SubjectKey } from '../event-sourcing/subject-key.js';
+/**
+ * The keys personal data is sealed with, one per data subject (crypto-shredding). Erasing a
+ * subject destroys its key: every value sealed with it can no longer be read from the live
+ * events and snapshots, nor from a backup of them that does not hold the key. A backup that
+ * holds the events and the keys together still opens them until it expires, so keep the keys
+ * apart from the events in production, with a shorter backup retention.
+ */
+export declare abstract class SubjectKeyStore {
+    /** The current key of the subject, created when it has none, a first time or after an erasure. */
+    abstract keyFor(subject: string): Promise<SubjectKey>;
+    /** The key of this id, `undefined` once its subject was erased. */
+    abstract find(keyId: string): Promise<SubjectKey | undefined>;
+    /** Destroys the keys of the subject. Answers whether there was one. */
+    abstract erase(subject: string): Promise<boolean>;
+}
+//# sourceMappingURL=subject-key-store.d.ts.map

package/dist/application/ports/subject-key-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subject-key-store.d.ts","sourceRoot":"","sources":["../../../src/application/ports/subject-key-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kCAAkC,CAAC;AAEnE;;;;;;GAMG;AACH,8BAAsB,eAAe;IAKnC,kGAAkG;IAClG,QAAQ,CAAC,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;IAEtD,mEAAmE;IACnE,QAAQ,CAAC,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,GAAG,SAAS,CAAC,CAAC;IAE9D,uEAAuE;IACvE,QAAQ,CAAC,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CACnD"}

package/dist/application/ports/subject-key-store.js

@@ -0,0 +1,13 @@
+/**
+ * The keys personal data is sealed with, one per data subject (crypto-shredding). Erasing a
+ * subject destroys its key: every value sealed with it can no longer be read from the live
+ * events and snapshots, nor from a backup of them that does not hold the key. A backup that
+ * holds the events and the keys together still opens them until it expires, so keep the keys
+ * apart from the events in production, with a shorter backup retention.
+ */
+export class SubjectKeyStore {
+    static {
+        Object.defineProperty(this, 'tokenKey', { value: 'kernel.SubjectKeyStore' });
+    }
+}
+//# sourceMappingURL=subject-key-store.js.map

package/dist/application/ports/subject-key-store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"subject-key-store.js","sourceRoot":"","sources":["../../../src/application/ports/subject-key-store.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,MAAM,OAAgB,eAAe;IACnC;QACE,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,UAAU,EAAE,EAAE,KAAK,EAAE,wBAAwB,EAAE,CAAC,CAAC;IAC/E,CAAC;CAUF"}

package/dist/declarations/decorators/projection-options.d.ts

@@ -0,0 +1,5 @@
+import type { ProjectionFeed } from '../model/projection-feed.js';
+export interface ProjectionOptions {
+    readonly feed: ProjectionFeed;
+}
+//# sourceMappingURL=projection-options.d.ts.map

package/dist/declarations/decorators/projection-options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"projection-options.d.ts","sourceRoot":"","sources":["../../../src/declarations/decorators/projection-options.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAElE,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;CAC/B"}

package/dist/declarations/decorators/projection-options.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=projection-options.js.map

package/dist/declarations/decorators/projection-options.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"projection-options.js","sourceRoot":"","sources":["../../../src/declarations/decorators/projection-options.ts"],"names":[],"mappings":""}

package/dist/declarations/decorators/projection.d.ts

@@ -1,11 +1,15 @@
 import type { ClassDeclarator } from '../dependencies/class-declarator.js';
 import type { DeclaredDependencies } from '../dependencies/declared-dependencies.js';
 import type { DependenciesFromSignature } from '../dependencies/dependencies-from-signature.js';
+import type { ProjectionOptions } from './projection-options.js';
 /**
  * A projector: the class that keeps one read model up to date, each of its `@On` methods
  * applying one event through a port of its own read model:
  * `@Projection('scheduling.appointment-list')`. The name is the consumer
  * it is subscribed as: stable, `<context>.<name>`, unique in the application.
+ * `@Projection('scheduling.attendance-history', { feed: 'event-store' })` is fed from the event
+ * store by a catch-up subscription instead of where the domain events are dispatched.
  */
 export declare function Projection<const D extends DeclaredDependencies = DependenciesFromSignature>(name: `${string}.${string}`, dependencies?: D): ClassDeclarator<object, D>;
+export declare function Projection<const D extends DeclaredDependencies = DependenciesFromSignature>(name: `${string}.${string}`, options: ProjectionOptions, dependencies?: D): ClassDeclarator<object, D>;
 //# sourceMappingURL=projection.d.ts.map

package/dist/declarations/decorators/projection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"projection.d.ts","sourceRoot":"","sources":["../../../src/declarations/decorators/projection.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qCAAqC,CAAC;AAC3E,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,0CAA0C,CAAC;AACrF,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,gDAAgD,CAAC;AAOhG;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,KAAK,CAAC,CAAC,SAAS,oBAAoB,GAAG,yBAAyB,EACzF,IAAI,EAAE,GAAG,MAAM,IAAI,MAAM,EAAE,EAC3B,YAAY,CAAC,EAAE,CAAC,GACf,eAAe,CAAC,MAAM,EAAE,CAAC,CAAC,CAgB5B"}
+{"version":3,"file":"projection.d.ts","sourceRoot":"","sources":["../../../src/declarations/decorators/projection.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qCAAqC,CAAC;AAC3E,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,0CAA0C,CAAC;AACrF,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,gDAAgD,CAAC;AAOhG,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAEjE;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,KAAK,CAAC,CAAC,SAAS,oBAAoB,GAAG,yBAAyB,EACzF,IAAI,EAAE,GAAG,MAAM,IAAI,MAAM,EAAE,EAC3B,YAAY,CAAC,EAAE,CAAC,GACf,eAAe,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;AAC9B,wBAAgB,UAAU,CAAC,KAAK,CAAC,CAAC,SAAS,oBAAoB,GAAG,yBAAyB,EACzF,IAAI,EAAE,GAAG,MAAM,IAAI,MAAM,EAAE,EAC3B,OAAO,EAAE,iBAAiB,EAC1B,YAAY,CAAC,EAAE,CAAC,GACf,eAAe,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC"}

package/dist/declarations/decorators/projection.js

@@ -2,24 +2,32 @@ import { isJobName } from '../../application/scheduling/is-job-name.js';
 import { DeclarationError } from '../registry/declaration-error.js';
 import { record } from '../registry/record.js';
 import { pendingApplications } from './pending-applications.js';
-/**
- * A projector: the class that keeps one read model up to date, each of its `@On` methods
- * applying one event through a port of its own read model:
- * `@Projection('scheduling.appointment-list')`. The name is the consumer
- * it is subscribed as: stable, `<context>.<name>`, unique in the application.
- */
-export function Projection(name, dependencies) {
+export function Projection(name, second, third) {
     if (!isJobName(name)) {
         throw new DeclarationError(`"${name}" is not a projection name: write <context>.<name> in lower case, words separated by dashes, as in 'scheduling.appointment-list'.`);
     }
+    const options = isOptions(second) ? second : undefined;
+    const dependencies = isOptions(second) ? third : second;
+    const feed = options?.feed ?? 'dispatch';
     return (target) => {
         const applies = claimed(target);
         if (applies.length === 0) {
             throw new DeclarationError(`Projection ${target.name} applies no event: write @On(...) on the methods that do.`);
         }
-        record(target, { role: 'projection', name, implementation: target, dependencies, applies });
+        assertFedBy(feed, target, applies);
+        record(target, { role: 'projection', name, implementation: target, dependencies, feed, applies });
     };
 }
+function isOptions(value) {
+    return typeof value === 'object' && 'feed' in value;
+}
+/** A projection fed by the event store applies the domain events of its context, nothing else. */
+function assertFedBy(feed, target, applies) {
+    const integration = applies.find((application) => application.kind === 'integration');
+    if (feed === 'event-store' && integration !== undefined) {
+        throw new DeclarationError(`Projection ${target.name} is fed by the event store and applies the integration event of its method "${integration.method}": an integration event reaches a projection fed where it is consumed.`);
+    }
+}
 /** The `@On` of the methods of the class: they ran just before its `@Projection`. */
 function claimed(target) {
     const pending = pendingApplications().splice(0);