@ddd-ts-kit/kernel 0.0.0-stage → 0.1.0

package/dist/infrastructure/context/restoring.js

@@ -0,0 +1,18 @@
+export function restoring(work, restore) {
+    let outcome;
+    try {
+        outcome = work();
+    }
+    catch (error) {
+        restore();
+        throw error;
+    }
+    if (outcome instanceof Promise) {
+        outcome.then(restore, restore);
+    }
+    else {
+        restore();
+    }
+    return outcome;
+}
+//# sourceMappingURL=restoring.js.map

package/dist/infrastructure/context/restoring.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"restoring.js","sourceRoot":"","sources":["../../../src/infrastructure/context/restoring.ts"],"names":[],"mappings":"AAAA,MAAM,UAAU,SAAS,CAAI,IAAa,EAAE,OAAmB;IAC7D,IAAI,OAAU,CAAC;IAEf,IAAI,CAAC;QACH,OAAO,GAAG,IAAI,EAAE,CAAC;IACnB,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,OAAO,EAAE,CAAC;QACV,MAAM,KAAK,CAAC;IACd,CAAC;IAED,IAAI,OAAO,YAAY,OAAO,EAAE,CAAC;QAC/B,OAAO,CAAC,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;IACjC,CAAC;SAAM,CAAC;QACN,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,OAAO,OAAO,CAAC;AACjB,CAAC"}

package/dist/infrastructure/context/scoped-actor-context.d.ts

@@ -0,0 +1,19 @@
+import type { Actor } from '../../application/actor/actor.js';
+import type { ActorContext } from '../../application/ports/actor-context.js';
+import type { ExecutionScope } from '../../application/ports/execution-scope.js';
+import type { IdGenerator } from '../../application/ports/id-generator.js';
+/**
+ * The `ActorContext` of an application that has an execution scope: one source of truth, so
+ * the two cannot disagree. The current actor is the actor of the current execution context;
+ * `run(actor, work)` runs the work in the current context seen as that actor, or opens a
+ * context of origin `internal` when there is none.
+ */
+export declare class ScopedActorContext implements ActorContext {
+    private readonly scope;
+    private readonly correlationIds;
+    constructor(scope: ExecutionScope, correlationIds: IdGenerator);
+    current(): Actor | undefined;
+    require(): Actor;
+    run<T>(actor: Actor, work: () => T): T;
+}
+//# sourceMappingURL=scoped-actor-context.d.ts.map

package/dist/infrastructure/context/scoped-actor-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scoped-actor-context.d.ts","sourceRoot":"","sources":["../../../src/infrastructure/context/scoped-actor-context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kCAAkC,CAAC;AAI9D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0CAA0C,CAAC;AAC7E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,4CAA4C,CAAC;AACjF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yCAAyC,CAAC;AAE3E;;;;;GAKG;AACH,qBAAa,kBAAmB,YAAW,YAAY;IAEnD,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,cAAc;IAFjC,YACmB,KAAK,EAAE,cAAc,EACrB,cAAc,EAAE,WAAW,EAC1C;IAEJ,OAAO,IAAI,KAAK,GAAG,SAAS,CAE3B;IAED,OAAO,IAAI,KAAK,CAQf;IAED,GAAG,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,CAAC,GAAG,CAAC,CASrC;CACF"}

package/dist/infrastructure/context/scoped-actor-context.js

@@ -0,0 +1,35 @@
+import { NoCurrentActorError } from '../../application/actor/no-current-actor-error.js';
+import { executionContext } from '../../application/execution/execution-context.js';
+import { withActor } from '../../application/execution/with-actor.js';
+/**
+ * The `ActorContext` of an application that has an execution scope: one source of truth, so
+ * the two cannot disagree. The current actor is the actor of the current execution context;
+ * `run(actor, work)` runs the work in the current context seen as that actor, or opens a
+ * context of origin `internal` when there is none.
+ */
+export class ScopedActorContext {
+    scope;
+    correlationIds;
+    constructor(scope, correlationIds) {
+        this.scope = scope;
+        this.correlationIds = correlationIds;
+    }
+    current() {
+        return this.scope.current()?.actor;
+    }
+    require() {
+        const actor = this.current();
+        if (actor === undefined) {
+            throw new NoCurrentActorError();
+        }
+        return actor;
+    }
+    run(actor, work) {
+        const current = this.scope.current();
+        const context = current === undefined
+            ? executionContext({ correlationId: this.correlationIds.next(), actor, origin: 'internal' })
+            : withActor(current, actor);
+        return this.scope.run(context, work);
+    }
+}
+//# sourceMappingURL=scoped-actor-context.js.map

