@saasicat/persistence-testing 1.0.0-rc.6 → 1.0.0-rc.8

package/README.md

@@ -46,7 +46,6 @@ import { persistenceAdapterContract } from '@saasicat/persistence-testing';
 
 persistenceAdapterContract({
     name: 'adapter-drizzle @ postgres',
-    projectKey: 'my-app',
     create: async () => ({
         adapter: {
             capabilities: { transactions: true, pessimisticLocking: true /* … */ },
@@ -81,4 +80,5 @@ scenarios gate off, visibly).
 ## Next
 
 - [Ports and adapters](../../docs/explanation/adr/0007-ports-and-adapters.md) — what a port promises
-- [Test coverage](../../docs/explanation/test-coverage.md) — what this contract reaches, and what it does not
+- [Test coverage](../../docs/explanation/test-coverage.md) — what this contract reaches, and what it
+  does not

package/dist/.build-stamp

@@ -1 +1 @@
-ebc7b4a96e9a57e93d8e7e38f708e2c44f7953784e74366e0391473dd2908f3f
+88264ec951b4befd31dea5d94e1cd92fe5953dca67eb08539e2e0f1d2453fabb

package/dist/index.cjs

@@ -260,11 +260,10 @@ function persistenceAdapterContract(options) {
         return;
       }
       const plan = await repository.create({
-        projectKey: options.projectKey,
         planKey: "STANDARD",
         label: "Standard"
       });
-      import_strict.default.equal(plan.projectKey, options.projectKey);
+      import_strict.default.equal(plan.planKey, "STANDARD");
       const firstDraft = await repository.createPlanVersionDraft({
         planId: "STANDARD",
         features: ["CORE"],
@@ -325,11 +324,10 @@ function persistenceAdapterContract(options) {
         return;
       }
       const bundle = await repository.create({
-        projectKey: options.projectKey,
         bundleKey: "REPORTING",
         label: "Reporting"
       });
-      import_strict.default.equal(bundle.projectKey, options.projectKey);
+      import_strict.default.equal(bundle.bundleKey, "REPORTING");
       const firstDraft = await repository.createDraft({
         bundleId: bundle.id,
         features: ["REPORTS"],
@@ -377,6 +375,375 @@ function persistenceAdapterContract(options) {
         second.id
       );
     });
+    (0, import_node_test.test)("a booking keeps the rhythm and the window it was made in", async (t) => {
+      const repository = harness.adapter.subscriptionBundleRepository;
+      const { seed } = harness;
+      if (!repository || !seed.createBundleVersion) {
+        t.skip("adapter provides no SubscriptionBundleRepository or bundle catalog");
+        return;
+      }
+      const { planVersionId } = await seed.createPlanVersion({
+        planKey: "PRO",
+        version: 1,
+        quotas: {},
+        features: ["CORE"],
+        published: true
+      });
+      const { subscriptionId } = await seed.createSubscription({
+        tenantId: "tenant-bundle-period",
+        plan: "PRO",
+        planVersionId,
+        billingCycle: "YEARLY"
+      });
+      const { bundleVersionId } = await seed.createBundleVersion({
+        bundleKey: "ANALYTICS",
+        features: ["REPORTS"]
+      });
+      const booked = await repository.add({
+        subscriptionId,
+        bundleVersionId,
+        startedAt: /* @__PURE__ */ new Date("2026-02-21T00:00:00.000Z"),
+        minimumTermEndsAt: null,
+        billingCycle: "MONTHLY",
+        currentPeriodStart: /* @__PURE__ */ new Date("2026-02-21T00:00:00.000Z"),
+        currentPeriodEnd: /* @__PURE__ */ new Date("2026-02-28T00:00:00.000Z")
+      });
+      import_strict.default.equal(booked.billingCycle, "MONTHLY");
+      const [readBack] = await repository.listBySubscription(subscriptionId);
+      import_strict.default.ok(readBack, "the booking must be readable back");
+      import_strict.default.equal(readBack.billingCycle, "MONTHLY");
+      import_strict.default.equal(
+        readBack.currentPeriodEnd?.toISOString(),
+        "2026-02-28T00:00:00.000Z",
+        "the period end must survive the round trip"
+      );
+      import_strict.default.equal(readBack.currentPeriodStart?.toISOString(), "2026-02-21T00:00:00.000Z");
+      const legacy = await repository.add({
+        subscriptionId,
+        bundleVersionId,
+        startedAt: /* @__PURE__ */ new Date("2026-01-01T00:00:00.000Z"),
+        minimumTermEndsAt: null
+      });
+      const legacyReadBack = await repository.findById(legacy.id);
+      import_strict.default.ok(legacyReadBack, "the legacy booking must be readable back");
+      import_strict.default.equal(legacyReadBack.billingCycle, null);
+      import_strict.default.equal(legacyReadBack.currentPeriodStart, null);
+      import_strict.default.equal(legacyReadBack.currentPeriodEnd, null);
+    });
+    (0, import_node_test.test)("a second cancellation of one booking is refused, not applied", async (t) => {
+      const repository = harness.adapter.subscriptionBundleRepository;
+      const { seed } = harness;
+      if (!repository || !seed.createBundleVersion) {
+        t.skip("adapter provides no SubscriptionBundleRepository or bundle catalog");
+        return;
+      }
+      const { planVersionId } = await seed.createPlanVersion({
+        planKey: "PRO",
+        version: 1,
+        quotas: {},
+        features: ["CORE"],
+        published: true
+      });
+      const { subscriptionId } = await seed.createSubscription({
+        tenantId: "tenant-double-cancel",
+        plan: "PRO",
+        planVersionId
+      });
+      const { bundleVersionId } = await seed.createBundleVersion({
+        bundleKey: "ANALYTICS",
+        features: ["REPORTS"]
+      });
+      const booking = await repository.add({
+        subscriptionId,
+        bundleVersionId,
+        startedAt: /* @__PURE__ */ new Date("2026-01-01T00:00:00.000Z"),
+        minimumTermEndsAt: null
+      });
+      const first = await repository.cancel(booking.id, {
+        canceledAt: /* @__PURE__ */ new Date("2026-03-01T00:00:00.000Z"),
+        canceledEffectiveAt: /* @__PURE__ */ new Date("2026-04-01T00:00:00.000Z")
+      });
+      import_strict.default.equal(first.canceledEffectiveAt?.toISOString(), "2026-04-01T00:00:00.000Z");
+      await import_strict.default.rejects(
+        () => repository.cancel(booking.id, {
+          canceledAt: /* @__PURE__ */ new Date("2026-03-02T00:00:00.000Z"),
+          canceledEffectiveAt: /* @__PURE__ */ new Date("2026-09-01T00:00:00.000Z")
+        }),
+        "a second cancellation must be refused"
+      );
+      const readBack = await repository.findById(booking.id);
+      import_strict.default.equal(
+        readBack?.canceledEffectiveAt?.toISOString(),
+        "2026-04-01T00:00:00.000Z",
+        "the first cancellation must still stand"
+      );
+      await repository.reactivate(booking.id);
+      const again = await repository.cancel(booking.id, {
+        canceledAt: /* @__PURE__ */ new Date("2026-03-02T00:00:00.000Z"),
+        canceledEffectiveAt: /* @__PURE__ */ new Date("2026-09-01T00:00:00.000Z")
+      });
+      import_strict.default.equal(again.canceledEffectiveAt?.toISOString(), "2026-09-01T00:00:00.000Z");
+    });
+    (0, import_node_test.test)("a subscription's bookings come back newest first", async (t) => {
+      const repository = harness.adapter.subscriptionBundleRepository;
+      const { seed } = harness;
+      if (!repository || !seed.createBundleVersion) {
+        t.skip("adapter provides no SubscriptionBundleRepository or bundle catalog");
+        return;
+      }
+      const { planVersionId } = await seed.createPlanVersion({
+        planKey: "PRO",
+        version: 1,
+        quotas: {},
+        features: ["CORE"],
+        published: true
+      });
+      const { subscriptionId } = await seed.createSubscription({
+        tenantId: "tenant-booking-order",
+        plan: "PRO",
+        planVersionId
+      });
+      for (const [key, startedAt] of [
+        ["OLDEST", "2026-01-01T00:00:00.000Z"],
+        ["MIDDLE", "2026-02-01T00:00:00.000Z"],
+        ["NEWEST", "2026-03-01T00:00:00.000Z"]
+      ]) {
+        const { bundleVersionId } = await seed.createBundleVersion({
+          bundleKey: key,
+          features: ["REPORTS"]
+        });
+        await repository.add({
+          subscriptionId,
+          bundleVersionId,
+          startedAt: new Date(startedAt),
+          minimumTermEndsAt: null
+        });
+      }
+      const listed = await repository.listBySubscription(subscriptionId);
+      import_strict.default.deepEqual(
+        listed.map((row) => row.startedAt.toISOString()),
+        [
+          "2026-03-01T00:00:00.000Z",
+          "2026-02-01T00:00:00.000Z",
+          "2026-01-01T00:00:00.000Z"
+        ]
+      );
+    });
+    (0, import_node_test.test)("a booking with no request date is active, whatever its effective date says", async (t) => {
+      const repository = harness.adapter.subscriptionBundleRepository;
+      const { seed } = harness;
+      if (!repository || !seed.createBundleVersion) {
+        t.skip("adapter provides no SubscriptionBundleRepository or bundle catalog");
+        return;
+      }
+      const { planVersionId } = await seed.createPlanVersion({
+        planKey: "PRO",
+        version: 1,
+        quotas: {},
+        features: ["CORE"],
+        published: true
+      });
+      const { subscriptionId } = await seed.createSubscription({
+        tenantId: "tenant-half-cancelled",
+        plan: "PRO",
+        planVersionId
+      });
+      const { bundleVersionId } = await seed.createBundleVersion({
+        bundleKey: "ANALYTICS",
+        features: ["REPORTS"]
+      });
+      const booking = await repository.add({
+        subscriptionId,
+        bundleVersionId,
+        startedAt: /* @__PURE__ */ new Date("2026-01-01T00:00:00.000Z"),
+        minimumTermEndsAt: null
+      });
+      await repository.cancel(booking.id, {
+        canceledAt: /* @__PURE__ */ new Date("2026-02-01T00:00:00.000Z"),
+        canceledEffectiveAt: /* @__PURE__ */ new Date("2026-03-01T00:00:00.000Z")
+      });
+      const clearRequestDate = harness.seed.clearBookingRequestDate;
+      if (!clearRequestDate) {
+        t.skip("adapter harness cannot write the half-cancelled shape");
+        return;
+      }
+      await clearRequestDate(booking.id);
+      const active = await repository.listActiveBySubscription(
+        subscriptionId,
+        /* @__PURE__ */ new Date("2026-06-01T00:00:00.000Z")
+      );
+      import_strict.default.equal(active.length, 1, "no request date means nobody asked to cancel it");
+      import_strict.default.equal(
+        await repository.countActiveByBundleVersionId(
+          bundleVersionId,
+          /* @__PURE__ */ new Date("2026-06-01T00:00:00.000Z")
+        ),
+        1
+      );
+    });
+    (0, import_node_test.test)("discarding a draft cannot remove a version published meanwhile", async (t) => {
+      const catalog = harness.adapter.bundleRepository;
+      const discardDraft = catalog?.deleteDraft?.bind(catalog);
+      if (!catalog || !discardDraft) {
+        t.skip("adapter provides no BundleRepository");
+        return;
+      }
+      const bundle = await catalog.create({
+        bundleKey: "RACE",
+        label: "Race"
+      });
+      const draft = await catalog.createDraft({
+        bundleId: bundle.id,
+        features: ["REPORTS"],
+        quotas: {}
+      });
+      await catalog.publishDraft(draft.id, {
+        publishedByUserId: null,
+        publishedChanges: [],
+        nonRegressive: true,
+        validFrom: /* @__PURE__ */ new Date("2026-01-01T00:00:00.000Z"),
+        validUntil: null
+      });
+      await import_strict.default.rejects(
+        () => discardDraft(draft.id),
+        "a published version must not be discardable"
+      );
+      import_strict.default.ok(
+        await catalog.findVersionById(draft.id),
+        "and it must still be there afterwards"
+      );
+    });
+    (0, import_node_test.test)("publishing one draft twice claims it once, and the windows stay adjacent", async (t) => {
+      const catalog = harness.adapter.bundleRepository;
+      const publish = catalog?.publishDraft?.bind(catalog);
+      if (!catalog || !publish) {
+        t.skip("adapter provides no BundleRepository");
+        return;
+      }
+      const bundle = await catalog.create({
+        bundleKey: "CLAIM",
+        label: "Claim"
+      });
+      const first = await catalog.createDraft({
+        bundleId: bundle.id,
+        features: ["A"],
+        quotas: {}
+      });
+      await publish(first.id, {
+        publishedByUserId: null,
+        publishedChanges: [],
+        nonRegressive: true,
+        validFrom: /* @__PURE__ */ new Date("2026-01-01T00:00:00.000Z"),
+        validUntil: null
+      });
+      const second = await catalog.createDraft({
+        bundleId: bundle.id,
+        baseVersionId: first.id,
+        features: ["A", "B"],
+        quotas: {}
+      });
+      const publishedAt = /* @__PURE__ */ new Date("2026-03-01T00:00:00.000Z");
+      await publish(second.id, {
+        publishedByUserId: null,
+        publishedChanges: [],
+        nonRegressive: true,
+        validFrom: publishedAt,
+        validUntil: null
+      });
+      await import_strict.default.rejects(
+        () => publish(second.id, {
+          publishedByUserId: null,
+          publishedChanges: [],
+          nonRegressive: true,
+          validFrom: /* @__PURE__ */ new Date("2026-06-01T00:00:00.000Z"),
+          validUntil: null
+        }),
+        "a version that is already published must not be published again"
+      );
+      const successor = await catalog.findVersionById(second.id);
+      const predecessor = await catalog.findVersionById(first.id);
+      import_strict.default.equal(
+        successor?.validFrom && new Date(successor.validFrom).toISOString(),
+        publishedAt.toISOString(),
+        "the winning date must still stand"
+      );
+      import_strict.default.ok(predecessor?.supersededAt, "the predecessor must be superseded");
+      if (predecessor?.validUntil) {
+        const closesAt = new Date(predecessor.validUntil);
+        import_strict.default.equal(
+          closesAt.toISOString().slice(0, 10),
+          "2026-02-28",
+          "the predecessor must close the day before its successor opens"
+        );
+      }
+    });
+    (0, import_node_test.test)("a plan key names one plan for the whole installation", async (t) => {
+      const repository = harness.adapter.planRepository;
+      if (!repository) {
+        t.skip("adapter provides no PlanRepository");
+        return;
+      }
+      await repository.create({ planKey: "DOUBLE", label: "First" });
+      await import_strict.default.rejects(
+        () => repository.create({ planKey: "DOUBLE", label: "Second" }),
+        "a plan key is taken once"
+      );
+    });
+    (0, import_node_test.test)("a bundle key names one bundle for the whole installation", async (t) => {
+      const catalog = harness.adapter.bundleRepository;
+      if (!catalog) {
+        t.skip("adapter provides no BundleRepository");
+        return;
+      }
+      await catalog.create({ bundleKey: "DOUBLE", label: "First" });
+      await import_strict.default.rejects(
+        () => catalog.create({ bundleKey: "DOUBLE", label: "Second" }),
+        "a bundle key is taken once"
+      );
+    });
+    (0, import_node_test.test)("a retired plan still occupies its key", async (t) => {
+      const repository = harness.adapter.planRepository;
+      const retire = repository?.softDelete?.bind(repository);
+      const byKey = repository?.findByKey?.bind(repository);
+      if (!repository || !retire || !byKey) {
+        t.skip("adapter provides no PlanRepository");
+        return;
+      }
+      const plan = await repository.create({ planKey: "RETIRED_PLAN", label: "Retired" });
+      await retire(plan.id);
+      const stillThere = await byKey("RETIRED_PLAN");
+      import_strict.default.equal(stillThere?.id, plan.id, "the key is not free again");
+      import_strict.default.ok(stillThere?.deletedAt, "and the row says it is retired");
+      import_strict.default.equal(
+        (await repository.list({})).some((row) => row.id === plan.id),
+        false,
+        "a retired plan is not in the catalogue an operator browses"
+      );
+    });
+    (0, import_node_test.test)("a retired bundle still occupies its key", async (t) => {
+      const catalog = harness.adapter.bundleRepository;
+      const retire = catalog?.softDelete?.bind(catalog);
+      const byKey = catalog?.findByKey?.bind(catalog);
+      if (!catalog || !retire || !byKey) {
+        t.skip("adapter provides no BundleRepository");
+        return;
+      }
+      const bundle = await catalog.create({
+        bundleKey: "RETIRED_KEY",
+        label: "Retired"
+      });
+      import_strict.default.equal((await byKey("RETIRED_KEY"))?.id, bundle.id);
+      await retire(bundle.id);
+      const stillThere = await byKey("RETIRED_KEY");
+      import_strict.default.equal(stillThere?.id, bundle.id, "the key is not free again");
+      import_strict.default.ok(stillThere?.deletedAt, "and the row says it is retired");
+      const listed = await catalog.list({});
+      import_strict.default.equal(
+        listed.some((row) => row.id === bundle.id),
+        false,
+        "a retired bundle is not in the catalogue an operator browses"
+      );
+    });
     (0, import_node_test.test)("countByPlanVersionId counts current AND pending bindings in one query", async (t) => {
       const { seed, adapter } = harness;
       if (!adapter.subscriptionRepository.countByPlanVersionId) {
@@ -747,13 +1114,245 @@ function persistenceAdapterContract(options) {
       import_strict.default.equal(seen?.id, subscriptionId);
       import_strict.default.equal(seen?.tenantId, "tenant-a");
     });
-    (0, import_node_test.test)("immutable subscription contracts (append-only, terminate-only)", (t) => {
-      if (!harness.adapter.subscriptionContractRepository) {
-        t.skip("adapter provides no SubscriptionContractRepository \u2014 scenario pending");
+    (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) {
+        t.skip("adapter provides no SubscriptionContractRepository");
+        return;
+      }
+      const tenantId = "tenant-contract-lifecycle";
+      const signedAt = /* @__PURE__ */ new Date("2026-01-01T00:00:00.000Z");
+      const created = await contracts.create({
+        tenantId,
+        effectiveFrom: signedAt,
+        priceSnapshot: {
+          currency: "EUR",
+          billingCycle: "monthly",
+          subtotalNet: 29.9,
+          discountNet: 0,
+          totalNet: 29.9,
+          vatRate: 19,
+          totalGross: 35.58
+        },
+        entitlementSnapshot: {
+          plan: "STANDARD",
+          features: ["CORE"],
+          quotas: { users: 5 }
+        },
+        originalBundleVersionIds: ["bundle-version-1"],
+        termsSnapshot: { noticePeriodDays: 30 },
+        lineItems: [
+          {
+            kind: "plan",
+            sourceKey: "STANDARD",
+            sourceVersionId: "plan-version-1",
+            titleSnapshot: "Standard",
+            descriptionSnapshot: "The plan as it was signed",
+            quantity: 1,
+            unit: null,
+            priceNet: 19.9,
+            priceGross: 23.68,
+            billingCycle: "monthly",
+            minimumTermUntil: /* @__PURE__ */ new Date("2027-01-01T00:00:00.000Z"),
+            featuresSnapshot: ["CORE"],
+            quotaEffectsSnapshot: { users: 5 },
+            metadata: { origin: "onboarding" }
+          },
+          {
+            kind: "bundle",
+            sourceKey: "EXTRA-SEATS",
+            sourceVersionId: "bundle-version-1",
+            titleSnapshot: "Extra seats",
+            descriptionSnapshot: null,
+            quantity: 1,
+            unit: "seat",
+            priceNet: 10,
+            priceGross: 11.9,
+            billingCycle: "monthly",
+            minimumTermUntil: null,
+            featuresSnapshot: [],
+            quotaEffectsSnapshot: { users: 5 },
+            metadata: null
+          }
+        ]
+      });
+      import_strict.default.equal(created.status, "active");
+      import_strict.default.equal(created.tenantId, tenantId);
+      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 });
+      const planLine = created.lineItems.find((item) => item.kind === "plan");
+      import_strict.default.ok(planLine, "plan line expected");
+      import_strict.default.equal(planLine.priceNet, 19.9, "money must survive the round trip unrounded");
+      import_strict.default.equal(planLine.priceGross, 23.68);
+      import_strict.default.equal(planLine.billingCycle, "monthly");
+      import_strict.default.deepEqual(planLine.quotaEffectsSnapshot, { users: 5 });
+      import_strict.default.equal(planLine.descriptionSnapshot, "The plan as it was signed");
+      import_strict.default.equal(
+        planLine.minimumTermUntil?.getTime(),
+        (/* @__PURE__ */ new Date("2027-01-01T00:00:00.000Z")).getTime(),
+        "the commitment is part of what was agreed"
+      );
+      import_strict.default.deepEqual(planLine.metadata, { origin: "onboarding" });
+      const bundleLine = created.lineItems.find((item) => item.kind === "bundle");
+      import_strict.default.ok(bundleLine, "bundle line expected");
+      import_strict.default.equal(bundleLine.descriptionSnapshot, null);
+      import_strict.default.equal(bundleLine.unit, "seat");
+      import_strict.default.equal(bundleLine.minimumTermUntil, null);
+      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.equal(
+        readBack.lineItems.length,
+        2,
+        "lines belong to the contract, not the call"
+      );
+      import_strict.default.equal(
+        (await contracts.findActiveByTenantId(
+          tenantId,
+          /* @__PURE__ */ new Date("2026-06-01T00:00:00.000Z")
+        ))?.id,
+        created.id
+      );
+      import_strict.default.equal(
+        await contracts.findActiveByTenantId(
+          tenantId,
+          /* @__PURE__ */ new Date("2025-12-31T23:59:59.999Z")
+        ),
+        null,
+        "a contract is not active before it starts"
+      );
+      const endsAt = /* @__PURE__ */ new Date("2026-07-01T00:00:00.000Z");
+      const terminated = await contracts.terminate(created.id, {
+        effectiveUntil: endsAt,
+        status: null
+      });
+      import_strict.default.equal(
+        terminated.status,
+        "active",
+        "a null status leaves the contract in the state it had"
+      );
+      import_strict.default.equal(terminated.effectiveUntil?.getTime(), endsAt.getTime());
+      import_strict.default.equal(terminated.lineItems.length, 2, "ending a contract keeps its lines");
+      import_strict.default.equal(
+        terminated.priceSnapshot.totalNet,
+        created.priceSnapshot.totalNet,
+        "ending a contract does not restate its price"
+      );
+      const afterEnd = await contracts.findById(created.id);
+      import_strict.default.ok(afterEnd, "a terminated contract is still readable");
+      import_strict.default.equal(afterEnd.lineItems.length, 2);
+      import_strict.default.equal(
+        (await contracts.findActiveByTenantId(
+          tenantId,
+          /* @__PURE__ */ new Date("2026-06-30T00:00:00.000Z")
+        ))?.id,
+        created.id,
+        "active up to the moment it ends"
+      );
+      import_strict.default.equal(
+        await contracts.findActiveByTenantId(tenantId, endsAt),
+        null,
+        "and not at that moment"
+      );
+    });
+    (0, import_node_test.test)("a successor takes over without erasing the contract it replaces", async (t) => {
+      const contracts = harness.adapter.subscriptionContractRepository;
+      if (!contracts) {
+        t.skip("adapter provides no SubscriptionContractRepository");
         return;
       }
-      import_strict.default.fail(
-        "SubscriptionContractRepository present but the contract kit has no scenario yet \u2014 extend the kit"
+      const tenantId = "tenant-contract-succession";
+      const handover = /* @__PURE__ */ new Date("2026-04-01T00:00:00.000Z");
+      const lineAt = (priceNet, priceGross) => ({
+        kind: "plan",
+        sourceKey: "STANDARD",
+        sourceVersionId: null,
+        titleSnapshot: "Standard",
+        descriptionSnapshot: null,
+        quantity: 1,
+        unit: null,
+        priceNet,
+        priceGross,
+        billingCycle: "monthly",
+        minimumTermUntil: null,
+        featuresSnapshot: [],
+        quotaEffectsSnapshot: {},
+        metadata: null
+      });
+      const priceAt = (net, gross) => ({
+        currency: "EUR",
+        billingCycle: "monthly",
+        subtotalNet: net,
+        discountNet: 0,
+        totalNet: net,
+        vatRate: 19,
+        totalGross: gross
+      });
+      const first = await contracts.create({
+        tenantId,
+        effectiveFrom: /* @__PURE__ */ new Date("2026-01-01T00:00:00.000Z"),
+        priceSnapshot: priceAt(19.9, 23.68),
+        lineItems: [lineAt(19.9, 23.68)]
+      });
+      import_strict.default.equal(
+        (await contracts.findActiveByTenantId(
+          tenantId,
+          /* @__PURE__ */ new Date("2026-03-31T00:00:00.000Z")
+        ))?.id,
+        first.id
+      );
+      await contracts.terminate(first.id, {
+        effectiveUntil: handover,
+        status: "superseded"
+      });
+      const second = await contracts.create({
+        tenantId,
+        effectiveFrom: handover,
+        priceSnapshot: priceAt(24.9, 29.63),
+        lineItems: [lineAt(24.9, 29.63)]
+      });
+      import_strict.default.equal(
+        (await contracts.findActiveByTenantId(tenantId, handover))?.id,
+        second.id,
+        "the successor takes over at the moment the predecessor ends"
+      );
+      import_strict.default.equal(
+        await contracts.findActiveByTenantId(
+          tenantId,
+          /* @__PURE__ */ new Date("2026-03-31T00:00:00.000Z")
+        ),
+        null,
+        "a superseded contract is not live at any asOf"
+      );
+      const superseded = await contracts.findById(first.id);
+      import_strict.default.equal(superseded?.status, "superseded");
+      import_strict.default.equal(
+        superseded?.priceSnapshot.totalNet,
+        19.9,
+        "the replaced contract keeps the price it was signed at"
+      );
+      const history = await contracts.list({ tenantId });
+      import_strict.default.equal(history.length, 2, "both contracts remain in the history");
+      import_strict.default.deepEqual(
+        history.map((contract) => contract.lineItems.map((item) => item.priceNet)),
+        [[24.9], [19.9]]
+      );
+      import_strict.default.deepEqual(
+        history.map((contract) => contract.id),
+        [second.id, first.id],
+        "newest first"
+      );
+      import_strict.default.deepEqual(
+        (await contracts.list({ tenantId, asOf: /* @__PURE__ */ new Date("2026-03-31T00:00:00.000Z") })).map((contract) => contract.id),
+        [first.id],
+        "asOf narrows the history to what was in force then"
+      );
+      import_strict.default.deepEqual(
+        (await contracts.list({ tenantId, status: "superseded" })).map(
+          (contract) => contract.id
+        ),
+        [first.id]
       );
     });
   });