@shirudo/ddd-kit 1.1.0 → 1.3.0

package/dist/testing.js

@@ -0,0 +1,793 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/utils/array/is-built-in.ts
+var BUILT_IN_TAGS = /* @__PURE__ */ new Set([
+  "[object Date]",
+  "[object RegExp]",
+  "[object Map]",
+  "[object Set]",
+  "[object WeakMap]",
+  "[object WeakSet]",
+  "[object Promise]",
+  "[object Error]",
+  "[object Boolean]",
+  "[object Number]",
+  "[object String]",
+  "[object ArrayBuffer]",
+  "[object SharedArrayBuffer]",
+  "[object DataView]"
+]);
+function intrinsicGetter(proto, prop) {
+  const get = Object.getOwnPropertyDescriptor(proto, prop)?.get;
+  if (!get) throw new Error(`missing intrinsic getter for ${prop}`);
+  return get;
+}
+__name(intrinsicGetter, "intrinsicGetter");
+var dateGetTime = Date.prototype.getTime;
+var mapSizeGet = intrinsicGetter(Map.prototype, "size");
+var setSizeGet = intrinsicGetter(Set.prototype, "size");
+var weakMapHas = WeakMap.prototype.has;
+var weakSetHas = WeakSet.prototype.has;
+var dataViewByteLengthGet = intrinsicGetter(DataView.prototype, "byteLength");
+var arrayBufferByteLengthGet = intrinsicGetter(
+  ArrayBuffer.prototype,
+  "byteLength"
+);
+var regExpSourceGet = intrinsicGetter(RegExp.prototype, "source");
+var booleanValueOf = Boolean.prototype.valueOf;
+var numberValueOf = Number.prototype.valueOf;
+var stringValueOf = String.prototype.valueOf;
+var PROBE_KEY = {};
+function hasBrand(obj, tag) {
+  try {
+    switch (tag) {
+      case "[object Date]":
+        dateGetTime.call(obj);
+        return true;
+      case "[object RegExp]":
+        regExpSourceGet.call(obj);
+        return true;
+      case "[object Map]":
+        mapSizeGet.call(obj);
+        return true;
+      case "[object Set]":
+        setSizeGet.call(obj);
+        return true;
+      case "[object WeakMap]":
+        weakMapHas.call(obj, PROBE_KEY);
+        return true;
+      case "[object WeakSet]":
+        weakSetHas.call(obj, PROBE_KEY);
+        return true;
+      case "[object DataView]":
+        dataViewByteLengthGet.call(obj);
+        return true;
+      case "[object ArrayBuffer]":
+        arrayBufferByteLengthGet.call(obj);
+        return true;
+      case "[object Boolean]":
+        booleanValueOf.call(obj);
+        return true;
+      case "[object Number]":
+        numberValueOf.call(obj);
+        return true;
+      case "[object String]":
+        stringValueOf.call(obj);
+        return true;
+      default:
+        return true;
+    }
+  } catch {
+    return false;
+  }
+}
+__name(hasBrand, "hasBrand");
+function isBuiltInObject(obj, tag) {
+  if (ArrayBuffer.isView(obj)) return true;
+  if (tag.endsWith("Array]")) return false;
+  return BUILT_IN_TAGS.has(tag) && hasBrand(obj, tag);
+}
+__name(isBuiltInObject, "isBuiltInObject");
+
+// src/utils/array/deep-equal.ts
+var objProto = Object.prototype;
+var objToString = objProto.toString;
+var objHasOwn = objProto.hasOwnProperty;
+function sameValueZero(a, b) {
+  return a === b || Number.isNaN(a) && Number.isNaN(b);
+}
+__name(sameValueZero, "sameValueZero");
+function deepEqual(a, b) {
+  return deepEqualInner(a, b, /* @__PURE__ */ new WeakMap());
+}
+__name(deepEqual, "deepEqual");
+function deepEqualInner(a, b, visited) {
+  if (a === b) return true;
+  const typeA = typeof a;
+  const typeB = typeof b;
+  if (typeA !== "object" || a === null || typeB !== "object" || b === null) {
+    if (typeA === "number" && typeB === "number") {
+      return Number.isNaN(a) && Number.isNaN(b);
+    }
+    return false;
+  }
+  const objA = a;
+  const objB = b;
+  let cachedBs = visited.get(objA);
+  if (cachedBs?.has(objB)) {
+    return true;
+  }
+  if (!cachedBs) {
+    cachedBs = /* @__PURE__ */ new WeakSet();
+    visited.set(objA, cachedBs);
+  }
+  cachedBs.add(objB);
+  if (ArrayBuffer.isView(objA) || ArrayBuffer.isView(objB)) {
+    if (!ArrayBuffer.isView(objA) || !ArrayBuffer.isView(objB)) return false;
+    const tagA2 = objToString.call(objA);
+    const tagB2 = objToString.call(objB);
+    if (tagA2 !== tagB2) return false;
+    if (tagA2 === "[object DataView]") {
+      const viewA = objA;
+      const viewB = objB;
+      if (viewA.byteLength !== viewB.byteLength) return false;
+      const len2 = viewA.byteLength;
+      for (let i = 0; i < len2; i++) {
+        if (viewA.getUint8(i) !== viewB.getUint8(i)) return false;
+      }
+      return true;
+    }
+    const arrA = objA;
+    const arrB = objB;
+    const len = arrA.length;
+    if (len !== arrB.length) return false;
+    for (let i = 0; i < len; i++) {
+      if (!sameValueZero(arrA[i], arrB[i])) return false;
+    }
+    return true;
+  }
+  if (Array.isArray(objA) || Array.isArray(objB)) {
+    if (!Array.isArray(objA) || !Array.isArray(objB)) return false;
+    const arrA = objA;
+    const arrB = objB;
+    const len = arrA.length;
+    if (len !== arrB.length) return false;
+    for (let i = 0; i < len; i++) {
+      if (!deepEqualInner(arrA[i], arrB[i], visited)) return false;
+    }
+    return true;
+  }
+  const tagA = objToString.call(objA);
+  const tagB = objToString.call(objB);
+  if (tagA !== tagB) return false;
+  const builtInA = isBuiltInObject(objA, tagA);
+  const builtInB = isBuiltInObject(objB, tagB);
+  if (builtInA !== builtInB) return false;
+  if (!builtInA) {
+    return comparePlainObjects(objA, objB, visited);
+  }
+  switch (tagA) {
+    case "[object Map]": {
+      const mapA = objA;
+      const mapB = objB;
+      if (mapA.size !== mapB.size) return false;
+      for (const [key, valA] of mapA) {
+        if (!mapB.has(key)) return false;
+        const valB = mapB.get(key);
+        if (!deepEqualInner(valA, valB, visited)) return false;
+      }
+      return true;
+    }
+    case "[object Set]": {
+      const setA = objA;
+      const setB = objB;
+      if (setA.size !== setB.size) return false;
+      for (const value of setA) {
+        if (!setB.has(value)) return false;
+      }
+      return true;
+    }
+    case "[object Date]": {
+      return sameValueZero(objA.getTime(), objB.getTime());
+    }
+    case "[object RegExp]": {
+      const regA = objA;
+      const regB = objB;
+      return regA.source === regB.source && regA.flags === regB.flags;
+    }
+    case "[object Boolean]":
+    case "[object Number]":
+    case "[object String]": {
+      return sameValueZero(
+        objA.valueOf(),
+        objB.valueOf()
+      );
+    }
+    default: {
+      return objA === objB;
+    }
+  }
+}
+__name(deepEqualInner, "deepEqualInner");
+function comparePlainObjects(objA, objB, visited) {
+  const recA = objA;
+  const recB = objB;
+  const stringKeysA = Object.keys(objA);
+  const stringKeysB = Object.keys(objB);
+  if (stringKeysA.length !== stringKeysB.length) return false;
+  const symbolKeysA = Object.getOwnPropertySymbols(objA);
+  const symbolKeysB = Object.getOwnPropertySymbols(objB);
+  if (symbolKeysA.length !== symbolKeysB.length) return false;
+  const symbolKeysBSet = new Set(symbolKeysB);
+  for (const key of stringKeysA) {
+    if (!objHasOwn.call(objB, key)) return false;
+  }
+  for (const key of symbolKeysA) {
+    if (!symbolKeysBSet.has(key)) return false;
+  }
+  for (const key of stringKeysA) {
+    if (!deepEqualInner(recA[key], recB[key], visited)) {
+      return false;
+    }
+  }
+  for (const key of symbolKeysA) {
+    if (!deepEqualInner(recA[key], recB[key], visited)) {
+      return false;
+    }
+  }
+  return true;
+}
+__name(comparePlainObjects, "comparePlainObjects");
+
+// src/testing/repository-contract.ts
+function createRepositoryContractTests(harness) {
+  async function withEnvironment(body) {
+    const env = await harness.createEnvironment();
+    let bodyFailed = false;
+    let bodyError;
+    try {
+      await body(env);
+    } catch (error) {
+      bodyFailed = true;
+      bodyError = error;
+    }
+    try {
+      await env.teardown?.();
+    } catch (teardownError) {
+      if (!bodyFailed) {
+        throw teardownError;
+      }
+    }
+    if (bodyFailed) {
+      throw bodyError;
+    }
+  }
+  __name(withEnvironment, "withEnvironment");
+  async function loadOrFail(repository, id) {
+    const loaded = await repository.getById(id);
+    assert(
+      loaded !== null,
+      `getById(${String(id)}) returned null for an aggregate that must exist - broken hydration or a write that did not commit`
+    );
+    return loaded;
+  }
+  __name(loadOrFail, "loadOrFail");
+  async function seed(env) {
+    const aggregate = harness.createAggregate();
+    harness.mutate(aggregate);
+    await env.run(async ({ repository }) => {
+      await repository.save(aggregate);
+    });
+    return aggregate;
+  }
+  __name(seed, "seed");
+  async function reload(env, id) {
+    return env.run(({ repository }) => loadOrFail(repository, id));
+  }
+  __name(reload, "reload");
+  function captureRejection(promise) {
+    return promise.then(
+      () => void 0,
+      (error) => error
+    );
+  }
+  __name(captureRejection, "captureRejection");
+  const eventIds = /* @__PURE__ */ __name((events) => events.map((event) => event.eventId).sort(), "eventIds");
+  const snapshotState = harness.snapshotState;
+  const mutateVersionOnly = harness.mutateVersionOnly;
+  const mutateChildCollection = harness.mutateChildCollection;
+  const createAggregateWithId = harness.createAggregateWithId;
+  const deletesAreVersionChecked = harness.deletesAreVersionChecked === true;
+  const insertsAreDuplicateChecked = harness.insertsAreDuplicateChecked !== false;
+  function skippedTest(name, capability) {
+    return {
+      name,
+      skipped: { capability },
+      run: /* @__PURE__ */ __name(async () => {
+        throw new Error(
+          `Repository contract test skipped: harness capability '${capability}' is not provided. Bind skipped tests with it.skip ((test.skipped ? it.skip : it)(test.name, test.run)) or provide the capability - each one closes a real OCC hole.`
+        );
+      }, "run")
+    };
+  }
+  __name(skippedTest, "skippedTest");
+  const tests = [
+    {
+      name: "MANDATORY two-writer conflict: the stale writer throws ConcurrencyConflictError and persists nothing",
+      run: /* @__PURE__ */ __name(() => withEnvironment(async (env) => {
+        const seeded = await seed(env);
+        const seedEvents = await env.committedOutboxEvents();
+        const seedEventIds = new Set(seedEvents.map((e) => e.eventId));
+        const staleB = await reload(env, seeded.id);
+        const committedA = await env.run(async ({ repository }) => {
+          const a = await loadOrFail(repository, seeded.id);
+          harness.mutate(a);
+          await repository.save(a);
+          return a;
+        });
+        const outboxAfterA = await env.committedOutboxEvents();
+        assert(
+          outboxAfterA.length > seedEvents.length,
+          "writer A's events must reach the outbox on commit"
+        );
+        const newSinceSeed = outboxAfterA.filter(
+          (event) => !seedEventIds.has(event.eventId)
+        );
+        assert(
+          newSinceSeed.length > 0 && newSinceSeed.every(
+            (event) => event.aggregateVersion === committedA.version
+          ),
+          `writer A's committed outbox events must carry aggregateVersion === ${committedA.version} (A's commit version). Suspect #1: your outbox read-back (committedOutboxEvents) reconstructs events from an explicit column list and drops or string-types the aggregateVersion field. Suspect #2: a hand-rolled orchestration that does not stamp aggregateVersion = aggregate.version at harvest (withCommit does this automatically).`
+        );
+        harness.mutate(staleB);
+        const rejection = await captureRejection(
+          env.run(async ({ repository }) => {
+            await repository.save(staleB);
+          })
+        );
+        assert(
+          rejection !== void 0,
+          "the second writer's commit must reject - it committed on a stale version instead (OCC predicate missing?)"
+        );
+        assert(
+          chainContainsErrorNamed(rejection, "ConcurrencyConflictError"),
+          `the second writer's rejection must be (or wrap, via the cause chain) ConcurrencyConflictError; got: ${describeError(rejection)}`
+        );
+        const final = await reload(env, seeded.id);
+        assertEqual(
+          final.version,
+          committedA.version,
+          "the persisted version must equal writer A's committed version"
+        );
+        if (snapshotState) {
+          assert(
+            deepEqual(
+              snapshotState.call(harness, final),
+              snapshotState.call(harness, committedA)
+            ),
+            "the persisted STATE must equal writer A's. Two suspects: (a) a predicate that guards only the version write lets the stale writer's state survive; (b) your snapshotState projection is not roundtrip-stable (date precision, undefined-valued keys, decimal representation) - see its JSDoc"
+          );
+        }
+        const outboxFinal = await env.committedOutboxEvents();
+        assert(
+          deepEqual(eventIds(outboxFinal), eventIds(outboxAfterA)),
+          "the outbox must contain exactly the winning writer's events (compared by eventId) - nothing from the stale writer, nothing replaced"
+        );
+      }), "run")
+    },
+    {
+      name: "insert routing: a never-persisted aggregate INSERTs even after pre-save mutations",
+      run: /* @__PURE__ */ __name(() => withEnvironment(async (env) => {
+        const aggregate = harness.createAggregate();
+        assert(
+          aggregate.persistedVersion === void 0,
+          "harness contract: createAggregate() must return a never-persisted aggregate (persistedVersion === undefined)"
+        );
+        harness.mutate(aggregate);
+        harness.mutate(aggregate);
+        await env.run(async ({ repository }) => {
+          await repository.save(aggregate);
+        });
+        const loaded = await reload(env, aggregate.id);
+        assertEqual(
+          loaded.version,
+          aggregate.version,
+          "the INSERT must persist the in-memory version (route on persistedVersion === undefined, not version === 0)"
+        );
+      }), "run")
+    },
+    {
+      name: "update writes the in-memory version and predicates on persistedVersion",
+      run: /* @__PURE__ */ __name(() => withEnvironment(async (env) => {
+        const seeded = await seed(env);
+        const baseline = seeded.version;
+        await env.run(async ({ repository }) => {
+          const loaded = await loadOrFail(repository, seeded.id);
+          harness.mutate(loaded);
+          harness.mutate(loaded);
+          await repository.save(loaded);
+        });
+        const final = await reload(env, seeded.id);
+        assertEqual(
+          final.version,
+          baseline + 2,
+          "two mutations must persist as baseline + 2 (version is a mutation sequence)"
+        );
+        assertEqual(
+          final.persistedVersion,
+          final.version,
+          "a reloaded aggregate's persistedVersion must equal its version"
+        );
+      }), "run")
+    },
+    {
+      name: "rollback persists nothing: state, version, and outbox untouched",
+      run: /* @__PURE__ */ __name(() => withEnvironment(async (env) => {
+        const seeded = await seed(env);
+        const versionBefore = seeded.version;
+        const outboxBefore = (await env.committedOutboxEvents()).length;
+        const probe = new Error("contract rollback probe");
+        const rejection = await captureRejection(
+          env.run(async ({ repository }) => {
+            const loaded = await loadOrFail(repository, seeded.id);
+            harness.mutate(loaded);
+            await repository.save(loaded);
+            throw probe;
+          })
+        );
+        assert(
+          rejection !== void 0,
+          "a throwing unit of work must reject"
+        );
+        const final = await reload(env, seeded.id);
+        assertEqual(
+          final.version,
+          versionBefore,
+          "a rolled-back write must not change the persisted version"
+        );
+        assertEqual(
+          (await env.committedOutboxEvents()).length,
+          outboxBefore,
+          "a rolled-back transaction must not leave events in the outbox"
+        );
+      }), "run")
+    },
+    {
+      name: "identity map: two getById calls in one unit of work return the same instance",
+      run: /* @__PURE__ */ __name(() => withEnvironment(async (env) => {
+        const seeded = await seed(env);
+        await env.run(async ({ repository }) => {
+          const first = await repository.getById(seeded.id);
+          const second = await repository.getById(seeded.id);
+          assert(
+            first !== null && first === second,
+            "repeated loads within one unit of work must return the SAME instance (identity map) - distinct instances double-harvest events"
+          );
+        });
+      }), "run")
+    },
+    {
+      name: "delete: getById returns null in the same unit of work and after the commit",
+      run: /* @__PURE__ */ __name(() => withEnvironment(async (env) => {
+        const seeded = await seed(env);
+        await env.run(async ({ repository }) => {
+          const loaded = await loadOrFail(repository, seeded.id);
+          await repository.delete(loaded);
+          const probe = await repository.getById(seeded.id);
+          assert(
+            probe === null,
+            "after delete, getById in the SAME unit of work must return null (isDeleted check), even if the physical delete is deferred"
+          );
+        });
+        await env.run(async ({ repository }) => {
+          const probe = await repository.getById(seeded.id);
+          assert(
+            probe === null,
+            "after the deleting unit of work committed, the aggregate must be gone"
+          );
+        });
+      }), "run")
+    },
+    {
+      name: "deletion is final: saving the deleted aggregate in the same unit of work throws AggregateDeletedError",
+      run: /* @__PURE__ */ __name(() => withEnvironment(async (env) => {
+        const seeded = await seed(env);
+        const rejection = await captureRejection(
+          env.run(async ({ repository }) => {
+            const loaded = await loadOrFail(repository, seeded.id);
+            harness.mutate(loaded);
+            await repository.delete(loaded);
+            await repository.save(loaded);
+          })
+        );
+        assert(
+          chainContainsErrorNamed(rejection, "AggregateDeletedError"),
+          `save-after-delete must reject with (or wrap) AggregateDeletedError; got: ${describeError(rejection)}. If you see ConcurrencyConflictError here instead, your save() probably enrolls AFTER the row write - enroll first.`
+        );
+      }), "run")
+    },
+    {
+      name: "events are cleared after a committed unit of work and kept after a rollback",
+      run: /* @__PURE__ */ __name(() => withEnvironment(async (env) => {
+        const committed = harness.createAggregate();
+        harness.mutate(committed);
+        assert(
+          committed.pendingEvents.length > 0,
+          "harness contract: mutate() must record at least one domain event"
+        );
+        await env.run(async ({ repository }) => {
+          await repository.save(committed);
+        });
+        assertEqual(
+          committed.pendingEvents.length,
+          0,
+          "pending events must be cleared after a successful commit"
+        );
+        const rolledBack = harness.createAggregate();
+        harness.mutate(rolledBack);
+        const pendingBefore = rolledBack.pendingEvents.length;
+        await captureRejection(
+          env.run(async ({ repository }) => {
+            await repository.save(rolledBack);
+            throw new Error("contract rollback probe");
+          })
+        );
+        assertEqual(
+          rolledBack.pendingEvents.length,
+          pendingBefore,
+          "pending events must survive a rollback (so a fresh load + retry can re-emit them)"
+        );
+      }), "run")
+    },
+    {
+      name: "persistedVersion syncs only after a successful commit",
+      run: /* @__PURE__ */ __name(() => withEnvironment(async (env) => {
+        const aggregate = harness.createAggregate();
+        harness.mutate(aggregate);
+        await captureRejection(
+          env.run(async ({ repository }) => {
+            await repository.save(aggregate);
+            throw new Error("contract rollback probe");
+          })
+        );
+        assert(
+          aggregate.persistedVersion === void 0,
+          "a rolled-back first save must leave persistedVersion undefined (the aggregate is still unpersisted)"
+        );
+        await env.run(async ({ repository }) => {
+          await repository.save(aggregate);
+        });
+        assertEqual(
+          aggregate.persistedVersion,
+          aggregate.version,
+          "after a successful commit, persistedVersion must equal version (markPersisted ran)"
+        );
+      }), "run")
+    }
+  ];
+  tests.push(
+    mutateVersionOnly ? {
+      name: "version-only change still persists (skip-save must not desync the OCC baseline)",
+      run: /* @__PURE__ */ __name(() => withEnvironment(async (env) => {
+        const seeded = await seed(env);
+        const baseline = seeded.version;
+        await env.run(async ({ repository }) => {
+          const loaded = await loadOrFail(repository, seeded.id);
+          mutateVersionOnly.call(harness, loaded);
+          await repository.save(loaded);
+        });
+        const final = await reload(env, seeded.id);
+        assertEqual(
+          final.version,
+          baseline + 1,
+          "a version-only change (empty changedKeys, bumped version) must still be persisted - skipping it desyncs persistedVersion and produces false ConcurrencyConflictErrors later"
+        );
+      }), "run")
+    } : skippedTest(
+      "version-only change still persists (skip-save must not desync the OCC baseline)",
+      "mutateVersionOnly"
+    )
+  );
+  tests.push(
+    mutateChildCollection ? {
+      name: "a child-collection-only change bumps the persisted root version",
+      run: /* @__PURE__ */ __name(() => withEnvironment(async (env) => {
+        const seeded = await seed(env);
+        const baseline = seeded.version;
+        await env.run(async ({ repository }) => {
+          const loaded = await loadOrFail(repository, seeded.id);
+          mutateChildCollection.call(harness, loaded);
+          await repository.save(loaded);
+        });
+        const final = await reload(env, seeded.id);
+        assert(
+          final.version > baseline,
+          "a child-collection-only change must advance the persisted ROOT version - otherwise concurrent writers interleave with collection writes undetected"
+        );
+      }), "run")
+    } : skippedTest(
+      "a child-collection-only change bumps the persisted root version",
+      "mutateChildCollection"
+    )
+  );
+  tests.push(
+    createAggregateWithId ? {
+      name: "deletion is final across instances: a re-created aggregate with the same id cannot be saved",
+      run: /* @__PURE__ */ __name(() => withEnvironment(async (env) => {
+        const seeded = await seed(env);
+        const rejection = await captureRejection(
+          env.run(async ({ repository }) => {
+            const loaded = await loadOrFail(repository, seeded.id);
+            await repository.delete(loaded);
+            const resurrected = createAggregateWithId.call(
+              harness,
+              seeded.id
+            );
+            harness.mutate(resurrected);
+            await repository.save(resurrected);
+          })
+        );
+        assert(
+          chainContainsErrorNamed(rejection, "AggregateDeletedError"),
+          `saving a re-created instance of a deleted aggregate must reject with (or wrap) AggregateDeletedError; got: ${describeError(rejection)}`
+        );
+      }), "run")
+    } : skippedTest(
+      "deletion is final across instances: a re-created aggregate with the same id cannot be saved",
+      "createAggregateWithId"
+    )
+  );
+  tests.push(
+    createAggregateWithId && insertsAreDuplicateChecked ? {
+      name: "duplicate insert: a second never-persisted aggregate with an existing id throws DuplicateAggregateError",
+      run: /* @__PURE__ */ __name(() => withEnvironment(async (env) => {
+        const seeded = await seed(env);
+        const duplicate = createAggregateWithId.call(
+          harness,
+          seeded.id
+        );
+        harness.mutate(duplicate);
+        harness.mutate(duplicate);
+        const rejection = await captureRejection(
+          env.run(async ({ repository }) => {
+            await repository.save(duplicate);
+          })
+        );
+        assert(
+          chainContainsErrorNamed(rejection, "DuplicateAggregateError"),
+          `inserting a second aggregate with an existing id must reject with (or wrap) DuplicateAggregateError - map your driver's unique-violation signal (Postgres 23505, MySQL 1062, SQLite SQLITE_CONSTRAINT_UNIQUE) instead of letting the raw driver error escape; got: ${describeError(rejection)}`
+        );
+        const final = await reload(env, seeded.id);
+        assertEqual(
+          final.version,
+          seeded.version,
+          "the existing row must be untouched by the rejected duplicate insert - a duplicate check that fires AFTER the write (or outside the transaction) clobbers the existing row"
+        );
+        if (snapshotState) {
+          assert(
+            deepEqual(
+              snapshotState.call(harness, final),
+              snapshotState.call(harness, seeded)
+            ),
+            "the existing row's STATE must be untouched by the rejected duplicate insert"
+          );
+        }
+      }), "run")
+    } : skippedTest(
+      "duplicate insert: a second never-persisted aggregate with an existing id throws DuplicateAggregateError",
+      // Name the capability that is actually missing: the
+      // mechanical one (cannot build the duplicate) or the
+      // semantic opt-out (deliberately upserting adapter).
+      createAggregateWithId ? "insertsAreDuplicateChecked" : "createAggregateWithId"
+    )
+  );
+  tests.push(
+    deletesAreVersionChecked ? {
+      name: "stale delete conflicts: deleting from a stale instance throws ConcurrencyConflictError",
+      run: /* @__PURE__ */ __name(() => withEnvironment(async (env) => {
+        const seeded = await seed(env);
+        const staleB = await reload(env, seeded.id);
+        const versionAfterA = await env.run(
+          async ({ repository }) => {
+            const a = await loadOrFail(repository, seeded.id);
+            harness.mutate(a);
+            await repository.save(a);
+            return a.version;
+          }
+        );
+        const rejection = await captureRejection(
+          env.run(async ({ repository }) => {
+            await repository.delete(staleB);
+          })
+        );
+        assert(
+          chainContainsErrorNamed(rejection, "ConcurrencyConflictError"),
+          `a stale delete must reject with (or wrap) ConcurrencyConflictError; got: ${describeError(rejection)} - an unpredicated DELETE silently destroys the concurrent writer's update`
+        );
+        const final = await env.run(
+          ({ repository }) => repository.getById(seeded.id)
+        );
+        assert(
+          final !== null,
+          "the row must still exist after the stale delete was rejected - the predicate must PREVENT the destructive delete, not merely report it"
+        );
+        assertEqual(
+          final.version,
+          versionAfterA,
+          "the surviving row must carry writer A's version"
+        );
+      }), "run")
+    } : skippedTest(
+      "stale delete conflicts: deleting from a stale instance throws ConcurrencyConflictError",
+      "deletesAreVersionChecked"
+    )
+  );
+  return tests;
+}
+__name(createRepositoryContractTests, "createRepositoryContractTests");
+function assert(condition, message) {
+  if (!condition) {
+    throw new Error(`Repository contract violated: ${message}`);
+  }
+}
+__name(assert, "assert");
+function assertEqual(actual, expected, message) {
+  if (actual !== expected) {
+    throw new Error(
+      `Repository contract violated: ${message} (expected ${String(expected)}, got ${String(actual)})`
+    );
+  }
+}
+__name(assertEqual, "assertEqual");
+function chainContainsErrorNamed(error, name) {
+  const seen = /* @__PURE__ */ new Set();
+  let current = error;
+  while (current !== null && current !== void 0 && !seen.has(current)) {
+    if (typeof current !== "object") {
+      return false;
+    }
+    if (errorMatchesName(current, name)) {
+      return true;
+    }
+    seen.add(current);
+    try {
+      current = current.cause;
+    } catch {
+      return false;
+    }
+  }
+  return false;
+}
+__name(chainContainsErrorNamed, "chainContainsErrorNamed");
+function errorMatchesName(candidate, name) {
+  try {
+    if (candidate.name === name) {
+      return true;
+    }
+  } catch {
+  }
+  try {
+    let proto = Object.getPrototypeOf(candidate);
+    for (let depth = 0; proto !== null && depth < 20; depth++) {
+      if (proto.constructor?.name === name) {
+        return true;
+      }
+      proto = Object.getPrototypeOf(proto);
+    }
+  } catch {
+  }
+  return false;
+}
+__name(errorMatchesName, "errorMatchesName");
+function describeError(error) {
+  if (error instanceof Error) {
+    return `${error.name}: ${error.message}`;
+  }
+  return String(error);
+}
+__name(describeError, "describeError");
+
+export { createRepositoryContractTests };
+//# sourceMappingURL=testing.js.map
+//# sourceMappingURL=testing.js.map