package/dist/infrastructure/context/scoped-actor-context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scoped-actor-context.js","sourceRoot":"","sources":["../../../src/infrastructure/context/scoped-actor-context.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAE,MAAM,mDAAmD,CAAC;AACxF,OAAO,EAAE,gBAAgB,EAAE,MAAM,kDAAkD,CAAC;AACpF,OAAO,EAAE,SAAS,EAAE,MAAM,2CAA2C,CAAC;AAKtE;;;;;GAKG;AACH,MAAM,OAAO,kBAAkB;IAEV,KAAK;IACL,cAAc;IAFjC,YACmB,KAAqB,EACrB,cAA2B;qBAD3B,KAAK;8BACL,cAAc;IAC9B,CAAC;IAEJ,OAAO;QACL,OAAO,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,EAAE,KAAK,CAAC;IACrC,CAAC;IAED,OAAO;QACL,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC;QAE7B,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;YACxB,MAAM,IAAI,mBAAmB,EAAE,CAAC;QAClC,CAAC;QAED,OAAO,KAAK,CAAC;IACf,CAAC;IAED,GAAG,CAAI,KAAY,EAAE,IAAa;QAChC,MAAM,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC;QAErC,MAAM,OAAO,GACX,OAAO,KAAK,SAAS;YACnB,CAAC,CAAC,gBAAgB,CAAC,EAAE,aAAa,EAAE,IAAI,CAAC,cAAc,CAAC,IAAI,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,CAAC;YAC5F,CAAC,CAAC,SAAS,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;QAEhC,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;IACvC,CAAC;CACF"}

package/dist/infrastructure/domain-events/announce-domain-events.d.ts

@@ -0,0 +1,16 @@
+import type { DomainEventDispatcher } from '../../application/ports/domain-event-dispatcher.js';
+import type { DomainEvent } from '../../domain/domain-event.js';
+/**
+ * Hands over the events a save pulled from its aggregates.
+ *
+ * Inside a unit of work they only join its queue, behind what earlier saves recorded: the unit
+ * of work dispatches them at its end, before the commit (`withinUnitOfWork`), and the promise
+ * resolves at once.
+ *
+ * Outside of any, the save is all there is to wait for: they are dispatched now, `before-commit`
+ * handlers then `after-commit` ones, in the asynchronous context of that save. Events recorded
+ * meanwhile, by a handler that saves an aggregate, wait behind them: one chain, in recording
+ * order, without recursion. The first `before-commit` handler that fails rejects the promise.
+ */
+export declare function announceDomainEvents(events: readonly DomainEvent[], dispatcher: Pick<DomainEventDispatcher, 'dispatch'>): Promise<void>;
+//# sourceMappingURL=announce-domain-events.d.ts.map

package/dist/infrastructure/domain-events/announce-domain-events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"announce-domain-events.d.ts","sourceRoot":"","sources":["../../../src/infrastructure/domain-events/announce-domain-events.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,oDAAoD,CAAC;AAChG,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAOhE;;;;;;;;;;;GAWG;AACH,wBAAsB,oBAAoB,CACxC,MAAM,EAAE,SAAS,WAAW,EAAE,EAC9B,UAAU,EAAE,IAAI,CAAC,qBAAqB,EAAE,UAAU,CAAC,GAClD,OAAO,CAAC,IAAI,CAAC,CAkBf"}

package/dist/infrastructure/domain-events/announce-domain-events.js

@@ -0,0 +1,47 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { dispatchAfterCommit } from './dispatch-after-commit.js';
+import { dispatchBeforeCommit } from './dispatch-before-commit.js';
+import { here } from './here.js';
+import { SaveAfterCommitError } from './save-after-commit-error.js';
+import { unitOfWorkScope } from './unit-of-work-scope.js';
+/**
+ * Hands over the events a save pulled from its aggregates.
+ *
+ * Inside a unit of work they only join its queue, behind what earlier saves recorded: the unit
+ * of work dispatches them at its end, before the commit (`withinUnitOfWork`), and the promise
+ * resolves at once.
+ *
+ * Outside of any, the save is all there is to wait for: they are dispatched now, `before-commit`
+ * handlers then `after-commit` ones, in the asynchronous context of that save. Events recorded
+ * meanwhile, by a handler that saves an aggregate, wait behind them: one chain, in recording
+ * order, without recursion. The first `before-commit` handler that fails rejects the promise.
+ */
+export async function announceDomainEvents(events, dispatcher) {
+    if (events.length === 0) {
+        return;
+    }
+    const current = unitOfWorkScope.getStore();
+    if (current?.stage === 'after-commit') {
+        throw new SaveAfterCommitError('announceDomainEvents');
+    }
+    if (current !== undefined && current.stage !== 'closed') {
+        current.queue.push(...queued(events, dispatcher, current.kind === 'save' ? AsyncLocalStorage.snapshot() : here));
+        return;
+    }
+    await dispatchedNow(queued(events, dispatcher, AsyncLocalStorage.snapshot()));
+}
+function queued(events, dispatcher, within) {
+    return events.map((event) => ({ event, dispatcher, within }));
+}
+async function dispatchedNow(events) {
+    const scope = { kind: 'save', stage: 'open', queue: events, dispatched: [] };
+    try {
+        await dispatchBeforeCommit(scope);
+    }
+    finally {
+        scope.stage = 'closed';
+        scope.queue.length = 0;
+    }
+    await dispatchAfterCommit(scope);
+}
+//# sourceMappingURL=announce-domain-events.js.map

