@entifix/testing-unit 0.1.0-0

package/dist/doubles/transaction-ports.d.ts

@@ -0,0 +1,70 @@
+import { type DomainEvent, type EntifixError } from '@entifix/core';
+import type { EventBus, LockService, SequenceService, TransactionInbox } from '@entifix/transactions';
+import { Effect } from 'effect';
+export interface InMemoryLockService extends LockService {
+    /** Keys currently held, in acquisition order. */
+    readonly held: string[];
+    /** Every acquire/release in the order it happened. */
+    readonly log: ReadonlyArray<{
+        action: 'acquire' | 'release';
+        key: string;
+    }>;
+    /**
+     * Marks `key` as already taken by someone else, so the next `acquire` fails
+     * with {@link EntifixLockError} — the 409 path of the transaction facade.
+     */
+    contendOn(key: string): void;
+}
+/**
+ * In-memory {@link LockService}. Acquisition is immediate and uncontended
+ * unless {@link InMemoryLockService.contendOn} says otherwise, and `release`
+ * only frees a lock whose token matches — the compare-and-delete rule the Redis
+ * adapter enforces with a Lua script.
+ */
+export declare const makeInMemoryLockService: () => InMemoryLockService;
+export interface InMemorySequenceService extends SequenceService {
+    /** The current value of every sequence drawn from so far. */
+    readonly values: Readonly<Record<string, number>>;
+}
+/**
+ * In-memory {@link SequenceService} — a plain counter per name. Atomicity is
+ * what the Redis `INCR` adapter buys; single-threaded JS gives it for free here.
+ */
+export declare const makeInMemorySequenceService: () => InMemorySequenceService;
+export interface RecordingEventBus extends EventBus {
+    /** Every event published, in order. */
+    readonly published: DomainEvent[];
+    /**
+     * Pushes an event to the subscribers whose pattern matches it, as a topic
+     * exchange would. Deliberately not "to all subscribers": routing is the
+     * broker's job in production, so a double that ignored it would let a
+     * consumer pass its tests while receiving traffic it never bound to.
+     */
+    deliver(event: DomainEvent): Effect.Effect<void, EntifixError>;
+    /** Makes the next `publish` fail, for the broker-unavailable branch. */
+    failNextPublish(): void;
+}
+/**
+ * In-memory {@link EventBus} that records what was published rather than
+ * asserting on it. Prefer reading `bus.published` in a test over a mock's call
+ * assertions: the expectation then reads as state, not as a spy protocol.
+ */
+export declare const makeRecordingEventBus: () => RecordingEventBus;
+/**
+ * An in-memory {@link TransactionInbox}, one per consumer, over a shared claim
+ * set.
+ *
+ * Sharing the set across the inboxes one factory hands out is what makes the
+ * contract's "one consumer cannot consume another's claim" case a real
+ * assertion, rather than one the double satisfies by only ever having seen a
+ * single consumer.
+ */
+export declare const makeInMemoryInboxes: () => {
+    /** An inbox for `consumer`, over the shared claim set. */
+    for: (consumer: string) => TransactionInbox;
+    readonly claims: readonly {
+        consumer: string;
+        eventId: string;
+    }[];
+};
+//# sourceMappingURL=transaction-ports.d.ts.map

package/dist/doubles/transaction-ports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transaction-ports.d.ts","sourceRoot":"","sources":["../../src/doubles/transaction-ports.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,WAAW,EAEhB,KAAK,YAAY,EAGlB,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EACV,QAAQ,EAER,WAAW,EACX,eAAe,EACf,gBAAgB,EACjB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC,MAAM,WAAW,mBAAoB,SAAQ,WAAW;IACtD,iDAAiD;IACjD,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,CAAC;IACxB,sDAAsD;IACtD,QAAQ,CAAC,GAAG,EAAE,aAAa,CAAC;QAAE,MAAM,EAAE,SAAS,GAAG,SAAS,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC5E;;;OAGG;IACH,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;CAC9B;AAED;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,QAAO,mBAsC1C,CAAC;AAEF,MAAM,WAAW,uBAAwB,SAAQ,eAAe;IAC9D,6DAA6D;IAC7D,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;CACnD;AAED;;;GAGG;AACH,eAAO,MAAM,2BAA2B,QAAO,uBAc9C,CAAC;AAEF,MAAM,WAAW,iBAAkB,SAAQ,QAAQ;IACjD,uCAAuC;IACvC,QAAQ,CAAC,SAAS,EAAE,WAAW,EAAE,CAAC;IAClC;;;;;OAKG;IACH,OAAO,CAAC,KAAK,EAAE,WAAW,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,YAAY,CAAC,CAAC;IAC/D,wEAAwE;IACxE,eAAe,IAAI,IAAI,CAAC;CACzB;AAED;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,QAAO,iBA4CxC,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,mBAAmB;IAI5B,0DAA0D;oBAC1C,MAAM,KAAG,gBAAgB;qBAS3B,SAAS;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,EAAE;CAOjE,CAAC"}

package/dist/doubles/transaction-ports.js

