@saasicat/persistence-testing 1.0.0-rc.14 → 1.0.0-rc.16

package/README.md

@@ -16,6 +16,9 @@ Verified scenarios:
 - PlanVersion and BundleVersion validity windows with auto-succession
 - `countByPlanVersionId` counts current AND pending bindings in one query
 - transaction rollback discards writes
+- a contract written on a transaction is undone with it, and found by the offer it came from
+- a checkout offer is consumed once, whoever asks first, and a consume on a rolled-back transaction
+  leaves it open
 - `findByTenantIdLocked` serializes concurrent transactions (row lock)
 - concurrent `claimSlot` grants exactly `maxRedemptions` slots
 - claim / exhaust / release lifecycle
@@ -91,7 +94,7 @@ persistenceAdapterContract({
     }),
     // The parts this adapter deliberately does not provide. A part named here
     // that the harness does provide fails the suite as well.
-    gaps: ['subscriptionContracts', 'appliedSettings'],
+    gaps: ['subscriptionContracts', 'subscribers', 'checkoutOffers', 'appliedSettings'],
 });
 ```
 

package/dist/.build-stamp

@@ -1 +1 @@
-fe1ab043363d0764aaf580f2167335fcb0c2659c445bcc9540708782cb751a27
+1ca79840c535585e92be3594dc7e1b240dfd47e78e98d7577fe19a1cd7e51faf

package/dist/index.cjs

@@ -38,6 +38,100 @@ module.exports = __toCommonJS(index_exports);
 var import_strict = __toESM(require("node:assert/strict"), 1);
 var import_node_test = require("node:test");
 var LOCK_HOLD_MS = 150;
+var OFFER = {
+  planKey: "STANDARD",
+  planVersionId: null,
+  billingCycle: "monthly",
+  priceBreakdown: {
+    currency: "EUR",
+    billingCycle: "monthly",
+    planNet: 49,
+    bundlesNet: 0,
+    regularNet: 49,
+    effectiveNet: 49,
+    vatRate: 19,
+    effectiveGross: 58.31
+  }
+};
+function partiesWith(subscriberId, legalName) {
+  return {
+    subscriberId,
+    subscriber: {
+      customerNumber: "K-10001",
+      legalName,
+      vatId: "DE123456789",
+      taxNumber: null,
+      addressLine1: "Hauptstra\xDFe 1",
+      addressLine2: null,
+      postalCode: "10115",
+      city: "Berlin",
+      country: "DE"
+    },
+    issuer: {
+      legalName: "Example Software GmbH",
+      vatId: "DE987654321",
+      taxNumber: "12/345/67890",
+      addressLine1: "Werkstra\xDFe 5",
+      addressLine2: null,
+      postalCode: "80331",
+      city: "M\xFCnchen",
+      country: "DE"
+    }
+  };
+}
+function subscriberFor(tenantId, legalName) {
+  return {
+    tenantId,
+    legalName,
+    vatId: null,
+    taxNumber: null,
+    addressLine1: null,
+    addressLine2: null,
+    postalCode: null,
+    city: null,
+    country: null,
+    invoiceEmail: null,
+    customerNumberPrefix: ""
+  };
+}
+function contractFromOffer(offerId, parties) {
+  return {
+    tenantId: `tenant-${offerId}`,
+    parties,
+    effectiveFrom: /* @__PURE__ */ new Date("2026-01-01T00:00:00.000Z"),
+    originalOfferId: offerId,
+    priceSnapshot: {
+      currency: "EUR",
+      billingCycle: "monthly",
+      subtotalNet: 49,
+      discountNet: 0,
+      totalNet: 49,
+      vatRate: 19,
+      totalGross: 58.31
+    },
+    lineItems: [
+      {
+        kind: "plan",
+        sourceKey: "STANDARD",
+        sourceVersionId: null,
+        titleSnapshot: "Standard",
+        descriptionSnapshot: null,
+        quantity: 1,
+        unit: null,
+        priceNet: 49,
+        priceGross: 58.31,
+        billingCycle: "monthly",
+        currency: "EUR",
+        taxRate: 19,
+        taxAmount: 9.31,
+        minimumTermUntil: null,
+        featuresSnapshot: [],
+        quotaEffectsSnapshot: {},
+        metadata: null
+      }
+    ]
+  };
+}
 var CONTRACT_GAPS = {
   atomicPlanBinding: {
     reason: "adapter does not expose atomic plan-binding writes",
@@ -135,8 +229,16 @@ var CONTRACT_GAPS = {
     present: ({ adapter }) => Boolean(adapter.mfa)
   },
   subscriptionContracts: {
-    reason: "adapter provides no SubscriptionContractRepository",
-    present: ({ adapter }) => Boolean(adapter.subscriptionContractRepository)
+    reason: "adapter provides no SubscriptionContractRepository, or no subscriber seed for it",
+    present: ({ adapter, seed }) => Boolean(adapter.subscriptionContractRepository && seed.createSubscriber)
+  },
+  subscribers: {
+    reason: "adapter provides no SubscriberRepository",
+    present: ({ adapter }) => Boolean(adapter.subscriberRepository)
+  },
+  checkoutOffers: {
+    reason: "adapter provides no CheckoutOfferRepository",
+    present: ({ adapter }) => Boolean(adapter.checkoutOfferRepository)
   },
   appliedSettings: {
     reason: "adapter provides no AppliedSettingsPort",
@@ -1327,14 +1429,18 @@ function persistenceAdapterContract(options) {
     });
     (0, import_node_test.test)("a contract keeps what was agreed, and ending it does not rewrite it", async (t) => {
       const contracts = harness.adapter.subscriptionContractRepository;
-      if (!contracts) {
+      const createSubscriber = harness.seed.createSubscriber;
+      if (!contracts || !createSubscriber) {
         missing(t, "subscriptionContracts");
         return;
       }
       const tenantId = "tenant-contract-lifecycle";
       const signedAt = /* @__PURE__ */ new Date("2026-01-01T00:00:00.000Z");
+      const { subscriberId } = await createSubscriber({ legalName: "Meier GmbH" });
+      const parties = partiesWith(subscriberId, "Meier GmbH");
       const created = await contracts.create({
         tenantId,
+        parties,
         effectiveFrom: signedAt,
         priceSnapshot: {
           currency: "EUR",
@@ -1395,6 +1501,10 @@ function persistenceAdapterContract(options) {
       });
       import_strict.default.equal(created.status, "active");
       import_strict.default.equal(created.tenantId, tenantId);
+      import_strict.default.equal(created.subscriberId, subscriberId);
+      import_strict.default.deepEqual(created.subscriber, parties.subscriber);
+      import_strict.default.deepEqual(created.issuer, parties.issuer);
+      import_strict.default.equal(created.partiesMigrated, false);
       import_strict.default.equal(created.lineItems.length, 2);
       import_strict.default.deepEqual(created.originalBundleVersionIds, ["bundle-version-1"]);
       import_strict.default.deepEqual(created.termsSnapshot, { noticePeriodDays: 30 });
@@ -1427,6 +1537,8 @@ function persistenceAdapterContract(options) {
       import_strict.default.equal(bundleLine.metadata, null);
       const readBack = await contracts.findById(created.id);
       import_strict.default.ok(readBack, "contract expected by id");
+      import_strict.default.deepEqual(readBack.subscriber, parties.subscriber, "the copy is stored");
+      import_strict.default.deepEqual(readBack.issuer, parties.issuer);
       import_strict.default.equal(
         readBack.lineItems.length,
         2,
@@ -1483,11 +1595,14 @@ function persistenceAdapterContract(options) {
     });
     (0, import_node_test.test)("a successor takes over without erasing the contract it replaces", async (t) => {
       const contracts = harness.adapter.subscriptionContractRepository;
-      if (!contracts) {
+      const createSubscriber = harness.seed.createSubscriber;
+      if (!contracts || !createSubscriber) {
         missing(t, "subscriptionContracts");
         return;
       }
       const tenantId = "tenant-contract-succession";
+      const { subscriberId } = await createSubscriber({ legalName: "Nachfolger KG" });
+      const parties = partiesWith(subscriberId, "Nachfolger KG");
       const handover = /* @__PURE__ */ new Date("2026-04-01T00:00:00.000Z");
       const lineAt = (priceNet, priceGross) => ({
         kind: "plan",
@@ -1519,6 +1634,7 @@ function persistenceAdapterContract(options) {
       });
       const first = await contracts.create({
         tenantId,
+        parties,
         effectiveFrom: /* @__PURE__ */ new Date("2026-01-01T00:00:00.000Z"),
         priceSnapshot: priceAt(19.9, 23.68),
         lineItems: [lineAt(19.9, 23.68)]
@@ -1536,6 +1652,7 @@ function persistenceAdapterContract(options) {
       });
       const second = await contracts.create({
         tenantId,
+        parties,
         effectiveFrom: handover,
         priceSnapshot: priceAt(24.9, 29.63),
         lineItems: [lineAt(24.9, 29.63)]
@@ -1585,13 +1702,17 @@ function persistenceAdapterContract(options) {
     });
     (0, import_node_test.test)("a line keeps the currency and the tax it was booked with", async (t) => {
       const contracts = harness.adapter.subscriptionContractRepository;
-      if (!contracts) {
+      const createSubscriber = harness.seed.createSubscriber;
+      if (!contracts || !createSubscriber) {
         missing(t, "subscriptionContracts");
         return;
       }
       const tenantId = "tenant-contract-money-facts";
+      const { subscriberId } = await createSubscriber({ legalName: "Z\xFCrich AG" });
+      const parties = { ...partiesWith(subscriberId, "Z\xFCrich AG"), issuer: null };
       const created = await contracts.create({
         tenantId,
+        parties,
         effectiveFrom: /* @__PURE__ */ new Date("2026-01-01T00:00:00.000Z"),
         priceSnapshot: {
           currency: "CHF",
@@ -1665,6 +1786,414 @@ function persistenceAdapterContract(options) {
         );
       }
     });
+    (0, import_node_test.test)("a contract written on a transaction is undone with it, and found by its offer", async (t) => {
+      const { adapter, seed } = harness;
+      const contracts = adapter.subscriptionContractRepository;
+      if (!contracts || !seed.createSubscriber) {
+        missing(t, "subscriptionContracts");
+        return;
+      }
+      if (!adapter.capabilities.transactions) {
+        t.skip("adapter declares no transaction capability");
+        return;
+      }
+      const { subscriberId } = await seed.createSubscriber({ legalName: "Angebot GmbH" });
+      const parties = partiesWith(subscriberId, "Angebot GmbH");
+      await import_strict.default.rejects(
+        adapter.transactionRunner.run(async (tx) => {
+          await contracts.create(contractFromOffer("offer-rolled-back", parties), tx);
+          throw new Error("the conclusion fails after the contract is written");
+        })
+      );
+      import_strict.default.equal(
+        await contracts.findByOriginalOfferId("offer-rolled-back"),
+        null,
+        "the contract outlived its transaction"
+      );
+      const kept = await adapter.transactionRunner.run(
+        (tx) => contracts.create(contractFromOffer("offer-kept", parties), tx)
+      );
+      const found = await contracts.findByOriginalOfferId("offer-kept");
+      import_strict.default.equal(found?.id, kept.id);
+      import_strict.default.equal(found?.lineItems.length, 1, "with its lines");
+      import_strict.default.equal(await contracts.findByOriginalOfferId("offer-nobody-concluded"), null);
+    });
+    (0, import_node_test.test)("a subscriber is created live for its tenant, and numbered by the database", async (t) => {
+      const subscribers = harness.adapter.subscriberRepository;
+      if (!subscribers) {
+        missing(t, "subscribers");
+        return;
+      }
+      const first = await subscribers.createForTenant({
+        ...subscriberFor("tenant-subscriber-first", "Erste Autohaus GmbH"),
+        vatId: "DE123456789",
+        addressLine1: "Hauptstra\xDFe 1",
+        postalCode: "10115",
+        city: "Berlin",
+        country: "DE",
+        invoiceEmail: "rechnung@erste.example",
+        customerNumberPrefix: "K-"
+      });
+      const second = await subscribers.createForTenant(
+        subscriberFor("tenant-subscriber-second", "Zweiter Verein e.V.")
+      );
+      import_strict.default.ok(first && second, "both tenants had no subscriber");
+      const numberOf = (customerNumber) => Number(customerNumber.replace("K-", ""));
+      import_strict.default.ok(first.customerNumber.startsWith("K-"), first.customerNumber);
+      import_strict.default.equal(numberOf(second.customerNumber), numberOf(first.customerNumber) + 1);
+      import_strict.default.ok(numberOf(first.customerNumber) >= 10001, first.customerNumber);
+      const found = await subscribers.findByTenantId("tenant-subscriber-first");
+      import_strict.default.deepEqual(
+        found && {
+          id: found.id,
+          customerNumber: found.customerNumber,
+          tenantId: found.tenantId,
+          legalName: found.legalName,
+          vatId: found.vatId,
+          taxNumber: found.taxNumber,
+          addressLine1: found.addressLine1,
+          addressLine2: found.addressLine2,
+          postalCode: found.postalCode,
+          city: found.city,
+          country: found.country,
+          invoiceEmail: found.invoiceEmail,
+          migrated: found.migrated
+        },
+        {
+          id: first.id,
+          customerNumber: first.customerNumber,
+          tenantId: "tenant-subscriber-first",
+          legalName: "Erste Autohaus GmbH",
+          vatId: "DE123456789",
+          // The nullable half, so an adapter writing '' is caught too.
+          taxNumber: null,
+          addressLine1: "Hauptstra\xDFe 1",
+          addressLine2: null,
+          postalCode: "10115",
+          city: "Berlin",
+          country: "DE",
+          invoiceEmail: "rechnung@erste.example",
+          migrated: false
+        }
+      );
+      import_strict.default.equal(
+        (await subscribers.findById(second.id))?.tenantId,
+        "tenant-subscriber-second"
+      );
+      import_strict.default.equal(await subscribers.findByTenantId("tenant-without-subscriber"), null);
+      import_strict.default.equal(await subscribers.findById("subscriber-nobody-created"), null);
+    });
+    (0, import_node_test.test)("a tenant has one live subscriber: a second is refused, and the transaction survives it", async (t) => {
+      const { adapter } = harness;
+      const subscribers = adapter.subscriberRepository;
+      if (!subscribers) {
+        missing(t, "subscribers");
+        return;
+      }
+      if (!adapter.capabilities.transactions) {
+        t.skip("adapter declares no transaction capability");
+        return;
+      }
+      const first = await subscribers.createForTenant(
+        subscriberFor("tenant-one-subscriber", "Einzig GmbH")
+      );
+      const afterRefusal = await adapter.transactionRunner.run(async (tx) => {
+        const refused = await subscribers.createForTenant(
+          subscriberFor("tenant-one-subscriber", "Doppelt GmbH"),
+          tx
+        );
+        import_strict.default.equal(refused, null, "a second live subscriber was created");
+        return subscribers.createForTenant(
+          subscriberFor("tenant-after-refusal", "Danach GmbH"),
+          tx
+        );
+      });
+      import_strict.default.equal(
+        (await subscribers.findByTenantId("tenant-one-subscriber"))?.id,
+        first?.id
+      );
+      import_strict.default.equal(
+        (await subscribers.findByTenantId("tenant-after-refusal"))?.id,
+        afterRefusal?.id,
+        "the transaction did not survive the refusal"
+      );
+    });
+    (0, import_node_test.test)("creating a subscriber for one tenant twice at once ends with one", async (t) => {
+      const subscribers = harness.adapter.subscriberRepository;
+      if (!subscribers) {
+        missing(t, "subscribers");
+        return;
+      }
+      const results = await Promise.all([
+        subscribers.createForTenant(subscriberFor("tenant-at-once", "Gleichzeitig A")),
+        subscribers.createForTenant(subscriberFor("tenant-at-once", "Gleichzeitig B"))
+      ]);
+      const created = results.filter((result) => result !== null);
+      import_strict.default.equal(created.length, 1, `${created.length} subscribers were created`);
+      import_strict.default.equal((await subscribers.findByTenantId("tenant-at-once"))?.id, created[0].id);
+    });
+    (0, import_node_test.test)("a subscriber written on a transaction is undone with it", async (t) => {
+      const { adapter } = harness;
+      const subscribers = adapter.subscriberRepository;
+      if (!subscribers) {
+        missing(t, "subscribers");
+        return;
+      }
+      if (!adapter.capabilities.transactions) {
+        t.skip("adapter declares no transaction capability");
+        return;
+      }
+      await import_strict.default.rejects(
+        adapter.transactionRunner.run(async (tx) => {
+          await subscribers.createForTenant(
+            subscriberFor("tenant-rolled-back", "Zur\xFCckgerollt GmbH"),
+            tx
+          );
+          throw new Error("the tenant is not created after all");
+        })
+      );
+      import_strict.default.equal(await subscribers.findByTenantId("tenant-rolled-back"), null);
+      import_strict.default.ok(
+        await subscribers.createForTenant(
+          subscriberFor("tenant-rolled-back", "Zur\xFCckgerollt GmbH")
+        )
+      );
+    });
+    (0, import_node_test.test)("a contact change writes what it names and keeps the rest", async (t) => {
+      const subscribers = harness.adapter.subscriberRepository;
+      if (!subscribers) {
+        missing(t, "subscribers");
+        return;
+      }
+      const created = await subscribers.createForTenant({
+        ...subscriberFor("tenant-contact", "Kontakt GmbH"),
+        addressLine2: "Hinterhaus",
+        city: "Hamburg"
+      });
+      import_strict.default.ok(created);
+      const changed = await subscribers.updateContact(created.id, {
+        city: "Bremen",
+        addressLine2: null,
+        invoiceEmail: "buchhaltung@kontakt.example"
+      });
+      import_strict.default.deepEqual(
+        changed && [
+          changed.city,
+          changed.addressLine2,
+          changed.invoiceEmail,
+          changed.legalName,
+          changed.tenantId
+        ],
+        ["Bremen", null, "buchhaltung@kontakt.example", "Kontakt GmbH", "tenant-contact"]
+      );
+      import_strict.default.equal((await subscribers.findById(created.id))?.city, "Bremen");
+      import_strict.default.equal(
+        await subscribers.updateContact("subscriber-nobody-created", { city: "Kiel" }),
+        null
+      );
+    });
+    (0, import_node_test.test)("a correction records the values it replaced, and nothing when nothing moves", async (t) => {
+      const subscribers = harness.adapter.subscriberRepository;
+      if (!subscribers) {
+        missing(t, "subscribers");
+        return;
+      }
+      const created = await subscribers.createForTenant(
+        subscriberFor("tenant-correction", "Mueller GmbH")
+      );
+      import_strict.default.ok(created);
+      const at = (day) => new Date(Date.UTC(2026, 8, day));
+      const first = await subscribers.correctIdentity(created.id, {
+        corrected: { legalName: "M\xFCller GmbH", vatId: "DE123456789", taxNumber: null },
+        reason: "Umlaut lost when the registration was typed",
+        correctedBy: "operator:anna",
+        correctedAt: at(1)
+      });
+      import_strict.default.deepEqual(
+        first?.correction && {
+          previous: first.correction.previous,
+          corrected: first.correction.corrected,
+          reason: first.correction.reason,
+          correctedBy: first.correction.correctedBy,
+          correctedAt: first.correction.correctedAt.getTime()
+        },
+        {
+          previous: { legalName: "Mueller GmbH", vatId: null },
+          corrected: { legalName: "M\xFCller GmbH", vatId: "DE123456789" },
+          reason: "Umlaut lost when the registration was typed",
+          correctedBy: "operator:anna",
+          correctedAt: at(1).getTime()
+        }
+      );
+      import_strict.default.equal(first?.subscriber.legalName, "M\xFCller GmbH");
+      import_strict.default.equal((await subscribers.findById(created.id))?.vatId, "DE123456789");
+      const unchanged = await subscribers.correctIdentity(created.id, {
+        corrected: { legalName: "M\xFCller GmbH" },
+        reason: "Clicked twice",
+        correctedBy: "operator:anna",
+        correctedAt: at(2)
+      });
+      import_strict.default.equal(
+        unchanged?.correction,
+        null,
+        "a correction that moved nothing was recorded"
+      );
+      await subscribers.correctIdentity(created.id, {
+        corrected: { vatId: "DE999999999" },
+        reason: "Wrong VAT id on the first correction",
+        correctedBy: "operator:ben",
+        correctedAt: at(3)
+      });
+      const listed = await subscribers.listCorrections(created.id);
+      import_strict.default.deepEqual(
+        listed.map((correction) => correction.reason),
+        [
+          "Wrong VAT id on the first correction",
+          "Umlaut lost when the registration was typed"
+        ],
+        "corrections come back the latest first, and only the two that moved something"
+      );
+      import_strict.default.equal(
+        await subscribers.correctIdentity("subscriber-nobody-created", {
+          corrected: { legalName: "Niemand" },
+          reason: "none",
+          correctedBy: "operator:anna",
+          correctedAt: at(4)
+        }),
+        null
+      );
+    });
+    (0, import_node_test.test)("two corrections at once each record the value the other left behind", async (t) => {
+      const { adapter } = harness;
+      const subscribers = adapter.subscriberRepository;
+      if (!subscribers) {
+        missing(t, "subscribers");
+        return;
+      }
+      if (!adapter.capabilities.transactions || !adapter.capabilities.pessimisticLocking) {
+        t.skip("adapter declares no transactions or no row locks");
+        return;
+      }
+      const created = await subscribers.createForTenant(
+        subscriberFor("tenant-corrected-twice", "Original GmbH")
+      );
+      import_strict.default.ok(created);
+      const correctTo = (legalName) => adapter.transactionRunner.run(async (tx) => {
+        await subscribers.correctIdentity(
+          created.id,
+          {
+            corrected: { legalName },
+            reason: `to ${legalName}`,
+            correctedBy: "operator:anna",
+            correctedAt: /* @__PURE__ */ new Date()
+          },
+          tx
+        );
+        await sleep(LOCK_HOLD_MS);
+      });
+      await Promise.all([
+        correctTo("Erste Korrektur GmbH"),
+        correctTo("Zweite Korrektur GmbH")
+      ]);
+      const listed = await subscribers.listCorrections(created.id);
+      import_strict.default.equal(listed.length, 2);
+      const replaced = listed.map((correction) => correction.previous.legalName).sort();
+      const written = listed.map((correction) => correction.corrected.legalName);
+      const current = (await subscribers.findById(created.id))?.legalName;
+      import_strict.default.ok(replaced.includes("Original GmbH"), JSON.stringify(listed));
+      const secondReplaced = replaced.find((name) => name !== "Original GmbH");
+      import_strict.default.ok(
+        secondReplaced !== void 0 && written.includes(secondReplaced),
+        `a correction recorded a value it did not replace: ${JSON.stringify(listed)}`
+      );
+      import_strict.default.ok(current !== void 0 && written.includes(current));
+      import_strict.default.notEqual(secondReplaced, current);
+    });
+    (0, import_node_test.test)("a contract keeps its subscriber's copy after the subscriber is corrected", async (t) => {
+      const { adapter } = harness;
+      const subscribers = adapter.subscriberRepository;
+      const contracts = adapter.subscriptionContractRepository;
+      if (!subscribers) {
+        missing(t, "subscribers");
+        return;
+      }
+      if (!contracts || !harness.seed.createSubscriber) {
+        missing(t, "subscriptionContracts");
+        return;
+      }
+      const subscriber = await subscribers.createForTenant(
+        subscriberFor("tenant-copy-kept", "Vorher GmbH")
+      );
+      import_strict.default.ok(subscriber);
+      const parties = partiesWith(subscriber.id, "Vorher GmbH");
+      const contract = await contracts.create({
+        ...contractFromOffer("offer-copy-kept", parties),
+        tenantId: "tenant-copy-kept"
+      });
+      await subscribers.correctIdentity(subscriber.id, {
+        corrected: { legalName: "Nachher GmbH" },
+        reason: "Change of name of the same company",
+        correctedBy: "operator:anna",
+        correctedAt: /* @__PURE__ */ new Date()
+      });
+      const readBack = await contracts.findById(contract.id);
+      import_strict.default.equal(readBack?.subscriberId, subscriber.id);
+      import_strict.default.equal(
+        readBack?.subscriber.legalName,
+        "Vorher GmbH",
+        "the contract followed a correction of the live record"
+      );
+    });
+    (0, import_node_test.test)("an offer is consumed once, whoever asks first", async (t) => {
+      const offers = harness.adapter.checkoutOfferRepository;
+      if (!offers) {
+        missing(t, "checkoutOffers");
+        return;
+      }
+      const offer = await offers.create(OFFER);
+      import_strict.default.equal(offer.status, "open");
+      const attempts = await Promise.allSettled([
+        offers.consume(offer.id),
+        offers.consume(offer.id)
+      ]);
+      import_strict.default.equal(
+        attempts.filter((attempt) => attempt.status === "fulfilled").length,
+        1,
+        "exactly one consume wins"
+      );
+      const consumed = await offers.findById(offer.id);
+      import_strict.default.equal(consumed?.status, "consumed");
+      import_strict.default.ok(consumed?.consumedAt, "and it records when");
+      await import_strict.default.rejects(() => offers.consume(offer.id), "a later consume is refused");
+      import_strict.default.equal(
+        (await offers.findById(offer.id))?.consumedAt,
+        consumed.consumedAt,
+        "and changes nothing"
+      );
+    });
+    (0, import_node_test.test)("a consume on a transaction that rolls back leaves the offer open", async (t) => {
+      const { adapter } = harness;
+      const offers = adapter.checkoutOfferRepository;
+      if (!offers) {
+        missing(t, "checkoutOffers");
+        return;
+      }
+      if (!adapter.capabilities.transactions) {
+        t.skip("adapter declares no transaction capability");
+        return;
+      }
+      const offer = await offers.create(OFFER);
+      await import_strict.default.rejects(
+        adapter.transactionRunner.run(async (tx) => {
+          await offers.consume(offer.id, tx);
+          throw new Error("the contract after the consume fails");
+        })
+      );
+      const afterwards = await offers.findById(offer.id);
+      import_strict.default.equal(afterwards?.status, "open", "the consume outlived its transaction");
+      import_strict.default.equal(afterwards?.consumedAt, null);
+      import_strict.default.equal((await offers.consume(offer.id)).status, "consumed");
+    });
     const SETTINGS = {
       app: { name: "Demo" },
       currency: "EUR",