package/dist/infrastructure/domain-events/announce-domain-events.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"announce-domain-events.js","sourceRoot":"","sources":["../../../src/infrastructure/domain-events/announce-domain-events.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAGrD,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AACjE,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AACnE,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AACpE,OAAO,EAAE,eAAe,EAAgD,MAAM,yBAAyB,CAAC;AAExG;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,KAAK,UAAU,oBAAoB,CACxC,MAA8B,EAC9B,UAAmD;IAEnD,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACxB,OAAO;IACT,CAAC;IAED,MAAM,OAAO,GAAG,eAAe,CAAC,QAAQ,EAAE,CAAC;IAE3C,IAAI,OAAO,EAAE,KAAK,KAAK,cAAc,EAAE,CAAC;QACtC,MAAM,IAAI,oBAAoB,CAAC,sBAAsB,CAAC,CAAC;IACzD,CAAC;IAED,IAAI,OAAO,KAAK,SAAS,IAAI,OAAO,CAAC,KAAK,KAAK,QAAQ,EAAE,CAAC;QACxD,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,UAAU,EAAE,OAAO,CAAC,IAAI,KAAK,MAAM,CAAC,CAAC,CAAC,iBAAiB,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;QAEjH,OAAO;IACT,CAAC;IAED,MAAM,aAAa,CAAC,MAAM,CAAC,MAAM,EAAE,UAAU,EAAE,iBAAiB,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC;AAChF,CAAC;AAED,SAAS,MAAM,CACb,MAA8B,EAC9B,UAAmD,EACnD,MAAmC;IAEnC,OAAO,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC;AAChE,CAAC;AAED,KAAK,UAAU,aAAa,CAAC,MAA2B;IACtD,MAAM,KAAK,GAAoB,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,EAAE,EAAE,CAAC;IAE9F,IAAI,CAAC;QACH,MAAM,oBAAoB,CAAC,KAAK,CAAC,CAAC;IACpC,CAAC;YAAS,CAAC;QACT,KAAK,CAAC,KAAK,GAAG,QAAQ,CAAC;QACvB,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC;IACzB,CAAC;IAED,MAAM,mBAAmB,CAAC,KAAK,CAAC,CAAC;AACnC,CAAC"}

package/dist/infrastructure/domain-events/dispatch-after-commit.d.ts

@@ -0,0 +1,8 @@
+import type { UnitOfWorkScope } from './unit-of-work-scope.js';
+/**
+ * Hands every event dispatched before the commit to the `after-commit` handlers. Never rejects:
+ * the state is committed, so nothing here may fail the caller. A save made from there is
+ * refused (`SaveAfterCommitError`), and a unit of work started from there is a new one.
+ */
+export declare function dispatchAfterCommit({ kind, dispatched }: UnitOfWorkScope): Promise<void>;
+//# sourceMappingURL=dispatch-after-commit.d.ts.map

package/dist/infrastructure/domain-events/dispatch-after-commit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dispatch-after-commit.d.ts","sourceRoot":"","sources":["../../../src/infrastructure/domain-events/dispatch-after-commit.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAE/D;;;;GAIG;AACH,wBAAsB,mBAAmB,CAAC,EAAE,IAAI,EAAE,UAAU,EAAE,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAM9F"}

package/dist/infrastructure/domain-events/dispatch-after-commit.js

@@ -0,0 +1,14 @@
+import { domainEventRuns } from './domain-event-runs.js';
+import { here } from './here.js';
+/**
+ * Hands every event dispatched before the commit to the `after-commit` handlers. Never rejects:
+ * the state is committed, so nothing here may fail the caller. A save made from there is
+ * refused (`SaveAfterCommitError`), and a unit of work started from there is a new one.
+ */
+export async function dispatchAfterCommit({ kind, dispatched }) {
+    const scope = { kind, stage: 'after-commit', queue: [], dispatched: [] };
+    for (const run of domainEventRuns(dispatched.map((queued) => ({ ...queued, within: here })))) {
+        await run.dispatch(scope, 'after-commit').catch(() => undefined);
+    }
+}
+//# sourceMappingURL=dispatch-after-commit.js.map

package/dist/infrastructure/domain-events/dispatch-after-commit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dispatch-after-commit.js","sourceRoot":"","sources":["../../../src/infrastructure/domain-events/dispatch-after-commit.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AACzD,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAGjC;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,mBAAmB,CAAC,EAAE,IAAI,EAAE,UAAU,EAAmB;IAC7E,MAAM,KAAK,GAAoB,EAAE,IAAI,EAAE,KAAK,EAAE,cAAc,EAAE,KAAK,EAAE,EAAE,EAAE,UAAU,EAAE,EAAE,EAAE,CAAC;IAE1F,KAAK,MAAM,GAAG,IAAI,eAAe,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,EAAE,GAAG,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QAC7F,MAAM,GAAG,CAAC,QAAQ,CAAC,KAAK,EAAE,cAAc,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,CAAC;IACnE,CAAC;AACH,CAAC"}

package/dist/infrastructure/domain-events/dispatch-before-commit.d.ts

@@ -0,0 +1,8 @@
+import type { UnitOfWorkScope } from './unit-of-work-scope.js';
+/**
+ * Dispatches what waits in the scope, before the commit: the events queued so far in one go,
+ * then those their handlers recorded meanwhile, until nothing is left. Recording order, no
+ * recursion. The first handler that fails rejects, and what was still waiting is dropped.
+ */
+export declare function dispatchBeforeCommit(scope: UnitOfWorkScope): Promise<void>;
+//# sourceMappingURL=dispatch-before-commit.d.ts.map

package/dist/infrastructure/domain-events/dispatch-before-commit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dispatch-before-commit.d.ts","sourceRoot":"","sources":["../../../src/infrastructure/domain-events/dispatch-before-commit.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAE/D;;;;GAIG;AACH,wBAAsB,oBAAoB,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAUhF"}