@@ -0,0 +1,145 @@
+import { EntifixConnError, EntifixLockError, matchesEventPattern } from '@entifix/core';
+import { Effect } from 'effect';
+/**
+ * In-memory {@link LockService}. Acquisition is immediate and uncontended
+ * unless {@link InMemoryLockService.contendOn} says otherwise, and `release`
+ * only frees a lock whose token matches — the compare-and-delete rule the Redis
+ * adapter enforces with a Lua script.
+ */ export const makeInMemoryLockService = ()=>{
+    const tokens = new Map();
+    const contended = new Set();
+    const log = [];
+    let counter = 0;
+    return {
+        acquire: (key)=>Effect.suspend(()=>{
+                if (contended.has(key) || tokens.has(key)) {
+                    return Effect.fail(new EntifixLockError(`Could not acquire lock "${key}"`, undefined, {
+                        key
+                    }));
+                }
+                const token = `token-${counter += 1}`;
+                tokens.set(key, token);
+                log.push({
+                    action: 'acquire',
+                    key
+                });
+                return Effect.succeed({
+                    key,
+                    token
+                });
+            }),
+        release: (handle)=>Effect.sync(()=>{
+                if (tokens.get(handle.key) === handle.token) {
+                    tokens.delete(handle.key);
+                    log.push({
+                        action: 'release',
+                        key: handle.key
+                    });
+                }
+            }),
+        get held () {
+            return [
+                ...tokens.keys()
+            ];
+        },
+        get log () {
+            return log;
+        },
+        contendOn: (key)=>{
+            contended.add(key);
+        }
+    };
+};
+/**
+ * In-memory {@link SequenceService} — a plain counter per name. Atomicity is
+ * what the Redis `INCR` adapter buys; single-threaded JS gives it for free here.
+ */ export const makeInMemorySequenceService = ()=>{
+    const sequences = new Map();
+    return {
+        next: (name)=>Effect.sync(()=>{
+                var _sequences_get;
+                const next = ((_sequences_get = sequences.get(name)) != null ? _sequences_get : 0) + 1;
+                sequences.set(name, next);
+                return next;
+            }),
+        get values () {
+            return Object.fromEntries(sequences);
+        }
+    };
+};
+/**
+ * In-memory {@link EventBus} that records what was published rather than
+ * asserting on it. Prefer reading `bus.published` in a test over a mock's call
+ * assertions: the expectation then reads as state, not as a spy protocol.
+ */ export const makeRecordingEventBus = ()=>{
+    const published = [];
+    const handlers = [];
+    let failNext = false;
+    return {
+        publish: (event)=>Effect.suspend(()=>{
+                if (failNext) {
+                    failNext = false;
+                    return Effect.fail(new EntifixConnError('Event bus unavailable', undefined, {
+                        eventId: event.id
+                    }));
+                }
+                published.push(event);
+                return Effect.void;
+            }),
+        subscribe: (subscription, handle)=>Effect.sync(()=>{
+                // Only the pattern is retained: queue durability and the delivery
+                // ceiling are broker facts with no in-memory analogue, and faking them
+                // would assert against the double rather than against a broker.
+                handlers.push({
+                    pattern: subscription.pattern,
+                    handle
+                });
+            }),
+        deliver: (event)=>Effect.forEach(handlers.filter(({ pattern })=>matchesEventPattern(pattern, event.name)), ({ handle })=>handle(event), {
+                discard: true
+            }),
+        get published () {
+            return published;
+        },
+        failNextPublish: ()=>{
+            failNext = true;
+        }
+    };
+};
+/**
+ * An in-memory {@link TransactionInbox}, one per consumer, over a shared claim
+ * set.
+ *
+ * Sharing the set across the inboxes one factory hands out is what makes the
+ * contract's "one consumer cannot consume another's claim" case a real
+ * assertion, rather than one the double satisfies by only ever having seen a
+ * single consumer.
+ */ export const makeInMemoryInboxes = ()=>{
+    const claimed = new Set();
+    return {
+        /** An inbox for `consumer`, over the shared claim set. */ for: (consumer)=>({
+                claim: (eventId)=>Effect.sync(()=>{
+                        const key = JSON.stringify([
+                            consumer,
+                            eventId
+                        ]);
+                        if (claimed.has(key)) return 'duplicate';
+                        claimed.add(key);
+                        return 'claimed';
+                    })
+            }),
+        get claims () {
+            return [
+                ...claimed
+            ].map((key)=>{
+                const [consumer, eventId] = JSON.parse(key);
+                return {
+                    consumer,
+                    eventId
+                };
+            });
+        }
+    };
+};
+
+//# sourceMappingURL=transaction-ports.js.map

