@relaybus/testing 0.4.0 → 0.5.0

package/dist/index.d.cts

@@ -1,4 +1,6 @@
 import { NewDelivery, EventEnvelope, EventStore, Clock, Transport, TransportMessageHandler } from '@relaybus/core';
+import { KafkaCodecContractOptions, RabbitMqCodecContractOptions } from './codec-contract.cjs';
+export { BodyComparison, CodecContractError, KafkaCapturedRecord, KafkaCodecCase, KafkaDeliveredRecord, KafkaWrittenRecord, RabbitMqCapturedMessage, RabbitMqCodecCase, RabbitMqDeliveredMessage, RabbitMqWrittenMessage, TestFramework, WireBytes, assertKafkaCodecCase, assertRabbitMqCodecCase, kafkaCodecMismatches, rabbitMqCodecMismatches, registerKafkaCodecContract, registerRabbitMqCodecContract } from './codec-contract.cjs';
 
 declare function at(offsetMs: number): Date;
 declare function createEnvelope(overrides?: Partial<EventEnvelope>): EventEnvelope;
@@ -66,10 +68,13 @@ declare class InMemoryTransport implements Transport {
     #private;
     readonly name: string;
     readonly published: PublishedMessage[];
+    /** Wire names (event type to name) that routes and catalogs declared; the transport sends events as they are. */
+    readonly declaredWireTypes: Record<string, string>;
     connected: boolean;
     closed: boolean;
     constructor(name?: string);
     connect(): Promise<void>;
+    declareWireTypes(wireTypes: Readonly<Record<string, string>>): () => void;
     /** Makes the next `count` publishes reject, simulating a broker outage. */
     failNextPublishes(count: number): void;
     publish(envelope: EventEnvelope, destination: string): Promise<void>;
@@ -83,145 +88,10 @@ declare class InMemoryTransport implements Transport {
     close(): Promise<void>;
 }
 
-/** How message bodies are compared: byte for byte, or as JSON regardless of key order and spacing. */
-type BodyComparison = 'bytes' | 'json';
-/** Bytes as text or bytes, as captured or encoded. */
-type WireBytes = string | Uint8Array;
-
-/** A record as captured from a topic: what an existing producer wrote. */
-interface KafkaCapturedRecord {
-    readonly topic: string;
-    /** Default 0. */
-    readonly partition?: number;
-    /** Default `'0'`. */
-    readonly offset?: string;
-    readonly key: WireBytes | null;
-    readonly value: WireBytes | null;
-    /** Default none. */
-    readonly headers?: Readonly<Record<string, WireBytes>>;
-    /** Epoch milliseconds in a string; compared only when the codec sets a timestamp. */
-    readonly timestamp?: string;
-}
-/** What a codec's `encode` returns: a `KafkaCodec` record. */
-interface KafkaWrittenRecord {
-    readonly key: WireBytes | null;
-    readonly value: WireBytes | null;
-    readonly headers: Readonly<Record<string, WireBytes | readonly WireBytes[]>>;
-    readonly timestamp?: string;
-}
-/** A record as a consumer hands it over: bytes for the key, the value and every header. */
-interface KafkaDeliveredRecord {
-    readonly topic: string;
-    readonly partition: number;
-    readonly offset: string;
-    readonly key: Buffer | null;
-    readonly value: Buffer | null;
-    readonly headers: Readonly<Record<string, Buffer>>;
-    readonly timestamp?: string;
-}
-/** One message of the format: the event and the record that carries it. */
-interface KafkaCodecCase {
-    readonly name: string;
-    readonly envelope: EventEnvelope;
-    readonly record: KafkaCapturedRecord;
-    /**
-     * The event decoding the record gives, when the wire does not carry all of `envelope` (for
-     * example a record written without a key). Default `envelope`.
-     */
-    readonly decoded?: EventEnvelope;
-    /**
-     * Checks one direction only: `'decode'` for a message only other producers write (for
-     * example one without an id, which relaybus would add), `'encode'` for one only other
-     * consumers read. Default both.
-     */
-    readonly only?: 'encode' | 'decode';
-}
-interface KafkaCodecContractOptions {
-    /** Writes an event: a codec's `encode`, or a transport's publish captured by an injected producer. */
-    readonly encode: (envelope: EventEnvelope) => KafkaWrittenRecord | Promise<KafkaWrittenRecord>;
-    /** Reads a record the way the transport does: `(record) => decodeKafkaRecord(codec, record)`. */
-    readonly decode: (record: KafkaDeliveredRecord) => EventEnvelope | Promise<EventEnvelope>;
-    readonly cases: readonly KafkaCodecCase[];
-    /** How values are compared. Default `'bytes'`. */
-    readonly compare?: BodyComparison;
-    /** Headers left out of the comparison, such as ones relaybus adds and other consumers ignore. */
-    readonly ignoreHeaders?: readonly string[];
-}
-/**
- * What differs between `testCase` and what the codec writes and reads, one line each: the key,
- * the value, the headers (a repeated header by its last value) and the timestamp of
- * `encode(envelope)`, and `decode(record)` against the expected event. Empty when they agree.
- */
-declare function kafkaCodecMismatches(options: KafkaCodecContractOptions, testCase: KafkaCodecCase): Promise<string[]>;
-/**
- * Registers one test per case asserting {@link kafkaCodecMismatches} finds nothing: a format of
- * existing producers and consumers is adopted only once relaybus writes and reads it exactly.
- */
+/** Registers one Vitest test per captured Kafka record (see `registerKafkaCodecContract`). */
 declare function kafkaCodecContract(name: string, options: KafkaCodecContractOptions): void;
-
-/** A message as captured from a queue: what an existing publisher wrote. */
-interface RabbitMqCapturedMessage {
-    readonly routingKey: string;
-    /**
-     * The message properties as publish options name them (`persistent`, `messageId`,
-     * `contentType`, `timestamp`, ...), without `headers`. Default none.
-     */
-    readonly properties?: Readonly<Record<string, unknown>>;
-    /** Default none. */
-    readonly headers?: Readonly<Record<string, unknown>>;
-    readonly body: WireBytes;
-}
-/** What a codec's `encode` returns: a `RabbitMqCodec` message. */
-interface RabbitMqWrittenMessage {
-    readonly content: Uint8Array;
-    /** The publish options: properties, and the headers under `headers`. */
-    readonly options: object;
-}
-/** A message as a consumer receives it. */
-interface RabbitMqDeliveredMessage {
-    readonly content: Buffer;
-    readonly fields: {
-        readonly routingKey: string;
-    };
-    readonly properties: Readonly<Record<string, unknown>> & {
-        readonly headers: Readonly<Record<string, unknown>>;
-    };
-}
-/** One message of the format: the event and the message that carries it. */
-interface RabbitMqCodecCase {
-    readonly name: string;
-    readonly envelope: EventEnvelope;
-    readonly message: RabbitMqCapturedMessage;
-    /** The event decoding the message gives, when the wire does not carry all of `envelope`. */
-    readonly decoded?: EventEnvelope;
-    /**
-     * Checks one direction only: `'decode'` for a message only other producers write (for
-     * example one without an id, which relaybus would add), `'encode'` for one only other
-     * consumers read. Default both.
-     */
-    readonly only?: 'encode' | 'decode';
-}
-interface RabbitMqCodecContractOptions {
-    /** Writes an event: a codec's `encode`. The routing key is the route's destination, not the codec's. */
-    readonly encode: (envelope: EventEnvelope) => RabbitMqWrittenMessage | Promise<RabbitMqWrittenMessage>;
-    /** Reads a message the way the transport does: `(message) => decodeRabbitMqMessage(codec, message)`. */
-    readonly decode: (message: RabbitMqDeliveredMessage) => EventEnvelope | Promise<EventEnvelope>;
-    readonly cases: readonly RabbitMqCodecCase[];
-    /** How bodies are compared. Default `'bytes'`. */
-    readonly compare?: BodyComparison;
-    /** Properties left out of the comparison, such as a `timestamp` that differs per send. */
-    readonly ignoreProperties?: readonly string[];
-    /** Headers left out of the comparison. */
-    readonly ignoreHeaders?: readonly string[];
-}
-/**
- * What differs between `testCase` and what the codec writes and reads, one line each: the
- * properties, headers and body of `encode(envelope)`, and `decode(message)` against the expected
- * event. Empty when they agree.
- */
-declare function rabbitMqCodecMismatches(options: RabbitMqCodecContractOptions, testCase: RabbitMqCodecCase): Promise<string[]>;
-/** Registers one test per case asserting {@link rabbitMqCodecMismatches} finds nothing. */
+/** Registers one Vitest test per captured RabbitMQ message (see `registerRabbitMqCodecContract`). */
 declare function rabbitMqCodecContract(name: string, options: RabbitMqCodecContractOptions): void;
 
-export { FakeClock, InMemoryTransport, at, createDelivery, createEnvelope, eventStoreContract, kafkaCodecContract, kafkaCodecMismatches, rabbitMqCodecContract, rabbitMqCodecMismatches };
-export type { BodyComparison, EventStoreContractOptions, KafkaCapturedRecord, KafkaCodecCase, KafkaCodecContractOptions, KafkaDeliveredRecord, KafkaWrittenRecord, PublishedMessage, RabbitMqCapturedMessage, RabbitMqCodecCase, RabbitMqCodecContractOptions, RabbitMqDeliveredMessage, RabbitMqWrittenMessage, WireBytes };
+export { FakeClock, InMemoryTransport, KafkaCodecContractOptions, RabbitMqCodecContractOptions, at, createDelivery, createEnvelope, eventStoreContract, kafkaCodecContract, rabbitMqCodecContract };
+export type { EventStoreContractOptions, PublishedMessage };

package/dist/index.d.ts

@@ -1,4 +1,6 @@
 import { NewDelivery, EventEnvelope, EventStore, Clock, Transport, TransportMessageHandler } from '@relaybus/core';
+import { KafkaCodecContractOptions, RabbitMqCodecContractOptions } from './codec-contract.js';
+export { BodyComparison, CodecContractError, KafkaCapturedRecord, KafkaCodecCase, KafkaDeliveredRecord, KafkaWrittenRecord, RabbitMqCapturedMessage, RabbitMqCodecCase, RabbitMqDeliveredMessage, RabbitMqWrittenMessage, TestFramework, WireBytes, assertKafkaCodecCase, assertRabbitMqCodecCase, kafkaCodecMismatches, rabbitMqCodecMismatches, registerKafkaCodecContract, registerRabbitMqCodecContract } from './codec-contract.js';
 
 declare function at(offsetMs: number): Date;
 declare function createEnvelope(overrides?: Partial<EventEnvelope>): EventEnvelope;
@@ -66,10 +68,13 @@ declare class InMemoryTransport implements Transport {
     #private;
     readonly name: string;
     readonly published: PublishedMessage[];
+    /** Wire names (event type to name) that routes and catalogs declared; the transport sends events as they are. */
+    readonly declaredWireTypes: Record<string, string>;
     connected: boolean;
     closed: boolean;
     constructor(name?: string);
     connect(): Promise<void>;
+    declareWireTypes(wireTypes: Readonly<Record<string, string>>): () => void;
     /** Makes the next `count` publishes reject, simulating a broker outage. */
     failNextPublishes(count: number): void;
     publish(envelope: EventEnvelope, destination: string): Promise<void>;
@@ -83,145 +88,10 @@ declare class InMemoryTransport implements Transport {
     close(): Promise<void>;
 }
 
-/** How message bodies are compared: byte for byte, or as JSON regardless of key order and spacing. */
-type BodyComparison = 'bytes' | 'json';
-/** Bytes as text or bytes, as captured or encoded. */
-type WireBytes = string | Uint8Array;
-
-/** A record as captured from a topic: what an existing producer wrote. */
-interface KafkaCapturedRecord {
-    readonly topic: string;
-    /** Default 0. */
-    readonly partition?: number;
-    /** Default `'0'`. */
-    readonly offset?: string;
-    readonly key: WireBytes | null;
-    readonly value: WireBytes | null;
-    /** Default none. */
-    readonly headers?: Readonly<Record<string, WireBytes>>;
-    /** Epoch milliseconds in a string; compared only when the codec sets a timestamp. */
-    readonly timestamp?: string;
-}
-/** What a codec's `encode` returns: a `KafkaCodec` record. */
-interface KafkaWrittenRecord {
-    readonly key: WireBytes | null;
-    readonly value: WireBytes | null;
-    readonly headers: Readonly<Record<string, WireBytes | readonly WireBytes[]>>;
-    readonly timestamp?: string;
-}
-/** A record as a consumer hands it over: bytes for the key, the value and every header. */
-interface KafkaDeliveredRecord {
-    readonly topic: string;
-    readonly partition: number;
-    readonly offset: string;
-    readonly key: Buffer | null;
-    readonly value: Buffer | null;
-    readonly headers: Readonly<Record<string, Buffer>>;
-    readonly timestamp?: string;
-}
-/** One message of the format: the event and the record that carries it. */
-interface KafkaCodecCase {
-    readonly name: string;
-    readonly envelope: EventEnvelope;
-    readonly record: KafkaCapturedRecord;
-    /**
-     * The event decoding the record gives, when the wire does not carry all of `envelope` (for
-     * example a record written without a key). Default `envelope`.
-     */
-    readonly decoded?: EventEnvelope;
-    /**
-     * Checks one direction only: `'decode'` for a message only other producers write (for
-     * example one without an id, which relaybus would add), `'encode'` for one only other
-     * consumers read. Default both.
-     */
-    readonly only?: 'encode' | 'decode';
-}
-interface KafkaCodecContractOptions {
-    /** Writes an event: a codec's `encode`, or a transport's publish captured by an injected producer. */
-    readonly encode: (envelope: EventEnvelope) => KafkaWrittenRecord | Promise<KafkaWrittenRecord>;
-    /** Reads a record the way the transport does: `(record) => decodeKafkaRecord(codec, record)`. */
-    readonly decode: (record: KafkaDeliveredRecord) => EventEnvelope | Promise<EventEnvelope>;
-    readonly cases: readonly KafkaCodecCase[];
-    /** How values are compared. Default `'bytes'`. */
-    readonly compare?: BodyComparison;
-    /** Headers left out of the comparison, such as ones relaybus adds and other consumers ignore. */
-    readonly ignoreHeaders?: readonly string[];
-}
-/**
- * What differs between `testCase` and what the codec writes and reads, one line each: the key,
- * the value, the headers (a repeated header by its last value) and the timestamp of
- * `encode(envelope)`, and `decode(record)` against the expected event. Empty when they agree.
- */
-declare function kafkaCodecMismatches(options: KafkaCodecContractOptions, testCase: KafkaCodecCase): Promise<string[]>;
-/**
- * Registers one test per case asserting {@link kafkaCodecMismatches} finds nothing: a format of
- * existing producers and consumers is adopted only once relaybus writes and reads it exactly.
- */
+/** Registers one Vitest test per captured Kafka record (see `registerKafkaCodecContract`). */
 declare function kafkaCodecContract(name: string, options: KafkaCodecContractOptions): void;
-
-/** A message as captured from a queue: what an existing publisher wrote. */
-interface RabbitMqCapturedMessage {
-    readonly routingKey: string;
-    /**
-     * The message properties as publish options name them (`persistent`, `messageId`,
-     * `contentType`, `timestamp`, ...), without `headers`. Default none.
-     */
-    readonly properties?: Readonly<Record<string, unknown>>;
-    /** Default none. */
-    readonly headers?: Readonly<Record<string, unknown>>;
-    readonly body: WireBytes;
-}
-/** What a codec's `encode` returns: a `RabbitMqCodec` message. */
-interface RabbitMqWrittenMessage {
-    readonly content: Uint8Array;
-    /** The publish options: properties, and the headers under `headers`. */
-    readonly options: object;
-}
-/** A message as a consumer receives it. */
-interface RabbitMqDeliveredMessage {
-    readonly content: Buffer;
-    readonly fields: {
-        readonly routingKey: string;
-    };
-    readonly properties: Readonly<Record<string, unknown>> & {
-        readonly headers: Readonly<Record<string, unknown>>;
-    };
-}
-/** One message of the format: the event and the message that carries it. */
-interface RabbitMqCodecCase {
-    readonly name: string;
-    readonly envelope: EventEnvelope;
-    readonly message: RabbitMqCapturedMessage;
-    /** The event decoding the message gives, when the wire does not carry all of `envelope`. */
-    readonly decoded?: EventEnvelope;
-    /**
-     * Checks one direction only: `'decode'` for a message only other producers write (for
-     * example one without an id, which relaybus would add), `'encode'` for one only other
-     * consumers read. Default both.
-     */
-    readonly only?: 'encode' | 'decode';
-}
-interface RabbitMqCodecContractOptions {
-    /** Writes an event: a codec's `encode`. The routing key is the route's destination, not the codec's. */
-    readonly encode: (envelope: EventEnvelope) => RabbitMqWrittenMessage | Promise<RabbitMqWrittenMessage>;
-    /** Reads a message the way the transport does: `(message) => decodeRabbitMqMessage(codec, message)`. */
-    readonly decode: (message: RabbitMqDeliveredMessage) => EventEnvelope | Promise<EventEnvelope>;
-    readonly cases: readonly RabbitMqCodecCase[];
-    /** How bodies are compared. Default `'bytes'`. */
-    readonly compare?: BodyComparison;
-    /** Properties left out of the comparison, such as a `timestamp` that differs per send. */
-    readonly ignoreProperties?: readonly string[];
-    /** Headers left out of the comparison. */
-    readonly ignoreHeaders?: readonly string[];
-}
-/**
- * What differs between `testCase` and what the codec writes and reads, one line each: the
- * properties, headers and body of `encode(envelope)`, and `decode(message)` against the expected
- * event. Empty when they agree.
- */
-declare function rabbitMqCodecMismatches(options: RabbitMqCodecContractOptions, testCase: RabbitMqCodecCase): Promise<string[]>;
-/** Registers one test per case asserting {@link rabbitMqCodecMismatches} finds nothing. */
+/** Registers one Vitest test per captured RabbitMQ message (see `registerRabbitMqCodecContract`). */
 declare function rabbitMqCodecContract(name: string, options: RabbitMqCodecContractOptions): void;
 
-export { FakeClock, InMemoryTransport, at, createDelivery, createEnvelope, eventStoreContract, kafkaCodecContract, kafkaCodecMismatches, rabbitMqCodecContract, rabbitMqCodecMismatches };
-export type { BodyComparison, EventStoreContractOptions, KafkaCapturedRecord, KafkaCodecCase, KafkaCodecContractOptions, KafkaDeliveredRecord, KafkaWrittenRecord, PublishedMessage, RabbitMqCapturedMessage, RabbitMqCodecCase, RabbitMqCodecContractOptions, RabbitMqDeliveredMessage, RabbitMqWrittenMessage, WireBytes };
+export { FakeClock, InMemoryTransport, KafkaCodecContractOptions, RabbitMqCodecContractOptions, at, createDelivery, createEnvelope, eventStoreContract, kafkaCodecContract, rabbitMqCodecContract };
+export type { EventStoreContractOptions, PublishedMessage };

package/dist/index.js

@@ -1,7 +1,8 @@
+import { registerKafkaCodecContract, registerRabbitMqCodecContract } from './chunk-ZZZXYZJ3.js';
+export { CodecContractError, assertKafkaCodecCase, assertRabbitMqCodecCase, kafkaCodecMismatches, rabbitMqCodecMismatches, registerKafkaCodecContract, registerRabbitMqCodecContract } from './chunk-ZZZXYZJ3.js';
 import { describe, beforeEach, afterEach, it, expect } from 'vitest';
-import { createUuidV7, toErrorInfo } from '@relaybus/core';
+import { createUuidV7 } from '@relaybus/core';
 
-// src/event-store-contract.ts
 function createDeferred() {
   let resolve;
   const promise = new Promise((onResolve) => {
@@ -1242,6 +1243,103 @@ function lostLeasesContract(suite) {
     });
   });
 }
+function unsortedPayload() {
+  return {
+    zulu: "last letter first",
+    b: { yankee: [{ zz: 1, a: 2, mm: { q: null, c: true } }, [], {}], alpha: {} },
+    longestKeyOfTheObject: 1,
+    a: '\xE7\u011F\u0131\xF6\u015F\xFC \u{1F680} \u2028 "quoted" \\ tab	',
+    exponent: 1e21,
+    tiny: 5e-324,
+    fraction: 0.1 + 0.2,
+    negative: -42.5,
+    maxSafe: Number.MAX_SAFE_INTEGER,
+    minSafe: Number.MIN_SAFE_INTEGER,
+    emptyObject: {},
+    emptyArray: [],
+    "7": "integer-like key",
+    mixed: ["z", { d: 4, c: 3 }, 0, false, null]
+  };
+}
+function payloadFidelityContract(suite) {
+  const { append, claim } = suite;
+  describe("payload fidelity", () => {
+    it("hands out the payload and headers with their key order, as published", async () => {
+      const event = createEnvelope({
+        payload: unsortedPayload(),
+        headers: { zz: "last", traceparent: "00-abc-def-01", a: "first", tenant: "acme" }
+      });
+      await append([{ event, deliveries: [createDelivery("handler-a")] }]);
+      const [claimed] = await claim(["handler-a"]);
+      expect(JSON.stringify(claimed.event.payload)).toBe(JSON.stringify(event.payload));
+      expect(JSON.stringify(claimed.event.headers)).toBe(JSON.stringify(event.headers));
+    });
+    it("keeps the order of a payload appended in a batch and of a top-level array", async () => {
+      const object = createEnvelope({ payload: unsortedPayload() });
+      const list = createEnvelope({ payload: [{ zz: 1, a: { y: 2, b: 1 } }, "x", 1e21] });
+      const scalar = createEnvelope({ payload: "plain text" });
+      await append([
+        { event: object, deliveries: [createDelivery("handler-a", at(1))] },
+        { event: list, deliveries: [createDelivery("handler-a", at(2))] },
+        { event: scalar, deliveries: [createDelivery("handler-a", at(3))] }
+      ]);
+      const claimed = await claim(["handler-a"], at(10));
+      expect(claimed.map((delivery) => JSON.stringify(delivery.event.payload))).toEqual(
+        [object, list, scalar].map((event) => JSON.stringify(event.payload))
+      );
+    });
+    it("keeps the order for a handler added to an event that already exists", async () => {
+      const event = createEnvelope({ payload: unsortedPayload() });
+      await append([{ event, deliveries: [createDelivery("handler-a")] }]);
+      await append([{ event, deliveries: [createDelivery("handler-b")] }]);
+      const [claimed] = await claim(["handler-b"]);
+      expect(JSON.stringify(claimed.event.payload)).toBe(JSON.stringify(event.payload));
+    });
+  });
+}
+function transactionIsolationContract(suite) {
+  let store;
+  beforeEach(() => {
+    store = suite.store();
+  });
+  describe("transaction isolation levels", () => {
+    it("recognizes no unrelated error as a serialization failure", () => {
+      for (const error of [new Error("boom"), void 0, null, "text", { code: "23505" }]) {
+        expect(store.isSerializationFailure?.(error) ?? false).toBe(false);
+      }
+    });
+    it("commits and rolls back at every level it lists", async () => {
+      for (const isolationLevel of store.isolationLevels ?? []) {
+        const committed = createEnvelope();
+        await store.transaction(
+          (transaction) => store.append(
+            transaction,
+            [{ event: committed, deliveries: [createDelivery("h")] }],
+            /* @__PURE__ */ new Date(0)
+          ),
+          { timeoutMs: 5e3, isolationLevel }
+        );
+        const abandoned = createEnvelope();
+        await expect(
+          store.transaction(
+            async (transaction) => {
+              await store.append(
+                transaction,
+                [{ event: abandoned, deliveries: [createDelivery("h")] }],
+                /* @__PURE__ */ new Date(0)
+              );
+              throw new Error(`rolled back at ${isolationLevel}`);
+            },
+            { timeoutMs: 5e3, isolationLevel }
+          )
+        ).rejects.toThrow(`rolled back at ${isolationLevel}`);
+        const stored = (await store.listDeliveries({})).map((delivery) => delivery.event.id);
+        expect(stored).toContain(committed.id);
+        expect(stored).not.toContain(abandoned.id);
+      }
+    });
+  });
+}
 
 // src/event-store-contract.ts
 function eventStoreContract(name, options) {
@@ -1290,6 +1388,8 @@ function eventStoreContract(name, options) {
     orderingAndLeasesContract(suite);
     completionContract(suite);
     lostLeasesContract(suite);
+    payloadFidelityContract(suite);
+    transactionIsolationContract(suite);
   });
 }
 