package/dist/infrastructure/domain-events/dispatch-before-commit.js

@@ -0,0 +1,16 @@
+import { domainEventRuns } from './domain-event-runs.js';
+/**
+ * Dispatches what waits in the scope, before the commit: the events queued so far in one go,
+ * then those their handlers recorded meanwhile, until nothing is left. Recording order, no
+ * recursion. The first handler that fails rejects, and what was still waiting is dropped.
+ */
+export async function dispatchBeforeCommit(scope) {
+    scope.stage = 'before-commit';
+    for (let round = scope.queue.splice(0); round.length > 0; round = scope.queue.splice(0)) {
+        for (const run of domainEventRuns(round)) {
+            await run.dispatch(scope, 'before-commit');
+        }
+        scope.dispatched.push(...round);
+    }
+}
+//# sourceMappingURL=dispatch-before-commit.js.map

package/dist/infrastructure/domain-events/dispatch-before-commit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dispatch-before-commit.js","sourceRoot":"","sources":["../../../src/infrastructure/domain-events/dispatch-before-commit.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAGzD;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,oBAAoB,CAAC,KAAsB;IAC/D,KAAK,CAAC,KAAK,GAAG,eAAe,CAAC;IAE9B,KAAK,IAAI,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC;QACxF,KAAK,MAAM,GAAG,IAAI,eAAe,CAAC,KAAK,CAAC,EAAE,CAAC;YACzC,MAAM,GAAG,CAAC,QAAQ,CAAC,KAAK,EAAE,eAAe,CAAC,CAAC;QAC7C,CAAC;QAED,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC,CAAC;IAClC,CAAC;AACH,CAAC"}

package/dist/infrastructure/domain-events/dispatching-on-save.d.ts

@@ -0,0 +1,20 @@
+import type { DomainEventDispatcher } from '../../application/ports/domain-event-dispatcher.js';
+type Dispatching = () => Pick<DomainEventDispatcher, 'dispatch'>;
+/**
+ * Makes domain events leave with the save. Every method of the repository that is handed an
+ * aggregate (`save(order)`, `saveAll([a, b])`, `remove(order)`) and resolves has the events
+ * those aggregates recorded pulled, in the order of the arguments then of recording, and handed
+ * to `announceDomainEvents`: queued until the end of the unit of work in progress, or dispatched
+ * before the caller gets its answer when there is none. A call that fails pulls nothing: the
+ * events stay on the aggregate and reach no handler. A method that is handed no aggregate
+ * (`findById`, `remove(id)`) is untouched. Called by an `after-commit` handler with an
+ * aggregate, a method is refused before it writes (`SaveAfterCommitError`).
+ *
+ * The repository is wrapped in place, as tracing and the aspects do, so the same object is
+ * answered and wrapping twice is a no-op; a sealed or frozen one is fronted by a proxy. The
+ * dispatcher is asked for at each dispatch. An adapter contains no dispatch code: one that
+ * pulls the events itself leaves nothing to dispatch here.
+ */
+export declare function dispatchingOnSave<T extends object>(repository: T, dispatcher: Dispatching): T;
+export {};
+//# sourceMappingURL=dispatching-on-save.d.ts.map

package/dist/infrastructure/domain-events/dispatching-on-save.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dispatching-on-save.d.ts","sourceRoot":"","sources":["../../../src/infrastructure/domain-events/dispatching-on-save.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,oDAAoD,CAAC;AAQhG,KAAK,WAAW,GAAG,MAAM,IAAI,CAAC,qBAAqB,EAAE,UAAU,CAAC,CAAC;AAIjE;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,MAAM,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU,EAAE,WAAW,GAAG,CAAC,CAgB7F"}

package/dist/infrastructure/domain-events/dispatching-on-save.js