package/dist/doubles/transaction-ports.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/doubles/transaction-ports.ts"],"sourcesContent":["import {\n  type DomainEvent,\n  EntifixConnError,\n  type EntifixError,\n  EntifixLockError,\n  matchesEventPattern,\n} from '@entifix/core';\nimport type {\n  EventBus,\n  LockHandle,\n  LockService,\n  SequenceService,\n  TransactionInbox,\n} from '@entifix/transactions';\nimport { Effect } from 'effect';\n\nexport interface InMemoryLockService extends LockService {\n  /** Keys currently held, in acquisition order. */\n  readonly held: string[];\n  /** Every acquire/release in the order it happened. */\n  readonly log: ReadonlyArray<{ action: 'acquire' | 'release'; key: string }>;\n  /**\n   * Marks `key` as already taken by someone else, so the next `acquire` fails\n   * with {@link EntifixLockError} — the 409 path of the transaction facade.\n   */\n  contendOn(key: string): void;\n}\n\n/**\n * In-memory {@link LockService}. Acquisition is immediate and uncontended\n * unless {@link InMemoryLockService.contendOn} says otherwise, and `release`\n * only frees a lock whose token matches — the compare-and-delete rule the Redis\n * adapter enforces with a Lua script.\n */\nexport const makeInMemoryLockService = (): InMemoryLockService => {\n  const tokens = new Map<string, string>();\n  const contended = new Set<string>();\n  const log: Array<{ action: 'acquire' | 'release'; key: string }> = [];\n  let counter = 0;\n\n  return {\n    acquire: key =>\n      Effect.suspend(() => {\n        if (contended.has(key) || tokens.has(key)) {\n          return Effect.fail(\n            new EntifixLockError(`Could not acquire lock \"${key}\"`, undefined, {\n              key,\n            }),\n          );\n        }\n        const token = `token-${(counter += 1)}`;\n        tokens.set(key, token);\n        log.push({ action: 'acquire', key });\n        return Effect.succeed({ key, token });\n      }),\n    release: (handle: LockHandle) =>\n      Effect.sync(() => {\n        if (tokens.get(handle.key) === handle.token) {\n          tokens.delete(handle.key);\n          log.push({ action: 'release', key: handle.key });\n        }\n      }),\n    get held() {\n      return [...tokens.keys()];\n    },\n    get log() {\n      return log;\n    },\n    contendOn: key => {\n      contended.add(key);\n    },\n  };\n};\n\nexport interface InMemorySequenceService extends SequenceService {\n  /** The current value of every sequence drawn from so far. */\n  readonly values: Readonly<Record<string, number>>;\n}\n\n/**\n * In-memory {@link SequenceService} — a plain counter per name. Atomicity is\n * what the Redis `INCR` adapter buys; single-threaded JS gives it for free here.\n */\nexport const makeInMemorySequenceService = (): InMemorySequenceService => {\n  const sequences = new Map<string, number>();\n\n  return {\n    next: name =>\n      Effect.sync(() => {\n        const next = (sequences.get(name) ?? 0) + 1;\n        sequences.set(name, next);\n        return next;\n      }),\n    get values() {\n      return Object.fromEntries(sequences);\n    },\n  };\n};\n\nexport interface RecordingEventBus extends EventBus {\n  /** Every event published, in order. */\n  readonly published: DomainEvent[];\n  /**\n   * Pushes an event to the subscribers whose pattern matches it, as a topic\n   * exchange would. Deliberately not \"to all subscribers\": routing is the\n   * broker's job in production, so a double that ignored it would let a\n   * consumer pass its tests while receiving traffic it never bound to.\n   */\n  deliver(event: DomainEvent): Effect.Effect<void, EntifixError>;\n  /** Makes the next `publish` fail, for the broker-unavailable branch. */\n  failNextPublish(): void;\n}\n\n/**\n * In-memory {@link EventBus} that records what was published rather than\n * asserting on it. Prefer reading `bus.published` in a test over a mock's call\n * assertions: the expectation then reads as state, not as a spy protocol.\n */\nexport const makeRecordingEventBus = (): RecordingEventBus => {\n  const published: DomainEvent[] = [];\n  const handlers: Array<{\n    pattern: string;\n    handle: (event: DomainEvent) => Effect.Effect<void, EntifixError>;\n  }> = [];\n  let failNext = false;\n\n  return {\n    publish: event =>\n      Effect.suspend(() => {\n        if (failNext) {\n          failNext = false;\n          return Effect.fail(\n            new EntifixConnError('Event bus unavailable', undefined, {\n              eventId: event.id,\n            }),\n          );\n        }\n        published.push(event);\n        return Effect.void;\n      }),\n    subscribe: (subscription, handle) =>\n      Effect.sync(() => {\n        // Only the pattern is retained: queue durability and the delivery\n        // ceiling are broker facts with no in-memory analogue, and faking them\n        // would assert against the double rather than against a broker.\n        handlers.push({ pattern: subscription.pattern, handle });\n      }),\n    deliver: event =>\n      Effect.forEach(\n        handlers.filter(({ pattern }) =>\n          matchesEventPattern(pattern, event.name),\n        ),\n        ({ handle }) => handle(event),\n        { discard: true },\n      ),\n    get published() {\n      return published;\n    },\n    failNextPublish: () => {\n      failNext = true;\n    },\n  };\n};\n\n/**\n * An in-memory {@link TransactionInbox}, one per consumer, over a shared claim\n * set.\n *\n * Sharing the set across the inboxes one factory hands out is what makes the\n * contract's \"one consumer cannot consume another's claim\" case a real\n * assertion, rather than one the double satisfies by only ever having seen a\n * single consumer.\n */\nexport const makeInMemoryInboxes = () => {\n  const claimed = new Set<string>();\n\n  return {\n    /** An inbox for `consumer`, over the shared claim set. */\n    for: (consumer: string): TransactionInbox => ({\n      claim: eventId =>\n        Effect.sync(() => {\n          const key = JSON.stringify([consumer, eventId]);\n          if (claimed.has(key)) return 'duplicate' as const;\n          claimed.add(key);\n          return 'claimed' as const;\n        }),\n    }),\n    get claims(): readonly { consumer: string; eventId: string }[] {\n      return [...claimed].map(key => {\n        const [consumer, eventId] = JSON.parse(key) as [string, string];\n        return { consumer, eventId };\n      });\n    },\n  };\n};\n"],"names":["EntifixConnError","EntifixLockError","matchesEventPattern","Effect","makeInMemoryLockService","tokens","Map","contended","Set","log","counter","acquire","key","suspend","has","fail","undefined","token","set","push","action","succeed","release","handle","sync","get","delete","held","keys","contendOn","add","makeInMemorySequenceService","sequences","next","name","values","Object","fromEntries","makeRecordingEventBus","published","handlers","failNext","publish","event","eventId","id","void","subscribe","subscription","pattern","deliver","forEach","filter","discard","failNextPublish","makeInMemoryInboxes","claimed","for","consumer","claim","JSON","stringify","claims","map","parse"],"mappings":"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"}

package/dist/drivers/fake-amqp.d.ts

@@ -0,0 +1,91 @@
+/**
+ * A fake of the amqplib channel, not of the {@link EventBus} port.
+ *
+ * `makeAmqpEventBus` runs on top of it, so the envelope framing, the
+ * `prefetch(1)` the saga tracker depends on, and the ack/nack policy are
+ * all exercised for real.
+ */
+export interface FakeAmqpMessage {
+    content: Buffer;
+}
+export interface FakeAmqpChannel {
+    /** Everything published, decoded from the wire. */
+    readonly published: ReadonlyArray<{
+        exchange: string;
+        routingKey: string;
+        body: unknown;
+    }>;
+    /**
+     * Every queue binding the adapter asked for. Recorded because the exchange is
+     * a topic now: the pattern a subscriber binds is the whole of its routing, so
+     * a fake that swallowed it would let a wrong binding pass every test.
+     */
+    readonly bindings: ReadonlyArray<{
+        queue: string;
+        exchange: string;
+        pattern: string;
+    }>;
+    /**
+     * Every exchange the adapter declared, with its type. Recorded because the
+     * dead-letter exchange is `direct` while the event exchange is `topic`, and a
+     * broker will not retype an existing exchange — declaring the wrong type is a
+     * failure that only appears against a real broker.
+     */
+    readonly exchanges: ReadonlyArray<{
+        exchange: string;
+        type: string;
+        options: Record<string, unknown> | undefined;
+    }>;
+    /**
+     * Every queue the adapter declared, with the arguments it declared it with.
+     * The arguments *are* the delivery policy — `x-queue-type`,
+     * `x-delivery-limit`, `x-dead-letter-exchange` — so a fake that swallowed
+     * them would let a queue with no retry ceiling and no dead-letter path pass
+     * every test, which is the exact defect ADR 0030 exists to close.
+     */
+    readonly queues: ReadonlyArray<{
+        queue: string;
+        options: Record<string, unknown> | undefined;
+    }>;
+    /** Messages acked, so the success policy can be asserted. */
+    readonly acked: FakeAmqpMessage[];
+    /**
+     * Messages nacked, **with their flags**. `requeue` is the whole distinction
+     * between a transient failure the broker should retry and a poison message it
+     * should quarantine at once, so recording only that a nack happened is how
+     * "dead-letters a failed message" stayed a passing test for a bus that
+     * discarded it.
+     */
+    readonly nacked: ReadonlyArray<{
+        message: FakeAmqpMessage;
+        allUpTo: boolean;
+        requeue: boolean;
+    }>;
+    /** The prefetch the adapter asked for — 1, or the fold races. */
+    readonly prefetchCount: number | undefined;
+    /**
+     * The consumer tags cancelled, in order.
+     *
+     * Recorded rather than merely accepted because a graceful shutdown's first
+     * phase *is* the cancel (ADR 0030): a connector that dropped the tag on the
+     * floor would pass every test while leaving the broker delivering into a
+     * process that is closing its connection.
+     */
+    readonly cancelled: readonly string[];
+    /**
+     * Pushes a message to the consumers whose binding matches it, as the broker
+     * would. The routing key defaults to the envelope's own `meta.event.name`,
+     * which is what the adapter publishes with.
+     */
+    deliver(body: unknown, routingKey?: string): Promise<void>;
+    /** Pushes a raw payload, for malformed-message paths. */
+    deliverRaw(payload: string): Promise<void>;
+    /** Simulates the broker cancelling the consumer (amqplib delivers `null`). */
+    deliverCancellation(): Promise<void>;
+    /** Makes every subsequent channel call throw/reject with `error`. */
+    failWith(error: unknown): void;
+    /** The object to pass where an amqplib `Channel` is expected. */
+    readonly channel: unknown;
+}
+export declare const makeFakeAmqpChannel: () => FakeAmqpChannel;
+//# sourceMappingURL=fake-amqp.d.ts.map

package/dist/drivers/fake-amqp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fake-amqp.d.ts","sourceRoot":"","sources":["../../src/drivers/fake-amqp.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AAEH,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,eAAe;IAC9B,mDAAmD;IACnD,QAAQ,CAAC,SAAS,EAAE,aAAa,CAAC;QAChC,QAAQ,EAAE,MAAM,CAAC;QACjB,UAAU,EAAE,MAAM,CAAC;QACnB,IAAI,EAAE,OAAO,CAAC;KACf,CAAC,CAAC;IACH;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC;QAC/B,KAAK,EAAE,MAAM,CAAC;QACd,QAAQ,EAAE,MAAM,CAAC;QACjB,OAAO,EAAE,MAAM,CAAC;KACjB,CAAC,CAAC;IACH;;;;;OAKG;IACH,QAAQ,CAAC,SAAS,EAAE,aAAa,CAAC;QAChC,QAAQ,EAAE,MAAM,CAAC;QACjB,IAAI,EAAE,MAAM,CAAC;QACb,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAAC;KAC9C,CAAC,CAAC;IACH;;;;;;OAMG;IACH,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC;QAC7B,KAAK,EAAE,MAAM,CAAC;QACd,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAAC;KAC9C,CAAC,CAAC;IACH,6DAA6D;IAC7D,QAAQ,CAAC,KAAK,EAAE,eAAe,EAAE,CAAC;IAClC;;;;;;OAMG;IACH,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC;QAC7B,OAAO,EAAE,eAAe,CAAC;QACzB,OAAO,EAAE,OAAO,CAAC;QACjB,OAAO,EAAE,OAAO,CAAC;KAClB,CAAC,CAAC;IACH,iEAAiE;IACjE,QAAQ,CAAC,aAAa,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3C;;;;;;;OAOG;IACH,QAAQ,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;IACtC;;;;OAIG;IACH,OAAO,CAAC,IAAI,EAAE,OAAO,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3D,yDAAyD;IACzD,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3C,8EAA8E;IAC9E,mBAAmB,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACrC,qEAAqE;IACrE,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAAC;IAC/B,iEAAiE;IACjE,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC3B;AASD,eAAO,MAAM,mBAAmB,QAAO,eA0KtC,CAAC"}

package/dist/drivers/fake-amqp.js

@@ -0,0 +1,164 @@
+import { matchesEventPattern } from '@entifix/core';
+/** The routing key a body would have been published with. */ const routingKeyOf = (body)=>{
+    var _body_meta;
+    const event = body == null ? void 0 : (_body_meta = body.meta) == null ? void 0 : _body_meta.event;
+    return typeof (event == null ? void 0 : event.name) === 'string' ? event.name : '';
+};
+export const makeFakeAmqpChannel = ()=>{
+    const published = [];
+    const bindings = [];
+    const exchanges = [];
+    const queues = [];
+    const acked = [];
+    const nacked = [];
+    let consumer;
+    const cancelled = [];
+    let consumerTags = 0;
+    let boundQueue;
+    let prefetchCount;
+    let failure;
+    const guard = ()=>{
+        if (failure !== undefined) throw failure;
+    };
+    const channel = {
+        publish: (exchange, routingKey, content)=>{
+            guard();
+            published.push({
+                exchange,
+                routingKey,
+                body: JSON.parse(content.toString())
+            });
+            return true;
+        },
+        prefetch: async (count)=>{
+            guard();
+            prefetchCount = count;
+        },
+        assertExchange: async (exchange, type, options)=>{
+            guard();
+            exchanges.push({
+                exchange,
+                type,
+                options
+            });
+            return {
+                exchange
+            };
+        },
+        assertQueue: async (queue, options)=>{
+            guard();
+            const name = queue === '' ? 'amq.gen-fake' : queue;
+            queues.push({
+                queue: name,
+                options
+            });
+            return {
+                queue: name
+            };
+        },
+        bindQueue: async (queue, exchange, pattern)=>{
+            guard();
+            bindings.push({
+                queue,
+                exchange,
+                pattern
+            });
+        },
+        consume: async (queue, handler)=>{
+            guard();
+            consumer = handler;
+            boundQueue = queue;
+            // A fresh tag per `consume`, so a reconnect's re-bind is distinguishable
+            // from the binding it replaced — the connector cancels what it currently
+            // holds, and a constant tag would hide it cancelling a stale one.
+            consumerTags += 1;
+            return {
+                consumerTag: `fake-consumer-${consumerTags}`
+            };
+        },
+        cancel: async (consumerTag)=>{
+            guard();
+            cancelled.push(consumerTag);
+            consumer = undefined;
+        },
+        ack: (message)=>{
+            acked.push(message);
+        },
+        nack: (message, allUpTo, requeue)=>{
+            nacked.push({
+                message,
+                allUpTo,
+                requeue
+            });
+        },
+        close: async ()=>{
+            guard();
+        }
+    };
+    /**
+   * The adapter acks/nacks from inside a floating promise chain, so a delivery
+   * is only settled once the microtask queue drains.
+   */ const settle = ()=>new Promise((resolve)=>setTimeout(resolve, 0));
+    /**
+   * Whether the consumer's queue is bound to a pattern matching `routingKey`.
+   * The broker decides this in production, so the fake has to as well — without
+   * it every subscriber sees every message and the topic exchange is untested.
+   */ const routes = (routingKey)=>bindings.some((binding)=>binding.queue === boundQueue && matchesEventPattern(binding.pattern, routingKey));
+    /**
+   * `routingKey === undefined` means "the broker already routed this" — used by
+   * the malformed-payload path, where the message reached the queue and it is
+   * the *content* that is wrong.
+   */ const push = async (payload, routingKey)=>{
+        if (consumer === undefined) {
+            throw new Error('fake amqp: nothing subscribed yet');
+        }
+        if (routingKey !== undefined && !routes(routingKey)) {
+            return;
+        }
+        consumer({
+            content: Buffer.from(payload)
+        });
+        await settle();
+    };
+    return {
+        get published () {
+            return published;
+        },
+        get bindings () {
+            return bindings;
+        },
+        get exchanges () {
+            return exchanges;
+        },
+        get queues () {
+            return queues;
+        },
+        get acked () {
+            return acked;
+        },
+        get nacked () {
+            return nacked;
+        },
+        get prefetchCount () {
+            return prefetchCount;
+        },
+        get cancelled () {
+            return cancelled;
+        },
+        deliver: (body, routingKey)=>push(JSON.stringify(body), routingKey != null ? routingKey : routingKeyOf(body)),
+        deliverRaw: (payload)=>push(payload, undefined),
+        deliverCancellation: async ()=>{
+            if (consumer === undefined) {
+                throw new Error('fake amqp: nothing subscribed yet');
+            }
+            consumer(null);
+            await settle();
+        },
+        failWith: (error)=>{
+            failure = error;
+        },
+        channel
+    };
+};
+
+//# sourceMappingURL=fake-amqp.js.map

package/dist/drivers/fake-amqp.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/drivers/fake-amqp.ts"],"sourcesContent":["import { matchesEventPattern } from '@entifix/core';\n\n/**\n * A fake of the amqplib channel, not of the {@link EventBus} port.\n *\n * `makeAmqpEventBus` runs on top of it, so the envelope framing, the\n * `prefetch(1)` the saga tracker depends on, and the ack/nack policy are\n * all exercised for real.\n */\n\nexport interface FakeAmqpMessage {\n  content: Buffer;\n}\n\nexport interface FakeAmqpChannel {\n  /** Everything published, decoded from the wire. */\n  readonly published: ReadonlyArray<{\n    exchange: string;\n    routingKey: string;\n    body: unknown;\n  }>;\n  /**\n   * Every queue binding the adapter asked for. Recorded because the exchange is\n   * a topic now: the pattern a subscriber binds is the whole of its routing, so\n   * a fake that swallowed it would let a wrong binding pass every test.\n   */\n  readonly bindings: ReadonlyArray<{\n    queue: string;\n    exchange: string;\n    pattern: string;\n  }>;\n  /**\n   * Every exchange the adapter declared, with its type. Recorded because the\n   * dead-letter exchange is `direct` while the event exchange is `topic`, and a\n   * broker will not retype an existing exchange — declaring the wrong type is a\n   * failure that only appears against a real broker.\n   */\n  readonly exchanges: ReadonlyArray<{\n    exchange: string;\n    type: string;\n    options: Record<string, unknown> | undefined;\n  }>;\n  /**\n   * Every queue the adapter declared, with the arguments it declared it with.\n   * The arguments *are* the delivery policy — `x-queue-type`,\n   * `x-delivery-limit`, `x-dead-letter-exchange` — so a fake that swallowed\n   * them would let a queue with no retry ceiling and no dead-letter path pass\n   * every test, which is the exact defect ADR 0030 exists to close.\n   */\n  readonly queues: ReadonlyArray<{\n    queue: string;\n    options: Record<string, unknown> | undefined;\n  }>;\n  /** Messages acked, so the success policy can be asserted. */\n  readonly acked: FakeAmqpMessage[];\n  /**\n   * Messages nacked, **with their flags**. `requeue` is the whole distinction\n   * between a transient failure the broker should retry and a poison message it\n   * should quarantine at once, so recording only that a nack happened is how\n   * \"dead-letters a failed message\" stayed a passing test for a bus that\n   * discarded it.\n   */\n  readonly nacked: ReadonlyArray<{\n    message: FakeAmqpMessage;\n    allUpTo: boolean;\n    requeue: boolean;\n  }>;\n  /** The prefetch the adapter asked for — 1, or the fold races. */\n  readonly prefetchCount: number | undefined;\n  /**\n   * The consumer tags cancelled, in order.\n   *\n   * Recorded rather than merely accepted because a graceful shutdown's first\n   * phase *is* the cancel (ADR 0030): a connector that dropped the tag on the\n   * floor would pass every test while leaving the broker delivering into a\n   * process that is closing its connection.\n   */\n  readonly cancelled: readonly string[];\n  /**\n   * Pushes a message to the consumers whose binding matches it, as the broker\n   * would. The routing key defaults to the envelope's own `meta.event.name`,\n   * which is what the adapter publishes with.\n   */\n  deliver(body: unknown, routingKey?: string): Promise<void>;\n  /** Pushes a raw payload, for malformed-message paths. */\n  deliverRaw(payload: string): Promise<void>;\n  /** Simulates the broker cancelling the consumer (amqplib delivers `null`). */\n  deliverCancellation(): Promise<void>;\n  /** Makes every subsequent channel call throw/reject with `error`. */\n  failWith(error: unknown): void;\n  /** The object to pass where an amqplib `Channel` is expected. */\n  readonly channel: unknown;\n}\n\n/** The routing key a body would have been published with. */\nconst routingKeyOf = (body: unknown): string => {\n  const event = (body as { meta?: { event?: { name?: unknown } } })?.meta\n    ?.event;\n  return typeof event?.name === 'string' ? event.name : '';\n};\n\nexport const makeFakeAmqpChannel = (): FakeAmqpChannel => {\n  const published: Array<{\n    exchange: string;\n    routingKey: string;\n    body: unknown;\n  }> = [];\n  const bindings: Array<{ queue: string; exchange: string; pattern: string }> =\n    [];\n  const exchanges: Array<{\n    exchange: string;\n    type: string;\n    options: Record<string, unknown> | undefined;\n  }> = [];\n  const queues: Array<{\n    queue: string;\n    options: Record<string, unknown> | undefined;\n  }> = [];\n  const acked: FakeAmqpMessage[] = [];\n  const nacked: Array<{\n    message: FakeAmqpMessage;\n    allUpTo: boolean;\n    requeue: boolean;\n  }> = [];\n  let consumer: ((message: FakeAmqpMessage | null) => void) | undefined;\n  const cancelled: string[] = [];\n  let consumerTags = 0;\n  let boundQueue: string | undefined;\n  let prefetchCount: number | undefined;\n  let failure: unknown;\n\n  const guard = () => {\n    if (failure !== undefined) throw failure;\n  };\n\n  const channel = {\n    publish: (exchange: string, routingKey: string, content: Buffer) => {\n      guard();\n      published.push({\n        exchange,\n        routingKey,\n        body: JSON.parse(content.toString()) as unknown,\n      });\n      return true;\n    },\n    prefetch: async (count: number) => {\n      guard();\n      prefetchCount = count;\n    },\n    assertExchange: async (\n      exchange: string,\n      type: string,\n      options?: Record<string, unknown>,\n    ) => {\n      guard();\n      exchanges.push({ exchange, type, options });\n      return { exchange };\n    },\n    assertQueue: async (queue: string, options?: Record<string, unknown>) => {\n      guard();\n      const name = queue === '' ? 'amq.gen-fake' : queue;\n      queues.push({ queue: name, options });\n      return { queue: name };\n    },\n    bindQueue: async (queue: string, exchange: string, pattern: string) => {\n      guard();\n      bindings.push({ queue, exchange, pattern });\n    },\n    consume: async (\n      queue: string,\n      handler: (message: FakeAmqpMessage | null) => void,\n    ) => {\n      guard();\n      consumer = handler;\n      boundQueue = queue;\n      // A fresh tag per `consume`, so a reconnect's re-bind is distinguishable\n      // from the binding it replaced — the connector cancels what it currently\n      // holds, and a constant tag would hide it cancelling a stale one.\n      consumerTags += 1;\n      return { consumerTag: `fake-consumer-${consumerTags}` };\n    },\n    cancel: async (consumerTag: string) => {\n      guard();\n      cancelled.push(consumerTag);\n      consumer = undefined;\n    },\n    ack: (message: FakeAmqpMessage) => {\n      acked.push(message);\n    },\n    nack: (message: FakeAmqpMessage, allUpTo: boolean, requeue: boolean) => {\n      nacked.push({ message, allUpTo, requeue });\n    },\n    close: async () => {\n      guard();\n    },\n  };\n\n  /**\n   * The adapter acks/nacks from inside a floating promise chain, so a delivery\n   * is only settled once the microtask queue drains.\n   */\n  const settle = () => new Promise<void>(resolve => setTimeout(resolve, 0));\n\n  /**\n   * Whether the consumer's queue is bound to a pattern matching `routingKey`.\n   * The broker decides this in production, so the fake has to as well — without\n   * it every subscriber sees every message and the topic exchange is untested.\n   */\n  const routes = (routingKey: string) =>\n    bindings.some(\n      binding =>\n        binding.queue === boundQueue &&\n        matchesEventPattern(binding.pattern, routingKey),\n    );\n\n  /**\n   * `routingKey === undefined` means \"the broker already routed this\" — used by\n   * the malformed-payload path, where the message reached the queue and it is\n   * the *content* that is wrong.\n   */\n  const push = async (payload: string, routingKey: string | undefined) => {\n    if (consumer === undefined) {\n      throw new Error('fake amqp: nothing subscribed yet');\n    }\n    if (routingKey !== undefined && !routes(routingKey)) {\n      return;\n    }\n    consumer({ content: Buffer.from(payload) });\n    await settle();\n  };\n\n  return {\n    get published() {\n      return published;\n    },\n    get bindings() {\n      return bindings;\n    },\n    get exchanges() {\n      return exchanges;\n    },\n    get queues() {\n      return queues;\n    },\n    get acked() {\n      return acked;\n    },\n    get nacked() {\n      return nacked;\n    },\n    get prefetchCount() {\n      return prefetchCount;\n    },\n    get cancelled() {\n      return cancelled;\n    },\n    deliver: (body, routingKey) =>\n      push(JSON.stringify(body), routingKey ?? routingKeyOf(body)),\n    deliverRaw: payload => push(payload, undefined),\n    deliverCancellation: async () => {\n      if (consumer === undefined) {\n        throw new Error('fake amqp: nothing subscribed yet');\n      }\n      consumer(null);\n      await settle();\n    },\n    failWith: error => {\n      failure = error;\n    },\n    channel,\n  };\n};\n"],"names":["matchesEventPattern","routingKeyOf","body","event","meta","name","makeFakeAmqpChannel","published","bindings","exchanges","queues","acked","nacked","consumer","cancelled","consumerTags","boundQueue","prefetchCount","failure","guard","undefined","channel","publish","exchange","routingKey","content","push","JSON","parse","toString","prefetch","count","assertExchange","type","options","assertQueue","queue","bindQueue","pattern","consume","handler","consumerTag","cancel","ack","message","nack","allUpTo","requeue","close","settle","Promise","resolve","setTimeout","routes","some","binding","payload","Error","Buffer","from","deliver","stringify","deliverRaw","deliverCancellation","failWith","error"],"mappings":"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"}

package/dist/drivers/fake-mongo.d.ts

@@ -0,0 +1,59 @@
+/**
+ * A fake of the mongodb driver, not of the repository port.
+ *
+ * It sits one level *below* `makeMongoRepository`, so the adapter's own code —
+ * the filter translation, the projection, the upsert rule, the error mapping —
+ * actually runs and is measured by coverage. A fake at the port level would
+ * skip all of it.
+ *
+ * Only the surface the adapter uses is implemented; anything else is a
+ * deliberate `TypeError` rather than a silent no-op.
+ */
+type Document = Record<string, unknown>;
+export interface FakeMongoCollection {
+    /** The documents currently stored, as the driver would return them. */
+    readonly documents: Document[];
+}
+export interface FakeMongoDb {
+    /** Replaces a collection's contents. */
+    seed(collection: string, documents: Document[]): void;
+    /** Reads a collection's current contents. */
+    read(collection: string): Document[];
+    /**
+     * Makes every subsequent driver call reject with `error`, so the adapter's
+     * `EntifixConnError` mapping is reachable. Pass `undefined` to restore.
+     */
+    failWith(error: unknown): void;
+    /**
+     * Makes only `operation` reject, leaving the rest working — the way a read
+     * that succeeds and a count that then fails reaches a distinct error branch.
+     */
+    failOn(operation: string, error: unknown): void;
+    /** Every operation performed, for assertions about what the adapter did. */
+    readonly operations: ReadonlyArray<{
+        collection: string;
+        op: string;
+    }>;
+    /**
+     * Opens a session whose `withTransaction` rolls the whole store back when its
+     * body throws. What a service hands to `client.startSession()`; see the
+     * implementation for why it is atomicity and not isolation.
+     */
+    startSession(): {
+        withTransaction(body: () => Promise<unknown>): Promise<unknown>;
+        endSession(): Promise<void>;
+        readonly hasEnded: boolean;
+    };
+    /** The object to hand to `makeMongoRepository` in place of a real `Db`. */
+    readonly db: unknown;
+}
+/**
+ * Builds an in-memory stand-in for a mongodb `Db`.
+ *
+ * `db` is typed `unknown` on purpose: casting it at the call site keeps this
+ * package free of a hard dependency on the `mongodb` types while remaining
+ * honest that it is not a real driver.
+ */
+export declare const makeFakeMongoDb: (seed?: Record<string, Document[]>) => FakeMongoDb;
+export {};
+//# sourceMappingURL=fake-mongo.d.ts.map

package/dist/drivers/fake-mongo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fake-mongo.d.ts","sourceRoot":"","sources":["../../src/drivers/fake-mongo.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH,KAAK,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAuMxC,MAAM,WAAW,mBAAmB;IAClC,uEAAuE;IACvE,QAAQ,CAAC,SAAS,EAAE,QAAQ,EAAE,CAAC;CAChC;AAED,MAAM,WAAW,WAAW;IAC1B,wCAAwC;IACxC,IAAI,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,GAAG,IAAI,CAAC;IACtD,6CAA6C;IAC7C,IAAI,CAAC,UAAU,EAAE,MAAM,GAAG,QAAQ,EAAE,CAAC;IACrC;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAAC;IAC/B;;;OAGG;IACH,MAAM,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAAC;IAChD,4EAA4E;IAC5E,QAAQ,CAAC,UAAU,EAAE,aAAa,CAAC;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACvE;;;;OAIG;IACH,YAAY,IAAI;QACd,eAAe,CAAC,IAAI,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;QAChE,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;QAC5B,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;KAC5B,CAAC;IACF,2EAA2E;IAC3E,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAC;CACtB;AAED;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,GAC1B,OAAM,MAAM,CAAC,MAAM,EAAE,QAAQ,EAAE,CAAM,KACpC,WA0dF,CAAC"}