@@ -1358,6 +1458,8 @@ var FakeClock = class {
 var InMemoryTransport = class {
   name;
   published = [];
+  /** Wire names (event type to name) that routes and catalogs declared; the transport sends events as they are. */
+  declaredWireTypes = {};
   #subscribers = /* @__PURE__ */ new Map();
   #failNextPublishes = 0;
   connected = false;
@@ -1368,6 +1470,11 @@ var InMemoryTransport = class {
   async connect() {
     this.connected = true;
   }
+  declareWireTypes(wireTypes) {
+    return () => {
+      Object.assign(this.declaredWireTypes, wireTypes);
+    };
+  }
   /** Makes the next `count` publishes reject, simulating a broker outage. */
   failNextPublishes(count) {
     this.#failNextPublishes = count;
@@ -1404,186 +1511,24 @@ var InMemoryTransport = class {
   }
 };
 async function deliverWithRedeliveries(handler, delivery) {
-  for (let attempt2 = 0; ; attempt2 += 1) {
+  for (let attempt = 0; ; attempt += 1) {
     try {
       await handler(delivery.envelope, { destination: delivery.destination });
-      return attempt2 + 1;
+      return attempt + 1;
     } catch (error) {
-      if (attempt2 >= delivery.maxRedeliveries) {
+      if (attempt >= delivery.maxRedeliveries) {
         throw error;
       }
     }
   }
 }
-function toBuffer(bytes) {
-  return typeof bytes === "string" ? Buffer.from(bytes, "utf8") : Buffer.from(bytes);
-}
-function canonicalJson(value) {
-  return JSON.stringify(sortKeys(JSON.parse(JSON.stringify(value) ?? "null")));
-}
-function sortKeys(value) {
-  if (Array.isArray(value)) {
-    return value.map(sortKeys);
-  }
-  if (typeof value !== "object" || value === null) {
-    return value;
-  }
-  return Object.fromEntries(
-    Object.keys(value).sort().map((name) => [name, sortKeys(value[name])])
-  );
-}
-function compareBodies(label, {
-  expected,
-  encoded,
-  comparison
-}) {
-  const text = (bytes) => bytes === null ? "null" : toBuffer(bytes).toString("utf8");
-  const same = expected === null || encoded === null ? expected === encoded : comparison === "json" ? canonicalJson(JSON.parse(text(expected))) === canonicalJson(JSON.parse(text(encoded))) : toBuffer(expected).equals(toBuffer(encoded));
-  return same ? [] : [`${label}: expected ${text(expected)}, encoded ${text(encoded)}`];
-}
-function compareObjects(label, {
-  expected,
-  encoded,
-  ignored
-}) {
-  const kept = (object) => canonicalJson(
-    Object.fromEntries(Object.entries(object).filter(([name]) => !ignored.includes(name)))
-  );
-  const [left, right] = [kept(expected), kept(encoded)];
-  return left === right ? [] : [`${label}: expected ${left}, encoded ${right}`];
-}
-function compareDecoded(expected, decoded) {
-  const [left, right] = [canonicalJson(expected), canonicalJson(decoded)];
-  return left === right ? [] : [`decoded: expected ${left}, decoded ${right}`];
-}
-async function attempt(label, step) {
-  try {
-    return { result: await step(), mismatches: [] };
-  } catch (error) {
-    return { mismatches: [`${label} threw: ${toErrorInfo(error).message}`] };
-  }
-}
-
-// src/codec-contract/kafka.ts
-async function kafkaCodecMismatches(options, testCase) {
-  const { record } = testCase;
-  const encoding = testCase.only === "decode" ? { mismatches: [] } : await attempt("encode", () => options.encode(testCase.envelope));
-  const encoded = encoding.result;
-  const decoding = testCase.only === "encode" ? { mismatches: [] } : await attempt("decode", () => options.decode(delivered(record)));
-  return [
-    ...encoding.mismatches,
-    ...encoded === void 0 ? [] : compareRecords(options, { record, encoded }),
-    ...decoding.mismatches,
-    ...decoding.result === void 0 ? [] : compareDecoded(testCase.decoded ?? testCase.envelope, decoding.result)
-  ];
-}
 function kafkaCodecContract(name, options) {
-  describe(`${name} writes and reads the captured Kafka records`, () => {
-    it.each(options.cases.map((testCase) => [testCase.name, testCase]))(
-      "%s",
-      async (_name, testCase) => {
-        expect(await kafkaCodecMismatches(options, testCase)).toEqual([]);
-      }
-    );
-  });
-}
-function compareRecords(options, {
-  record,
-  encoded
-}) {
-  const text = (bytes) => bytes === null ? null : toBuffer(bytes).toString("utf8");
-  const timestamp = encoded.timestamp;
-  return [
-    ...text(record.key) === text(encoded.key) ? [] : [`key: expected ${text(record.key)}, encoded ${text(encoded.key)}`],
-    ...compareBodies("value", {
-      expected: record.value,
-      encoded: encoded.value,
-      comparison: options.compare ?? "bytes"
-    }),
-    ...compareObjects("headers", {
-      expected: textHeaders(record.headers ?? {}),
-      encoded: textHeaders(encoded.headers),
-      ignored: options.ignoreHeaders ?? []
-    }),
-    ...timestamp === void 0 || timestamp === record.timestamp ? [] : [`timestamp: expected ${record.timestamp}, encoded ${timestamp}`]
-  ];
-}
-function textHeaders(headers) {
-  return Object.fromEntries(
-    Object.entries(headers).map(([name, value]) => [
-      name,
-      toBuffer(Array.isArray(value) ? value.at(-1) : value).toString(
-        "utf8"
-      )
-    ])
-  );
-}
-function delivered(record) {
-  return {
-    topic: record.topic,
-    partition: record.partition ?? 0,
-    offset: record.offset ?? "0",
-    key: record.key === null ? null : toBuffer(record.key),
-    value: record.value === null ? null : toBuffer(record.value),
-    headers: Object.fromEntries(
-      Object.entries(record.headers ?? {}).map(([name, value]) => [name, toBuffer(value)])
-    ),
-    ...record.timestamp === void 0 ? {} : { timestamp: record.timestamp }
-  };
-}
-async function rabbitMqCodecMismatches(options, testCase) {
-  const { message } = testCase;
-  const encoding = testCase.only === "decode" ? { mismatches: [] } : await attempt("encode", () => options.encode(testCase.envelope));
-  const encoded = encoding.result;
-  const decoding = testCase.only === "encode" ? { mismatches: [] } : await attempt("decode", () => options.decode(delivered2(message)));
-  return [
-    ...encoding.mismatches,
-    ...encoded === void 0 ? [] : compareMessages(options, { message, encoded }),
-    ...decoding.mismatches,
-    ...decoding.result === void 0 ? [] : compareDecoded(testCase.decoded ?? testCase.envelope, decoding.result)
-  ];
+  registerKafkaCodecContract({ describe: describe, it: it }, { name, options });
 }
 function rabbitMqCodecContract(name, options) {
-  describe(`${name} writes and reads the captured RabbitMQ messages`, () => {
-    it.each(options.cases.map((testCase) => [testCase.name, testCase]))(
-      "%s",
-      async (_name, testCase) => {
-        expect(await rabbitMqCodecMismatches(options, testCase)).toEqual([]);
-      }
-    );
-  });
-}
-function compareMessages(options, {
-  message,
-  encoded
-}) {
-  const { headers, ...properties } = encoded.options;
-  return [
-    ...compareObjects("properties", {
-      expected: message.properties ?? {},
-      encoded: properties,
-      ignored: options.ignoreProperties ?? []
-    }),
-    ...compareObjects("headers", {
-      expected: message.headers ?? {},
-      encoded: headers ?? {},
-      ignored: options.ignoreHeaders ?? []
-    }),
-    ...compareBodies("body", {
-      expected: message.body,
-      encoded: encoded.content,
-      comparison: options.compare ?? "bytes"
-    })
-  ];
-}
-function delivered2(message) {
-  return {
-    content: toBuffer(message.body),
-    fields: { routingKey: message.routingKey },
-    properties: { ...message.properties, headers: { ...message.headers } }
-  };
+  registerRabbitMqCodecContract({ describe: describe, it: it }, { name, options });
 }
 
-export { FakeClock, InMemoryTransport, at, createDelivery, createEnvelope, eventStoreContract, kafkaCodecContract, kafkaCodecMismatches, rabbitMqCodecContract, rabbitMqCodecMismatches };
+export { FakeClock, InMemoryTransport, at, createDelivery, createEnvelope, eventStoreContract, kafkaCodecContract, rabbitMqCodecContract };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map