@@ -0,0 +1,97 @@
+import { announceDomainEvents } from './announce-domain-events.js';
+import { recordedAggregates } from './recorded-aggregates.js';
+import { SaveAfterCommitError } from './save-after-commit-error.js';
+import { unitOfWorkScope } from './unit-of-work-scope.js';
+const wrapped = new WeakSet();
+/**
+ * Makes domain events leave with the save. Every method of the repository that is handed an
+ * aggregate (`save(order)`, `saveAll([a, b])`, `remove(order)`) and resolves has the events
+ * those aggregates recorded pulled, in the order of the arguments then of recording, and handed
+ * to `announceDomainEvents`: queued until the end of the unit of work in progress, or dispatched
+ * before the caller gets its answer when there is none. A call that fails pulls nothing: the
+ * events stay on the aggregate and reach no handler. A method that is handed no aggregate
+ * (`findById`, `remove(id)`) is untouched. Called by an `after-commit` handler with an
+ * aggregate, a method is refused before it writes (`SaveAfterCommitError`).
+ *
+ * The repository is wrapped in place, as tracing and the aspects do, so the same object is
+ * answered and wrapping twice is a no-op; a sealed or frozen one is fronted by a proxy. The
+ * dispatcher is asked for at each dispatch. An adapter contains no dispatch code: one that
+ * pulls the events itself leaves nothing to dispatch here.
+ */
+export function dispatchingOnSave(repository, dispatcher) {
+    if (wrapped.has(repository)) {
+        return repository;
+    }
+    const wrappers = new Map();
+    for (const [name, method] of methodsOf(repository)) {
+        wrappers.set(name, announcing(method, dispatcher));
+    }
+    const result = Object.isExtensible(repository) ? shadowed(repository, wrappers) : proxied(repository, wrappers);
+    wrapped.add(result);
+    return result;
+}
+/** Own and inherited methods as they are reached now: a wrapper put by an aspect is the method. */
+function methodsOf(instance) {
+    const methods = new Map();
+    for (let owner = instance; owner !== null && owner !== Object.prototype; owner = Reflect.getPrototypeOf(owner)) {
+        for (const name of Object.getOwnPropertyNames(owner)) {
+            const descriptor = Object.getOwnPropertyDescriptor(owner, name);
+            if (name === 'constructor' || methods.has(name) || typeof descriptor?.value !== 'function') {
+                continue;
+            }
+            const current = Reflect.get(instance, name);
+            if (isMethod(current)) {
+                methods.set(name, current);
+            }
+        }
+    }
+    return methods;
+}
+function isMethod(value) {
+    return typeof value === 'function' && !Function.prototype.toString.call(value).startsWith('class');
+}
+/** Async when the method is declared so, for what reads it later (tracing, an aspect) to see an asynchronous method. */
+function announcing(original, dispatcher) {
+    const announced = async (args, result) => {
+        const value = await result;
+        await announceDomainEvents(recordedAggregates(args).flatMap((aggregate) => aggregate.pullEvents()), dispatcher());
+        return value;
+    };
+    const wrapper = original.constructor.name === 'AsyncFunction'
+        ? async function (...args) {
+            refuseAfterCommit(original.name, args);
+            return announced(args, original.apply(this, args));
+        }
+        : function (...args) {
+            refuseAfterCommit(original.name, args);
+            const result = original.apply(this, args);
+            return isThenable(result) && recordedAggregates(args).length > 0 ? announced(args, result) : result;
+        };
+    Object.defineProperty(wrapper, 'name', { value: original.name, configurable: true });
+    return wrapper;
+}
+function refuseAfterCommit(method, args) {
+    if (unitOfWorkScope.getStore()?.stage === 'after-commit' && recordedAggregates(args).length > 0) {
+        throw new SaveAfterCommitError(method);
+    }
+}
+function isThenable(value) {
+    return typeof value === 'object' && value !== null && 'then' in value && typeof value.then === 'function';
+}
+function shadowed(instance, wrappers) {
+    for (const [name, wrapper] of wrappers) {
+        const enumerable = Object.getOwnPropertyDescriptor(instance, name)?.enumerable ?? false;
+        Object.defineProperty(instance, name, { value: wrapper, writable: true, configurable: true, enumerable });
+    }
+    return instance;
+}
+/** Methods run with the proxy as `this`, so a method the repository calls on itself meets the same wrappers. */
+function proxied(instance, wrappers) {
+    return new Proxy(instance, {
+        get(target, property, receiver) {
+            const wrapper = typeof property === 'string' ? wrappers.get(property) : undefined;
+            return wrapper ?? Reflect.get(target, property, receiver);
+        },
+    });
+}
+//# sourceMappingURL=dispatching-on-save.js.map

package/dist/infrastructure/domain-events/dispatching-on-save.js.map

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

package/dist/infrastructure/domain-events/domain-event-runs.d.ts

@@ -0,0 +1,9 @@
+import type { DomainEventPhase } from '../../application/events/domain-event-phase.js';
+import { type QueuedDomainEvent, type UnitOfWorkScope } from './unit-of-work-scope.js';
+/** Neighbours of a queue handed over by the same save to the same dispatcher: they leave together. */
+export interface DomainEventRun {
+    /** Hands the events to their dispatcher for one phase, inside the scope, in the asynchronous context they were queued with. */
+    dispatch(scope: UnitOfWorkScope, phase: DomainEventPhase): Promise<void>;
+}
+export declare function domainEventRuns(events: readonly QueuedDomainEvent[]): DomainEventRun[];
+//# sourceMappingURL=domain-event-runs.d.ts.map

package/dist/infrastructure/domain-events/domain-event-runs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain-event-runs.d.ts","sourceRoot":"","sources":["../../../src/infrastructure/domain-events/domain-event-runs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gDAAgD,CAAC;AACvF,OAAO,EAAmB,KAAK,iBAAiB,EAAE,KAAK,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAExG,sGAAsG;AACtG,MAAM,WAAW,cAAc;IAC7B,+HAA+H;IAC/H,QAAQ,CAAC,KAAK,EAAE,eAAe,EAAE,KAAK,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1E;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,SAAS,iBAAiB,EAAE,GAAG,cAAc,EAAE,CActF"}

package/dist/infrastructure/domain-events/domain-event-runs.js

@@ -0,0 +1,27 @@
+import { unitOfWorkScope } from './unit-of-work-scope.js';
+export function domainEventRuns(events) {
+    const groups = [];
+    for (const queued of events) {
+        const first = groups.at(-1)?.[0];
+        if (first !== undefined && first.dispatcher === queued.dispatcher && first.within === queued.within) {
+            groups.at(-1)?.push(queued);
+        }
+        else {
+            groups.push([queued]);
+        }
+    }
+    return groups.flatMap(runOf);
+}
+function runOf(group) {
+    const [first] = group;
+    if (first === undefined) {
+        return [];
+    }
+    const facts = group.map(({ event }) => event);
+    return [
+        {
+            dispatch: (scope, phase) => first.within(() => unitOfWorkScope.run(scope, async () => first.dispatcher.dispatch(facts, phase))),
+        },
+    ];
+}
+//# sourceMappingURL=domain-event-runs.js.map

package/dist/infrastructure/domain-events/domain-event-runs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain-event-runs.js","sourceRoot":"","sources":["../../../src/infrastructure/domain-events/domain-event-runs.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAgD,MAAM,yBAAyB,CAAC;AAQxG,MAAM,UAAU,eAAe,CAAC,MAAoC;IAClE,MAAM,MAAM,GAA0B,EAAE,CAAC;IAEzC,KAAK,MAAM,MAAM,IAAI,MAAM,EAAE,CAAC;QAC5B,MAAM,KAAK,GAAG,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;QAEjC,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,CAAC,UAAU,KAAK,MAAM,CAAC,UAAU,IAAI,KAAK,CAAC,MAAM,KAAK,MAAM,CAAC,MAAM,EAAE,CAAC;YACpG,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;QAC9B,CAAC;aAAM,CAAC;YACN,MAAM,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;QACxB,CAAC;IACH,CAAC;IAED,OAAO,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;AAC/B,CAAC;AAED,SAAS,KAAK,CAAC,KAAmC;IAChD,MAAM,CAAC,KAAK,CAAC,GAAG,KAAK,CAAC;IAEtB,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;QACxB,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,MAAM,KAAK,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC,KAAK,CAAC,CAAC;IAE9C,OAAO;QACL;YACE,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE,CACzB,KAAK,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC,eAAe,CAAC,GAAG,CAAC,KAAK,EAAE,KAAK,IAAI,EAAE,CAAC,KAAK,CAAC,UAAU,CAAC,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC;SACtG;KACF,CAAC;AACJ,CAAC"}

package/dist/infrastructure/domain-events/here.d.ts

@@ -0,0 +1,3 @@
+/** Runs the work in the asynchronous context of the caller. */
+export declare function here<T>(work: () => T): T;
+//# sourceMappingURL=here.d.ts.map

package/dist/infrastructure/domain-events/here.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"here.d.ts","sourceRoot":"","sources":["../../../src/infrastructure/domain-events/here.ts"],"names":[],"mappings":"AAAA,+DAA+D;AAC/D,wBAAgB,IAAI,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,CAAC,GAAG,CAAC,CAExC"}

package/dist/infrastructure/domain-events/here.js

@@ -0,0 +1,5 @@
+/** Runs the work in the asynchronous context of the caller. */
+export function here(work) {
+    return work();
+}
+//# sourceMappingURL=here.js.map

package/dist/infrastructure/domain-events/here.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"here.js","sourceRoot":"","sources":["../../../src/infrastructure/domain-events/here.ts"],"names":[],"mappings":"AAAA,+DAA+D;AAC/D,MAAM,UAAU,IAAI,CAAI,IAAa;IACnC,OAAO,IAAI,EAAE,CAAC;AAChB,CAAC"}

package/dist/infrastructure/domain-events/recorded-aggregates.d.ts

@@ -0,0 +1,10 @@
+import type { AggregateRoot } from '../../domain/aggregate-root.js';
+type EventSource = Pick<AggregateRoot<string | number>, 'pullEvents'>;
+/**
+ * The aggregates among the arguments of a call, given as such or in arrays, in the order
+ * written. Recognised by what they do, not by their class: a context compiled apart extends
+ * its own copy of `AggregateRoot`.
+ */
+export declare function recordedAggregates(args: readonly unknown[]): EventSource[];
+export {};
+//# sourceMappingURL=recorded-aggregates.d.ts.map

package/dist/infrastructure/domain-events/recorded-aggregates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recorded-aggregates.d.ts","sourceRoot":"","sources":["../../../src/infrastructure/domain-events/recorded-aggregates.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAEpE,KAAK,WAAW,GAAG,IAAI,CAAC,aAAa,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,YAAY,CAAC,CAAC;AAEtE;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,SAAS,OAAO,EAAE,GAAG,WAAW,EAAE,CAE1E"}

package/dist/infrastructure/domain-events/recorded-aggregates.js

@@ -0,0 +1,15 @@
+/**
+ * The aggregates among the arguments of a call, given as such or in arrays, in the order
+ * written. Recognised by what they do, not by their class: a context compiled apart extends
+ * its own copy of `AggregateRoot`.
+ */
+export function recordedAggregates(args) {
+    return args.flatMap(listOf).filter(isEventSource);
+}
+function listOf(argument) {
+    return Array.isArray(argument) ? argument : [argument];
+}
+function isEventSource(value) {
+    return typeof value === 'object' && value !== null && 'pullEvents' in value && typeof value.pullEvents === 'function';
+}
+//# sourceMappingURL=recorded-aggregates.js.map

package/dist/infrastructure/domain-events/recorded-aggregates.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"recorded-aggregates.js","sourceRoot":"","sources":["../../../src/infrastructure/domain-events/recorded-aggregates.ts"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,MAAM,UAAU,kBAAkB,CAAC,IAAwB;IACzD,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC;AACpD,CAAC;AAED,SAAS,MAAM,CAAC,QAAiB;IAC/B,OAAO,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC;AACzD,CAAC;AAED,SAAS,aAAa,CAAC,KAAc;IACnC,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,IAAI,YAAY,IAAI,KAAK,IAAI,OAAO,KAAK,CAAC,UAAU,KAAK,UAAU,CAAC;AACxH,CAAC"}

package/dist/infrastructure/domain-events/report-after-commit-failures.d.ts

@@ -0,0 +1,16 @@
+import type { AfterCommitFailure } from '../../application/events/after-commit-failure.js';
+import type { ErrorReporter } from '../../application/ports/error-reporter.js';
+import type { ExecutionScope } from '../../application/ports/execution-scope.js';
+import type { Logger } from '../../application/ports/logger.js';
+export interface AfterCommitFailureSinks {
+    readonly reporter: ErrorReporter;
+    readonly logger: Pick<Logger, 'error'>;
+    readonly scope?: Pick<ExecutionScope, 'current'>;
+}
+/**
+ * What a dispatcher does with the failure of an `after-commit` handler: one error entry naming
+ * the event and the class of the error, and the error handed to the reporter, under the
+ * operation `after-commit <event name>`. The state is committed: the failure goes no further.
+ */
+export declare function reportAfterCommitFailures({ reporter, logger, scope }: AfterCommitFailureSinks): AfterCommitFailure;
+//# sourceMappingURL=report-after-commit-failures.d.ts.map

package/dist/infrastructure/domain-events/report-after-commit-failures.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"report-after-commit-failures.d.ts","sourceRoot":"","sources":["../../../src/infrastructure/domain-events/report-after-commit-failures.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kDAAkD,CAAC;AAI3F,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2CAA2C,CAAC;AAC/E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,4CAA4C,CAAC;AACjF,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mCAAmC,CAAC;AAEhE,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC;IACjC,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACvC,QAAQ,CAAC,KAAK,CAAC,EAAE,IAAI,CAAC,cAAc,EAAE,SAAS,CAAC,CAAC;CAClD;AAED;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,EAAE,uBAAuB,GAAG,kBAAkB,CAWlH"}

package/dist/infrastructure/domain-events/report-after-commit-failures.js

@@ -0,0 +1,19 @@
+import { errorReportOf } from '../../application/error-reporting/error-report-of.js';
+import { reportOnce } from '../../application/error-reporting/report-once.js';
+import { identifyError } from '../../application/logging/identify-error.js';
+/**
+ * What a dispatcher does with the failure of an `after-commit` handler: one error entry naming
+ * the event and the class of the error, and the error handed to the reporter, under the
+ * operation `after-commit <event name>`. The state is committed: the failure goes no further.
+ */
+export function reportAfterCommitFailures({ reporter, logger, scope }) {
+    return (error, event) => {
+        const operation = `after-commit ${event.name}`;
+        logger.error('A domain event handler failed after the commit', {
+            domainEvent: event.name,
+            ...identifyError(error),
+        });
+        reportOnce(reporter, error, errorReportOf(error, { origin: 'domain-event', operation }, scope?.current()));
+    };
+}
+//# sourceMappingURL=report-after-commit-failures.js.map

package/dist/infrastructure/domain-events/report-after-commit-failures.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"report-after-commit-failures.js","sourceRoot":"","sources":["../../../src/infrastructure/domain-events/report-after-commit-failures.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,sDAAsD,CAAC;AACrF,OAAO,EAAE,UAAU,EAAE,MAAM,kDAAkD,CAAC;AAC9E,OAAO,EAAE,aAAa,EAAE,MAAM,6CAA6C,CAAC;AAW5E;;;;GAIG;AACH,MAAM,UAAU,yBAAyB,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,EAA2B;IAC5F,OAAO,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE;QACtB,MAAM,SAAS,GAAG,gBAAgB,KAAK,CAAC,IAAI,EAAE,CAAC;QAE/C,MAAM,CAAC,KAAK,CAAC,gDAAgD,EAAE;YAC7D,WAAW,EAAE,KAAK,CAAC,IAAI;YACvB,GAAG,aAAa,CAAC,KAAK,CAAC;SACxB,CAAC,CAAC;QAEH,UAAU,CAAC,QAAQ,EAAE,KAAK,EAAE,aAAa,CAAC,KAAK,EAAE,EAAE,MAAM,EAAE,cAAc,EAAE,SAAS,EAAE,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC,CAAC,CAAC;IAC7G,CAAC,CAAC;AACJ,CAAC"}

package/dist/infrastructure/domain-events/save-after-commit-error.d.ts

@@ -0,0 +1,10 @@
+/**
+ * An `after-commit` handler of a domain event handed an aggregate to a repository. The unit of
+ * work is over: nothing would dispatch what the aggregate recorded, and nothing would roll the
+ * write back. Such a handler sends a command through the command bus, which opens a unit of work
+ * of its own.
+ */
+export declare class SaveAfterCommitError extends Error {
+    constructor(method: string);
+}
+//# sourceMappingURL=save-after-commit-error.d.ts.map

package/dist/infrastructure/domain-events/save-after-commit-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"save-after-commit-error.d.ts","sourceRoot":"","sources":["../../../src/infrastructure/domain-events/save-after-commit-error.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,qBAAa,oBAAqB,SAAQ,KAAK;IAC7C,YAAY,MAAM,EAAE,MAAM,EAMzB;CACF"}

package/dist/infrastructure/domain-events/save-after-commit-error.js

@@ -0,0 +1,13 @@
+/**
+ * An `after-commit` handler of a domain event handed an aggregate to a repository. The unit of
+ * work is over: nothing would dispatch what the aggregate recorded, and nothing would roll the
+ * write back. Such a handler sends a command through the command bus, which opens a unit of work
+ * of its own.
+ */
+export class SaveAfterCommitError extends Error {
+    constructor(method) {
+        super(`An after-commit domain event handler called "${method}" with an aggregate: the unit of work is over. Send a command through the command bus instead, or declare the handler in the before-commit phase.`);
+        this.name = 'SaveAfterCommitError';
+    }
+}
+//# sourceMappingURL=save-after-commit-error.js.map

package/dist/infrastructure/domain-events/save-after-commit-error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"save-after-commit-error.js","sourceRoot":"","sources":["../../../src/infrastructure/domain-events/save-after-commit-error.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,OAAO,oBAAqB,SAAQ,KAAK;IAC7C,YAAY,MAAc;QACxB,KAAK,CACH,gDAAgD,MAAM,mJAAmJ,CAC1M,CAAC;QAEF,IAAI,CAAC,IAAI,GAAG,sBAAsB,CAAC;IACrC,CAAC;CACF"}

package/dist/infrastructure/domain-events/unit-of-work-scope.d.ts

@@ -0,0 +1,23 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import type { DomainEventDispatcher } from '../../application/ports/domain-event-dispatcher.js';
+import type { DomainEvent } from '../../domain/domain-event.js';
+/** One event waiting for the end of its scope: who dispatches it, and in which asynchronous context. */
+export interface QueuedDomainEvent {
+    readonly event: DomainEvent;
+    readonly dispatcher: Pick<DomainEventDispatcher, 'dispatch'>;
+    readonly within: <T>(work: () => T) => T;
+}
+/**
+ * What one unit of work has to dispatch. `unit-of-work` is opened by `withinUnitOfWork`; `save`
+ * is the scope of a save made outside of any, which dispatches as soon as it resolved.
+ */
+export interface UnitOfWorkScope {
+    readonly kind: 'unit-of-work' | 'save';
+    stage: 'open' | 'before-commit' | 'after-commit' | 'closed';
+    /** Recorded and not dispatched yet, oldest first. */
+    readonly queue: QueuedDomainEvent[];
+    /** Dispatched before the commit, in that order: what the `after-commit` phase is given. */
+    readonly dispatched: QueuedDomainEvent[];
+}
+export declare const unitOfWorkScope: AsyncLocalStorage<UnitOfWorkScope>;
+//# sourceMappingURL=unit-of-work-scope.d.ts.map

package/dist/infrastructure/domain-events/unit-of-work-scope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unit-of-work-scope.d.ts","sourceRoot":"","sources":["../../../src/infrastructure/domain-events/unit-of-work-scope.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,oDAAoD,CAAC;AAChG,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAEhE,wGAAwG;AACxG,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;IAC5B,QAAQ,CAAC,UAAU,EAAE,IAAI,CAAC,qBAAqB,EAAE,UAAU,CAAC,CAAC;IAC7D,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;CAC1C;AAED;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,IAAI,EAAE,cAAc,GAAG,MAAM,CAAC;IACvC,KAAK,EAAE,MAAM,GAAG,eAAe,GAAG,cAAc,GAAG,QAAQ,CAAC;IAC5D,qDAAqD;IACrD,QAAQ,CAAC,KAAK,EAAE,iBAAiB,EAAE,CAAC;IACpC,2FAA2F;IAC3F,QAAQ,CAAC,UAAU,EAAE,iBAAiB,EAAE,CAAC;CAC1C;AAGD,eAAO,MAAM,eAAe,oCAA2C,CAAC"}

package/dist/infrastructure/domain-events/unit-of-work-scope.js

@@ -0,0 +1,4 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+// Follows the asynchronous call chain of what opened it: concurrent commands never share a scope.
+export const unitOfWorkScope = new AsyncLocalStorage();
+//# sourceMappingURL=unit-of-work-scope.js.map

package/dist/infrastructure/domain-events/unit-of-work-scope.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unit-of-work-scope.js","sourceRoot":"","sources":["../../../src/infrastructure/domain-events/unit-of-work-scope.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAwBrD,kGAAkG;AAClG,MAAM,CAAC,MAAM,eAAe,GAAG,IAAI,iBAAiB,EAAmB,CAAC"}

package/dist/infrastructure/domain-events/unit-of-work-stage.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Where the caller stands in a unit of work: `open` while its work runs, `before-commit` while
+ * the domain events are dispatched inside the transaction, `after-commit` in a handler of that
+ * phase, `outside` anywhere else, a save made outside of any unit of work included.
+ */
+export type UnitOfWorkStage = 'outside' | 'open' | 'before-commit' | 'after-commit';
+export declare function unitOfWorkStage(): UnitOfWorkStage;
+//# sourceMappingURL=unit-of-work-stage.d.ts.map

package/dist/infrastructure/domain-events/unit-of-work-stage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unit-of-work-stage.d.ts","sourceRoot":"","sources":["../../../src/infrastructure/domain-events/unit-of-work-stage.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,MAAM,MAAM,eAAe,GAAG,SAAS,GAAG,MAAM,GAAG,eAAe,GAAG,cAAc,CAAC;AAEpF,wBAAgB,eAAe,IAAI,eAAe,CAQjD"}