@saasicat/nest 0.2.0

package/dist/testing/index.js

@@ -0,0 +1,1195 @@
+import {
+  SaasPlatformModule
+} from "../chunk-QJVPRD3R.js";
+import "../chunk-P6MYZMXQ.js";
+import "../chunk-Q53N43LQ.js";
+import "../chunk-E56W4U2P.js";
+import "../chunk-AJ3EPELS.js";
+import "../chunk-M6CZQYPY.js";
+import "../chunk-YXGHPILG.js";
+import "../chunk-MV6LW5UB.js";
+import "../chunk-NYLON2VC.js";
+import "../chunk-7MLGHWKO.js";
+import "../chunk-XCZ3TTFK.js";
+import "../chunk-SABTXESR.js";
+import "../chunk-L4SUWH5B.js";
+import {
+  __name
+} from "../chunk-SHUYVCID.js";
+
+// src/testing/fake-repositories.ts
+import { startOfUtcDay } from "@saasicat/types";
+var FakeSubscriptionRepository = class {
+  static {
+    __name(this, "FakeSubscriptionRepository");
+  }
+  byTenantId = /* @__PURE__ */ new Map();
+  /**
+   * Test stubs for the `countBy*` editability methods. Tests set them
+   * directly; default 0 (= "no subscription binds the version" →
+   * published-but-future versions are editable when they are latest-in-chain
+   * and validFrom lies in the future).
+   */
+  planVersionCounts = /* @__PURE__ */ new Map();
+  bundleVersionCounts = /* @__PURE__ */ new Map();
+  set(record) {
+    this.byTenantId.set(record.tenantId, record);
+  }
+  delete(tenantId) {
+    this.byTenantId.delete(tenantId);
+  }
+  clear() {
+    this.byTenantId.clear();
+    this.planVersionCounts.clear();
+    this.bundleVersionCounts.clear();
+  }
+  /** Test helper: force the number of subscriptions for a PlanVersion. */
+  setPlanVersionCount(planVersionId, count) {
+    this.planVersionCounts.set(planVersionId, count);
+  }
+  /** Test helper: force the number of subscriptions for a BundleVersion. */
+  setBundleVersionCount(bundleVersionId, count) {
+    this.bundleVersionCounts.set(bundleVersionId, count);
+  }
+  async findByTenantId(tenantId) {
+    return this.byTenantId.get(tenantId) ?? null;
+  }
+  async findByTenantIdLocked(tenantId, _tx) {
+    return this.findByTenantId(tenantId);
+  }
+  async countByPlanVersionId(planVersionId) {
+    return this.planVersionCounts.get(planVersionId) ?? 0;
+  }
+  async countByBundleVersionId(bundleVersionId) {
+    return this.bundleVersionCounts.get(bundleVersionId) ?? 0;
+  }
+};
+var FakeSubscriptionBundleRepository = class {
+  static {
+    __name(this, "FakeSubscriptionBundleRepository");
+  }
+  byId = /* @__PURE__ */ new Map();
+  nextId = 1;
+  now() {
+    return /* @__PURE__ */ new Date("2026-01-01T00:00:00.000Z");
+  }
+  clear() {
+    this.byId.clear();
+  }
+  async listBySubscription(subscriptionId) {
+    return [
+      ...this.byId.values()
+    ].filter((r) => r.subscriptionId === subscriptionId).sort((a, b) => b.startedAt.getTime() - a.startedAt.getTime());
+  }
+  async findById(subscriptionBundleId) {
+    return this.byId.get(subscriptionBundleId) ?? null;
+  }
+  async listActiveBySubscription(subscriptionId, asOf = /* @__PURE__ */ new Date()) {
+    return [
+      ...this.byId.values()
+    ].filter((r) => r.subscriptionId === subscriptionId && (r.canceledAt === null || r.canceledEffectiveAt !== null && r.canceledEffectiveAt.getTime() > asOf.getTime()));
+  }
+  async add(data) {
+    const id = `sub-bundle-${this.nextId++}`;
+    const createdAt = this.now();
+    const row = {
+      id,
+      subscriptionId: data.subscriptionId,
+      bundleVersionId: data.bundleVersionId,
+      startedAt: data.startedAt,
+      minimumTermEndsAt: data.minimumTermEndsAt ?? null,
+      canceledAt: null,
+      canceledEffectiveAt: null,
+      createdAt,
+      updatedAt: createdAt
+    };
+    this.byId.set(id, row);
+    return row;
+  }
+  async cancel(subscriptionBundleId, data) {
+    const existing = this.byId.get(subscriptionBundleId);
+    if (!existing) {
+      throw new Error(`SubscriptionBundle '${subscriptionBundleId}' nicht gefunden`);
+    }
+    if (existing.canceledAt !== null) {
+      throw new Error(`SubscriptionBundle '${subscriptionBundleId}' ist bereits gek\xFCndigt`);
+    }
+    const updated = {
+      ...existing,
+      canceledAt: data.canceledAt,
+      canceledEffectiveAt: data.canceledEffectiveAt,
+      updatedAt: this.now()
+    };
+    this.byId.set(subscriptionBundleId, updated);
+    return updated;
+  }
+  async reactivate(subscriptionBundleId) {
+    const existing = this.byId.get(subscriptionBundleId);
+    if (!existing) {
+      throw new Error(`SubscriptionBundle '${subscriptionBundleId}' nicht gefunden`);
+    }
+    const updated = {
+      ...existing,
+      canceledAt: null,
+      canceledEffectiveAt: null,
+      updatedAt: this.now()
+    };
+    this.byId.set(subscriptionBundleId, updated);
+    return updated;
+  }
+  async countActiveByBundleVersionId(bundleVersionId, asOf = /* @__PURE__ */ new Date()) {
+    let n = 0;
+    for (const r of this.byId.values()) {
+      if (r.bundleVersionId !== bundleVersionId) continue;
+      if (r.canceledAt === null) n += 1;
+      else if (r.canceledEffectiveAt !== null && r.canceledEffectiveAt.getTime() > asOf.getTime()) {
+        n += 1;
+      }
+    }
+    return n;
+  }
+};
+var FakeSubscriptionContractRepository = class {
+  static {
+    __name(this, "FakeSubscriptionContractRepository");
+  }
+  byId = /* @__PURE__ */ new Map();
+  nextContractId = 1;
+  nextLineItemId = 1;
+  clear() {
+    this.byId.clear();
+    this.nextContractId = 1;
+    this.nextLineItemId = 1;
+  }
+  async list(filter) {
+    return [
+      ...this.byId.values()
+    ].filter((row) => !filter.projectKey || row.projectKey === filter.projectKey).filter((row) => !filter.tenantId || row.tenantId === filter.tenantId).filter((row) => !filter.status || row.status === filter.status).filter((row) => !filter.asOf || this.isActiveAt(row, filter.asOf)).sort((a, b) => b.effectiveFrom.getTime() - a.effectiveFrom.getTime()).map((row) => this.cloneRecord(row));
+  }
+  async findById(contractId) {
+    const row = this.byId.get(contractId);
+    return row ? this.cloneRecord(row) : null;
+  }
+  async findActiveByTenantId(tenantId, asOf = /* @__PURE__ */ new Date()) {
+    const active = [
+      ...this.byId.values()
+    ].filter((row) => row.tenantId === tenantId).filter((row) => this.isActiveAt(row, asOf)).sort((a, b) => b.effectiveFrom.getTime() - a.effectiveFrom.getTime())[0];
+    return active ? this.cloneRecord(active) : null;
+  }
+  async create(data) {
+    const now = /* @__PURE__ */ new Date();
+    const id = `contract-${this.nextContractId++}`;
+    const row = {
+      id,
+      projectKey: data.projectKey,
+      tenantId: data.tenantId,
+      status: data.status ?? "active",
+      effectiveFrom: new Date(data.effectiveFrom),
+      effectiveUntil: data.effectiveUntil ? new Date(data.effectiveUntil) : null,
+      originalOfferId: data.originalOfferId ?? null,
+      originalPlanVersionId: data.originalPlanVersionId ?? null,
+      originalBundleVersionIds: [
+        ...data.originalBundleVersionIds ?? []
+      ],
+      entitlementSnapshot: data.entitlementSnapshot ? {
+        plan: data.entitlementSnapshot.plan,
+        quotas: {
+          ...data.entitlementSnapshot.quotas
+        },
+        features: [
+          ...data.entitlementSnapshot.features
+        ]
+      } : null,
+      priceSnapshot: {
+        ...data.priceSnapshot
+      },
+      promotionSnapshots: [
+        ...data.promotionSnapshots ?? []
+      ],
+      promoCodeSnapshots: [
+        ...data.promoCodeSnapshots ?? []
+      ],
+      termsSnapshot: data.termsSnapshot ? {
+        ...data.termsSnapshot
+      } : null,
+      lineItems: data.lineItems.map((item) => ({
+        ...item,
+        id: `contract-line-${this.nextLineItemId++}`,
+        contractId: id,
+        minimumTermUntil: item.minimumTermUntil ? new Date(item.minimumTermUntil) : null,
+        featuresSnapshot: [
+          ...item.featuresSnapshot
+        ],
+        quotaEffectsSnapshot: {
+          ...item.quotaEffectsSnapshot
+        },
+        metadata: item.metadata ? {
+          ...item.metadata
+        } : null,
+        createdAt: now
+      })),
+      createdAt: now,
+      updatedAt: now
+    };
+    this.byId.set(id, row);
+    return this.cloneRecord(row);
+  }
+  async terminate(contractId, data) {
+    const existing = this.byId.get(contractId);
+    if (!existing) throw new Error(`SubscriptionContract '${contractId}' nicht gefunden`);
+    const updated = {
+      ...existing,
+      status: data.status,
+      effectiveUntil: new Date(data.effectiveUntil),
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    this.byId.set(contractId, updated);
+    return this.cloneRecord(updated);
+  }
+  isActiveAt(row, asOf) {
+    if (row.status !== "active" && row.status !== "scheduled") return false;
+    return row.effectiveFrom.getTime() <= asOf.getTime() && (row.effectiveUntil === null || row.effectiveUntil.getTime() > asOf.getTime());
+  }
+  cloneRecord(row) {
+    return {
+      ...row,
+      effectiveFrom: new Date(row.effectiveFrom),
+      effectiveUntil: row.effectiveUntil ? new Date(row.effectiveUntil) : null,
+      originalBundleVersionIds: [
+        ...row.originalBundleVersionIds
+      ],
+      entitlementSnapshot: row.entitlementSnapshot ? {
+        plan: row.entitlementSnapshot.plan,
+        quotas: {
+          ...row.entitlementSnapshot.quotas
+        },
+        features: [
+          ...row.entitlementSnapshot.features
+        ]
+      } : null,
+      priceSnapshot: {
+        ...row.priceSnapshot
+      },
+      promotionSnapshots: [
+        ...row.promotionSnapshots
+      ],
+      promoCodeSnapshots: [
+        ...row.promoCodeSnapshots
+      ],
+      termsSnapshot: row.termsSnapshot ? {
+        ...row.termsSnapshot
+      } : null,
+      lineItems: row.lineItems.map((item) => ({
+        ...item,
+        minimumTermUntil: item.minimumTermUntil ? new Date(item.minimumTermUntil) : null,
+        featuresSnapshot: [
+          ...item.featuresSnapshot
+        ],
+        quotaEffectsSnapshot: {
+          ...item.quotaEffectsSnapshot
+        },
+        metadata: item.metadata ? {
+          ...item.metadata
+        } : null,
+        createdAt: new Date(item.createdAt)
+      })),
+      createdAt: new Date(row.createdAt),
+      updatedAt: new Date(row.updatedAt)
+    };
+  }
+};
+var FakePlanVersionRepository = class {
+  static {
+    __name(this, "FakePlanVersionRepository");
+  }
+  byPlanId = /* @__PURE__ */ new Map();
+  set(record) {
+    this.byPlanId.set(record.planId, record);
+  }
+  clear() {
+    this.byPlanId.clear();
+  }
+  async findLatestLive(planId, _tx) {
+    return this.byPlanId.get(planId) ?? null;
+  }
+  // The fake keeps only one record per planId — `findActive` returns the
+  // same as `findLatestLive`. Consumers test real time-window semantics
+  // against the Prisma implementation or against `FakePlanRepository`
+  // (which supports multiple versions per planKey).
+  async findActive(planId, _asOf, _tx) {
+    return this.byPlanId.get(planId) ?? null;
+  }
+};
+var FakeTransactionRunner = class _FakeTransactionRunner {
+  static {
+    __name(this, "FakeTransactionRunner");
+  }
+  /** Sentinel value passed through as the TransactionContext. */
+  static TX_SENTINEL = /* @__PURE__ */ Symbol.for("FakeTransactionRunner.tx");
+  runCount = 0;
+  async run(fn) {
+    this.runCount += 1;
+    return fn(_FakeTransactionRunner.TX_SENTINEL);
+  }
+};
+var FakeBundleRepository = class {
+  static {
+    __name(this, "FakeBundleRepository");
+  }
+  bundles = /* @__PURE__ */ new Map();
+  versions = /* @__PURE__ */ new Map();
+  nextId = 1;
+  genId(prefix) {
+    const n = this.nextId++;
+    const suffix = n.toString(16).padStart(12, "0");
+    return `${prefix}aaaa-aaaa-aaaa-aaaa-${suffix}`;
+  }
+  nowIso() {
+    return (/* @__PURE__ */ new Date()).toISOString();
+  }
+  // Test helpers
+  seedBundle(row) {
+    this.bundles.set(row.id, row);
+  }
+  seedVersion(row) {
+    this.versions.set(row.id, row);
+  }
+  clear() {
+    this.bundles.clear();
+    this.versions.clear();
+  }
+  // ─── Master operations ───
+  async list(filter) {
+    const excludeDeleted = filter.excludeDeleted ?? true;
+    return [
+      ...this.bundles.values()
+    ].filter((b) => b.projectKey === filter.projectKey && (!excludeDeleted || b.deletedAt === null));
+  }
+  async findById(bundleId) {
+    return this.bundles.get(bundleId) ?? null;
+  }
+  async findByKey(projectKey, bundleKey) {
+    for (const b of this.bundles.values()) {
+      if (b.projectKey === projectKey && b.bundleKey === bundleKey && b.deletedAt === null) {
+        return b;
+      }
+    }
+    return null;
+  }
+  async create(data) {
+    const now = this.nowIso();
+    const row = {
+      id: this.genId("bbbb"),
+      projectKey: data.projectKey,
+      bundleKey: data.bundleKey,
+      label: data.label,
+      description: data.description ?? null,
+      icon: data.icon ?? null,
+      sortOrder: data.sortOrder ?? 0,
+      i18n: data.i18n ?? {},
+      createdAt: now,
+      updatedAt: now,
+      deletedAt: null
+    };
+    this.bundles.set(row.id, row);
+    return row;
+  }
+  async update(bundleId, data) {
+    const existing = this.bundles.get(bundleId);
+    if (!existing) throw new Error(`Bundle '${bundleId}' nicht gefunden`);
+    const updated = {
+      ...existing,
+      label: data.label ?? existing.label,
+      description: data.description !== void 0 ? data.description : existing.description,
+      icon: data.icon !== void 0 ? data.icon : existing.icon,
+      sortOrder: data.sortOrder ?? existing.sortOrder,
+      i18n: data.i18n ?? existing.i18n,
+      updatedAt: this.nowIso()
+    };
+    this.bundles.set(bundleId, updated);
+    return updated;
+  }
+  async softDelete(bundleId) {
+    const existing = this.bundles.get(bundleId);
+    if (!existing) throw new Error(`Bundle '${bundleId}' nicht gefunden`);
+    this.bundles.set(bundleId, {
+      ...existing,
+      deletedAt: this.nowIso()
+    });
+  }
+  // ─── Version operations ───
+  async listVersions(bundleId) {
+    return [
+      ...this.versions.values()
+    ].filter((v) => v.bundleId === bundleId).sort((a, b) => a.version - b.version);
+  }
+  async findVersionById(versionId) {
+    return this.versions.get(versionId) ?? null;
+  }
+  async findCurrentDraft(bundleId) {
+    for (const v of this.versions.values()) {
+      if (v.bundleId === bundleId && v.publishedAt === null) return v;
+    }
+    return null;
+  }
+  async findLatestLive(bundleId) {
+    for (const v of this.versions.values()) {
+      if (v.bundleId === bundleId && v.publishedAt !== null && v.supersededAt === null) {
+        return v;
+      }
+    }
+    return null;
+  }
+  async createDraft(data) {
+    const draft = await this.findCurrentDraft(data.bundleId);
+    if (draft) {
+      throw new Error(`Bundle '${data.bundleId}' hat bereits eine Draft-Version v${draft.version}`);
+    }
+    const all = await this.listVersions(data.bundleId);
+    const nextVersion = all.length === 0 ? 1 : Math.max(...all.map((v) => v.version)) + 1;
+    const now = this.nowIso();
+    const row = {
+      id: this.genId("vvvv"),
+      version: nextVersion,
+      baseVersionId: data.baseVersionId ?? null,
+      publishedAt: null,
+      supersededAt: null,
+      publishedChanges: null,
+      changeNote: data.changeNote ?? "",
+      nonRegressive: true,
+      createdByUserId: data.createdByUserId ?? null,
+      publishedByUserId: null,
+      validFrom: data.validFrom ?? null,
+      validUntil: data.validUntil ?? null,
+      createdAt: now,
+      updatedAt: now,
+      bundleId: data.bundleId,
+      bundleKey: this.bundles.get(data.bundleId)?.bundleKey ?? "",
+      label: this.bundles.get(data.bundleId)?.label ?? "",
+      features: data.features,
+      quotas: data.quotas ?? {},
+      compatibility: data.compatibility ?? {},
+      pricingOverrides: data.pricingOverrides ?? [],
+      monthlyNet: data.monthlyNet ?? null,
+      yearlyNet: data.yearlyNet ?? null,
+      marketed: data.marketed ?? true
+    };
+    this.versions.set(row.id, row);
+    return row;
+  }
+  async updateDraft(versionId, data) {
+    const existing = this.versions.get(versionId);
+    if (!existing) throw new Error(`BundleVersion '${versionId}' nicht gefunden`);
+    const updated = {
+      ...existing,
+      features: data.features ?? existing.features,
+      quotas: data.quotas ?? existing.quotas,
+      compatibility: data.compatibility ?? existing.compatibility,
+      pricingOverrides: data.pricingOverrides ?? existing.pricingOverrides,
+      monthlyNet: data.monthlyNet !== void 0 ? data.monthlyNet : existing.monthlyNet,
+      yearlyNet: data.yearlyNet !== void 0 ? data.yearlyNet : existing.yearlyNet,
+      marketed: data.marketed ?? existing.marketed,
+      changeNote: data.changeNote ?? existing.changeNote,
+      validFrom: data.validFrom !== void 0 ? data.validFrom : existing.validFrom,
+      validUntil: data.validUntil !== void 0 ? data.validUntil : existing.validUntil,
+      updatedAt: this.nowIso()
+    };
+    this.versions.set(versionId, updated);
+    return updated;
+  }
+  async deleteDraft(versionId) {
+    const existing = this.versions.get(versionId);
+    if (!existing) return;
+    if (existing.publishedAt !== null) {
+      throw new Error(`BundleVersion '${versionId}' ist bereits published`);
+    }
+    this.versions.delete(versionId);
+  }
+  async publishDraft(versionId, publishMeta) {
+    const draft = this.versions.get(versionId);
+    if (!draft) throw new Error(`BundleVersion '${versionId}' nicht gefunden`);
+    if (draft.publishedAt !== null) {
+      throw new Error(`BundleVersion '${versionId}' ist bereits published`);
+    }
+    const now = this.nowIso();
+    const validFromIso = publishMeta.validFrom.toISOString();
+    const validUntilIso = publishMeta.validUntil ? publishMeta.validUntil.toISOString() : null;
+    const previous = await this.findLatestLive(draft.bundleId);
+    if (previous) {
+      const dayMs = 24 * 60 * 60 * 1e3;
+      const inheritedValidUntil = new Date(publishMeta.validFrom.getTime() - dayMs).toISOString();
+      this.versions.set(previous.id, {
+        ...previous,
+        supersededAt: now,
+        validUntil: inheritedValidUntil,
+        updatedAt: now
+      });
+    }
+    const published = {
+      ...draft,
+      publishedAt: now,
+      publishedChanges: publishMeta.publishedChanges,
+      nonRegressive: publishMeta.nonRegressive,
+      publishedByUserId: publishMeta.publishedByUserId,
+      validFrom: validFromIso,
+      validUntil: validUntilIso,
+      updatedAt: now
+    };
+    this.versions.set(versionId, published);
+    return published;
+  }
+};
+var FakeBusinessTypeRepository = class {
+  static {
+    __name(this, "FakeBusinessTypeRepository");
+  }
+  types = /* @__PURE__ */ new Map();
+  versions = /* @__PURE__ */ new Map();
+  nextId = 1;
+  genId(prefix) {
+    const n = this.nextId++;
+    const suffix = n.toString(16).padStart(12, "0");
+    return `${prefix}aaaa-aaaa-aaaa-aaaa-${suffix}`;
+  }
+  nowIso() {
+    return (/* @__PURE__ */ new Date()).toISOString();
+  }
+  seedBusinessType(row) {
+    this.types.set(row.id, row);
+  }
+  seedVersion(row) {
+    this.versions.set(row.id, row);
+  }
+  clear() {
+    this.types.clear();
+    this.versions.clear();
+  }
+  async list(filter) {
+    const excludeDeleted = filter.excludeDeleted ?? true;
+    return [
+      ...this.types.values()
+    ].filter((t) => t.projectKey === filter.projectKey && (!excludeDeleted || t.deletedAt === null));
+  }
+  async findById(businessTypeId) {
+    return this.types.get(businessTypeId) ?? null;
+  }
+  async findByKey(projectKey, businessTypeKey) {
+    for (const t of this.types.values()) {
+      if (t.projectKey === projectKey && t.businessTypeKey === businessTypeKey && t.deletedAt === null) {
+        return t;
+      }
+    }
+    return null;
+  }
+  async create(data) {
+    const now = this.nowIso();
+    const row = {
+      id: this.genId("cccc"),
+      projectKey: data.projectKey,
+      businessTypeKey: data.businessTypeKey,
+      label: data.label,
+      description: data.description ?? null,
+      icon: data.icon ?? null,
+      sortOrder: data.sortOrder ?? 0,
+      createdAt: now,
+      updatedAt: now,
+      deletedAt: null
+    };
+    this.types.set(row.id, row);
+    return row;
+  }
+  async update(businessTypeId, data) {
+    const existing = this.types.get(businessTypeId);
+    if (!existing) throw new Error(`BusinessType '${businessTypeId}' nicht gefunden`);
+    const updated = {
+      ...existing,
+      label: data.label ?? existing.label,
+      description: data.description !== void 0 ? data.description : existing.description,
+      icon: data.icon !== void 0 ? data.icon : existing.icon,
+      sortOrder: data.sortOrder ?? existing.sortOrder,
+      updatedAt: this.nowIso()
+    };
+    this.types.set(businessTypeId, updated);
+    return updated;
+  }
+  async softDelete(businessTypeId) {
+    const existing = this.types.get(businessTypeId);
+    if (!existing) throw new Error(`BusinessType '${businessTypeId}' nicht gefunden`);
+    this.types.set(businessTypeId, {
+      ...existing,
+      deletedAt: this.nowIso()
+    });
+  }
+  async listVersions(businessTypeId) {
+    return [
+      ...this.versions.values()
+    ].filter((v) => v.businessTypeId === businessTypeId).sort((a, b) => a.version - b.version);
+  }
+  async findVersionById(versionId) {
+    return this.versions.get(versionId) ?? null;
+  }
+  async findCurrentDraft(businessTypeId) {
+    for (const v of this.versions.values()) {
+      if (v.businessTypeId === businessTypeId && v.publishedAt === null) return v;
+    }
+    return null;
+  }
+  async findLatestLive(businessTypeId) {
+    for (const v of this.versions.values()) {
+      if (v.businessTypeId === businessTypeId && v.publishedAt !== null && v.supersededAt === null) {
+        return v;
+      }
+    }
+    return null;
+  }
+  async createDraft(data) {
+    const draft = await this.findCurrentDraft(data.businessTypeId);
+    if (draft) {
+      throw new Error(`BusinessType '${data.businessTypeId}' hat bereits eine Draft-Version v${draft.version}`);
+    }
+    const all = await this.listVersions(data.businessTypeId);
+    const nextVersion = all.length === 0 ? 1 : Math.max(...all.map((v) => v.version)) + 1;
+    const now = this.nowIso();
+    const businessType = this.types.get(data.businessTypeId);
+    const bundles = data.bundles.map((b) => ({
+      bundleVersionId: b.bundleVersionId,
+      bundleKey: "",
+      bundleLabel: "",
+      bundleVersion: 0,
+      sortOrder: b.sortOrder ?? 0
+    }));
+    const row = {
+      id: this.genId("wwww"),
+      version: nextVersion,
+      baseVersionId: data.baseVersionId ?? null,
+      publishedAt: null,
+      supersededAt: null,
+      publishedChanges: null,
+      changeNote: data.changeNote ?? "",
+      nonRegressive: true,
+      createdByUserId: data.createdByUserId ?? null,
+      publishedByUserId: null,
+      validFrom: null,
+      validUntil: null,
+      createdAt: now,
+      updatedAt: now,
+      businessTypeId: data.businessTypeId,
+      businessTypeKey: businessType?.businessTypeKey ?? "",
+      label: businessType?.label ?? "",
+      quotaOverrides: data.quotaOverrides ?? {},
+      monthlyNet: data.monthlyNet ?? null,
+      yearlyNet: data.yearlyNet ?? null,
+      marketed: data.marketed ?? true,
+      bundles
+    };
+    this.versions.set(row.id, row);
+    return row;
+  }
+  async updateDraft(versionId, data) {
+    const existing = this.versions.get(versionId);
+    if (!existing) throw new Error(`BusinessTypeVersion '${versionId}' nicht gefunden`);
+    if (existing.publishedAt !== null) {
+      throw new Error(`BusinessTypeVersion '${versionId}' ist bereits published`);
+    }
+    const bundles = data.bundles ? data.bundles.map((b) => ({
+      bundleVersionId: b.bundleVersionId,
+      bundleKey: "",
+      bundleLabel: "",
+      bundleVersion: 0,
+      sortOrder: b.sortOrder ?? 0
+    })) : existing.bundles;
+    const updated = {
+      ...existing,
+      quotaOverrides: data.quotaOverrides ?? existing.quotaOverrides,
+      monthlyNet: data.monthlyNet !== void 0 ? data.monthlyNet : existing.monthlyNet,
+      yearlyNet: data.yearlyNet !== void 0 ? data.yearlyNet : existing.yearlyNet,
+      marketed: data.marketed ?? existing.marketed,
+      changeNote: data.changeNote ?? existing.changeNote,
+      bundles,
+      updatedAt: this.nowIso()
+    };
+    this.versions.set(versionId, updated);
+    return updated;
+  }
+  async publishDraft(versionId, publishMeta) {
+    const draft = this.versions.get(versionId);
+    if (!draft) throw new Error(`BusinessTypeVersion '${versionId}' nicht gefunden`);
+    if (draft.publishedAt !== null) {
+      throw new Error(`BusinessTypeVersion '${versionId}' ist bereits published`);
+    }
+    const now = this.nowIso();
+    const previous = await this.findLatestLive(draft.businessTypeId);
+    if (previous) {
+      this.versions.set(previous.id, {
+        ...previous,
+        supersededAt: now,
+        updatedAt: now
+      });
+    }
+    const published = {
+      ...draft,
+      publishedAt: now,
+      publishedChanges: publishMeta.publishedChanges,
+      nonRegressive: publishMeta.nonRegressive,
+      publishedByUserId: publishMeta.publishedByUserId,
+      updatedAt: now
+    };
+    this.versions.set(versionId, published);
+    return published;
+  }
+};
+var FakeMarketingProjectionRepository = class {
+  static {
+    __name(this, "FakeMarketingProjectionRepository");
+  }
+  rows = /* @__PURE__ */ new Map();
+  nextId = 1;
+  genId() {
+    const n = this.nextId++;
+    const suffix = n.toString(16).padStart(12, "0");
+    return `mmmmaaaa-aaaa-aaaa-aaaa-${suffix}`;
+  }
+  nowIso() {
+    return (/* @__PURE__ */ new Date()).toISOString();
+  }
+  seed(row) {
+    this.rows.set(row.id, row);
+  }
+  clear() {
+    this.rows.clear();
+  }
+  async list(filter) {
+    return [
+      ...this.rows.values()
+    ].filter((r) => {
+      if (r.projectKey !== filter.projectKey) return false;
+      if (filter.targetType && r.targetType !== filter.targetType) return false;
+      if (filter.targetVersionId && r.targetVersionId !== filter.targetVersionId) return false;
+      if (filter.locale && r.locale !== filter.locale) return false;
+      return true;
+    });
+  }
+  async findById(id) {
+    return this.rows.get(id) ?? null;
+  }
+  async findByTarget(targetType, targetVersionId, locale) {
+    for (const r of this.rows.values()) {
+      if (r.targetType === targetType && r.targetVersionId === targetVersionId && r.locale === locale) {
+        return r;
+      }
+    }
+    return null;
+  }
+  async create(data) {
+    const locale = data.locale ?? "de";
+    const existing = await this.findByTarget(data.targetType, data.targetVersionId, locale);
+    if (existing) {
+      throw new Error(`MarketingProjection f\xFCr ${data.targetType}/${data.targetVersionId}/${locale} existiert bereits`);
+    }
+    const now = this.nowIso();
+    const row = {
+      id: this.genId(),
+      projectKey: data.projectKey,
+      targetType: data.targetType,
+      targetVersionId: data.targetVersionId,
+      locale,
+      displayLabel: data.displayLabel,
+      description: data.description,
+      visible: data.visible ?? true,
+      badge: data.badge ?? "",
+      topFeatures: data.topFeatures ?? [],
+      trialEnabled: data.trialEnabled ?? false,
+      trialDays: data.trialDays ?? 30,
+      priceTag: data.priceTag ?? null,
+      ctaLabel: data.ctaLabel ?? null,
+      priority: data.priority ?? 0,
+      highlight: data.highlight ?? false,
+      createdAt: now,
+      updatedAt: now
+    };
+    this.rows.set(row.id, row);
+    return row;
+  }
+  async update(id, data) {
+    const existing = this.rows.get(id);
+    if (!existing) throw new Error(`MarketingProjection '${id}' nicht gefunden`);
+    const updated = {
+      ...existing,
+      displayLabel: data.displayLabel ?? existing.displayLabel,
+      description: data.description ?? existing.description,
+      visible: data.visible ?? existing.visible,
+      badge: data.badge ?? existing.badge,
+      topFeatures: data.topFeatures ?? existing.topFeatures,
+      trialEnabled: data.trialEnabled ?? existing.trialEnabled,
+      trialDays: data.trialDays ?? existing.trialDays,
+      priceTag: data.priceTag !== void 0 ? data.priceTag : existing.priceTag,
+      ctaLabel: data.ctaLabel !== void 0 ? data.ctaLabel : existing.ctaLabel,
+      priority: data.priority ?? existing.priority,
+      highlight: data.highlight ?? existing.highlight,
+      updatedAt: this.nowIso()
+    };
+    this.rows.set(id, updated);
+    return updated;
+  }
+  async delete(id) {
+    if (!this.rows.has(id)) throw new Error(`MarketingProjection '${id}' nicht gefunden`);
+    this.rows.delete(id);
+  }
+};
+var FakePlanRepository = class {
+  static {
+    __name(this, "FakePlanRepository");
+  }
+  plans = /* @__PURE__ */ new Map();
+  versions = /* @__PURE__ */ new Map();
+  nextId = 1;
+  nextVersionId = 1;
+  genId() {
+    const n = this.nextId++;
+    const suffix = n.toString(16).padStart(12, "0");
+    return `dddd-aaaa-aaaa-aaaa-aaaa-${suffix}`;
+  }
+  genVersionId() {
+    const n = this.nextVersionId++;
+    const suffix = n.toString(16).padStart(12, "0");
+    return `eeee-aaaa-aaaa-aaaa-aaaa-${suffix}`;
+  }
+  nowIso() {
+    return (/* @__PURE__ */ new Date()).toISOString();
+  }
+  seed(row) {
+    this.plans.set(row.id, row);
+  }
+  seedVersion(row) {
+    this.versions.set(row.id, row);
+  }
+  clear() {
+    this.plans.clear();
+    this.versions.clear();
+  }
+  async list(filter) {
+    const excludeDeleted = filter.excludeDeleted ?? true;
+    const liveKeys = filter.onlyPublished ? new Set([
+      ...this.versions.values()
+    ].filter((v) => v.publishedAt != null && v.supersededAt == null).map((v) => v.planId)) : null;
+    return [
+      ...this.plans.values()
+    ].filter((p) => p.projectKey === filter.projectKey && (!excludeDeleted || p.deletedAt === null) && (!liveKeys || liveKeys.has(p.planKey)));
+  }
+  async findById(planId) {
+    return this.plans.get(planId) ?? null;
+  }
+  async findByKey(projectKey, planKey) {
+    for (const p of this.plans.values()) {
+      if (p.projectKey === projectKey && p.planKey === planKey && p.deletedAt === null) {
+        return p;
+      }
+    }
+    return null;
+  }
+  async create(data) {
+    const now = this.nowIso();
+    const row = {
+      id: this.genId(),
+      projectKey: data.projectKey,
+      planKey: data.planKey,
+      label: data.label,
+      description: data.description ?? null,
+      icon: data.icon ?? null,
+      sortOrder: data.sortOrder ?? 0,
+      createdAt: now,
+      updatedAt: now,
+      deletedAt: null
+    };
+    this.plans.set(row.id, row);
+    return row;
+  }
+  async update(planId, data) {
+    const existing = this.plans.get(planId);
+    if (!existing) throw new Error(`Plan '${planId}' nicht gefunden`);
+    const updated = {
+      ...existing,
+      label: data.label ?? existing.label,
+      description: data.description ?? existing.description,
+      icon: data.icon ?? existing.icon,
+      sortOrder: data.sortOrder ?? existing.sortOrder,
+      updatedAt: this.nowIso()
+    };
+    this.plans.set(planId, updated);
+    return updated;
+  }
+  async softDelete(planId) {
+    const existing = this.plans.get(planId);
+    if (!existing) throw new Error(`Plan '${planId}' nicht gefunden`);
+    const updated = {
+      ...existing,
+      deletedAt: this.nowIso(),
+      updatedAt: this.nowIso()
+    };
+    this.plans.set(planId, updated);
+  }
+  async hardDelete(planId) {
+    const existing = this.plans.get(planId);
+    if (!existing) return;
+    this.plans.delete(planId);
+    for (const [id, v] of this.versions.entries()) {
+      if (v.planId === existing.planKey) this.versions.delete(id);
+    }
+  }
+  // ─── Lifecycle (SPEC_V2 §11.1 M6 Pack 2a) ───
+  // Binding Plan ↔ PlanVersion: PlanVersion.planId === Plan.planKey
+  // (soft string reference). Lifecycle methods take planKey
+  // as input — the service resolves the plan UUID beforehand.
+  async listVersions(planKey) {
+    return [
+      ...this.versions.values()
+    ].filter((v) => v.planId === planKey).sort((a, b) => a.version - b.version);
+  }
+  async findVersionById(versionId) {
+    return this.versions.get(versionId) ?? null;
+  }
+  async findCurrentDraft(planKey) {
+    for (const v of this.versions.values()) {
+      if (v.planId === planKey && v.publishedAt === null) return v;
+    }
+    return null;
+  }
+  async findLatestLivePlanVersion(planKey) {
+    const now = Date.now();
+    const live = [
+      ...this.versions.values()
+    ].filter((v) => {
+      if (v.planId !== planKey) return false;
+      if (v.publishedAt === null) return false;
+      if (v.supersededAt !== null) return false;
+      if (v.endsAt) {
+        const ends = new Date(v.endsAt).getTime();
+        if (!Number.isNaN(ends) && ends <= now) return false;
+      }
+      return true;
+    });
+    live.sort((a, b) => b.version - a.version);
+    return live[0] ?? null;
+  }
+  async findActivePlanVersion(planKey, asOf = /* @__PURE__ */ new Date()) {
+    const t = asOf.getTime();
+    const dayStart = startOfUtcDay(asOf).getTime();
+    const matches = [
+      ...this.versions.values()
+    ].filter((v) => {
+      if (v.planId !== planKey) return false;
+      if (v.publishedAt === null) return false;
+      if (v.validFrom) {
+        const from = new Date(v.validFrom).getTime();
+        if (Number.isNaN(from) || from > t) return false;
+      }
+      if (v.validUntil) {
+        const until = new Date(v.validUntil).getTime();
+        if (!Number.isNaN(until) && until < dayStart) return false;
+      }
+      if (v.endsAt) {
+        const ends = new Date(v.endsAt).getTime();
+        if (!Number.isNaN(ends) && ends <= t) return false;
+      }
+      return true;
+    });
+    matches.sort((a, b) => {
+      const fa = a.validFrom ? new Date(a.validFrom).getTime() : 0;
+      const fb = b.validFrom ? new Date(b.validFrom).getTime() : 0;
+      if (fb !== fa) return fb - fa;
+      return b.version - a.version;
+    });
+    return matches[0] ?? null;
+  }
+  async createPlanVersionDraft(data) {
+    const planKey = data.planId;
+    const versions = [
+      ...this.versions.values()
+    ].filter((v) => v.planId === planKey);
+    const nextVersion = versions.reduce((max, v) => Math.max(max, v.version), 0) + 1;
+    const now = this.nowIso();
+    const row = {
+      id: this.genVersionId(),
+      planId: planKey,
+      version: nextVersion,
+      baseVersionId: data.baseVersionId ?? null,
+      features: data.features,
+      bundles: data.bundles ?? [],
+      quotas: data.quotas,
+      monthlyNet: data.monthlyNet,
+      yearlyNet: data.yearlyNet,
+      marketed: data.marketed ?? true,
+      publishedAt: null,
+      supersededAt: null,
+      publishedChanges: null,
+      changeNote: data.changeNote ?? "",
+      nonRegressive: true,
+      validFrom: data.validFrom ?? null,
+      validUntil: data.validUntil ?? null,
+      endsAt: null,
+      createdByUserId: data.createdByUserId ?? null,
+      publishedByUserId: null,
+      createdAt: now,
+      updatedAt: now
+    };
+    this.versions.set(row.id, row);
+    return row;
+  }
+  async updatePlanVersionDraft(versionId, data) {
+    const existing = this.versions.get(versionId);
+    if (!existing) throw new Error(`PlanVersion '${versionId}' nicht gefunden`);
+    const updated = {
+      ...existing,
+      features: data.features ?? existing.features,
+      bundles: data.bundles ?? existing.bundles ?? [],
+      quotas: data.quotas ?? existing.quotas,
+      monthlyNet: data.monthlyNet ?? existing.monthlyNet,
+      yearlyNet: data.yearlyNet ?? existing.yearlyNet,
+      marketed: data.marketed ?? existing.marketed,
+      changeNote: data.changeNote ?? existing.changeNote,
+      updatedAt: this.nowIso()
+    };
+    this.versions.set(versionId, updated);
+    return updated;
+  }
+  async publishPlanVersionDraft(versionId, publishMeta) {
+    const draft = this.versions.get(versionId);
+    if (!draft) throw new Error(`PlanVersion '${versionId}' nicht gefunden`);
+    const planKey = draft.planId;
+    const now = this.nowIso();
+    const dayMs = 24 * 60 * 60 * 1e3;
+    const inheritedValidUntil = new Date(publishMeta.validFrom.getTime() - dayMs).toISOString();
+    for (const v of this.versions.values()) {
+      if (v.planId === planKey && v.publishedAt !== null && v.supersededAt === null && v.id !== versionId) {
+        this.versions.set(v.id, {
+          ...v,
+          supersededAt: now,
+          validUntil: v.validUntil ?? inheritedValidUntil,
+          updatedAt: now
+        });
+      }
+    }
+    const published = {
+      ...draft,
+      publishedAt: now,
+      publishedChanges: publishMeta.publishedChanges,
+      nonRegressive: publishMeta.nonRegressive,
+      publishedByUserId: publishMeta.publishedByUserId,
+      validFrom: publishMeta.validFrom.toISOString(),
+      validUntil: publishMeta.validUntil ? publishMeta.validUntil.toISOString() : null,
+      updatedAt: now
+    };
+    this.versions.set(versionId, published);
+    return published;
+  }
+  async deletePlanVersionDraft(versionId) {
+    const existing = this.versions.get(versionId);
+    if (!existing) return;
+    if (existing.publishedAt !== null) {
+      throw new Error(`FakePlanRepository: PlanVersion '${versionId}' ist bereits published \u2014 Discard nicht erlaubt`);
+    }
+    this.versions.delete(versionId);
+  }
+  async terminate(versionId, endsAt) {
+    const existing = this.versions.get(versionId);
+    if (!existing) {
+      throw new Error(`FakePlanRepository: PlanVersion '${versionId}' nicht gefunden`);
+    }
+    const updated = {
+      ...existing,
+      endsAt: endsAt.toISOString(),
+      updatedAt: this.nowIso()
+    };
+    this.versions.set(versionId, updated);
+    return updated;
+  }
+};
+
+// src/testing/create-saas-platform-test-module.ts
+import { Module } from "@nestjs/common";
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+var StubMfaPort = class {
+  static {
+    __name(this, "StubMfaPort");
+  }
+  secrets = /* @__PURE__ */ new Map();
+  async getSecret(userId) {
+    return this.secrets.get(userId) ?? null;
+  }
+  async setSecret(userId, secret) {
+    if (secret === null) this.secrets.delete(userId);
+    else this.secrets.set(userId, secret);
+  }
+  async isEnabled(userId) {
+    return this.secrets.has(userId);
+  }
+};
+var StubAuditPort = class {
+  static {
+    __name(this, "StubAuditPort");
+  }
+  calls = [];
+  async write(input) {
+    this.calls.push(input);
+  }
+};
+var StubRlsBypassPort = class {
+  static {
+    __name(this, "StubRlsBypassPort");
+  }
+  async runWithBypass(fn) {
+    return fn();
+  }
+};
+function createSaasPlatformTestModule(options) {
+  const defaultPlanId = options.defaultPlanId ?? options.planCatalog.plans?.[0]?.id;
+  let SaasPlatformTestHost = class SaasPlatformTestHost {
+    static {
+      __name(this, "SaasPlatformTestHost");
+    }
+  };
+  SaasPlatformTestHost = _ts_decorate([
+    Module({
+      imports: [
+        SaasPlatformModule.forRoot({
+          planCatalog: options.planCatalog,
+          controller: {
+            guards: []
+          },
+          adapters: {
+            mfa: options.overrides?.mfa ?? new StubMfaPort(),
+            audit: options.overrides?.audit ?? new StubAuditPort(),
+            rlsBypass: options.overrides?.rlsBypass ?? new StubRlsBypassPort()
+          },
+          defaultPlanId,
+          quotaProviders: options.quotaProviders
+        })
+      ]
+    })
+  ], SaasPlatformTestHost);
+  return {
+    module: SaasPlatformTestHost
+  };
+}
+__name(createSaasPlatformTestModule, "createSaasPlatformTestModule");
+export {
+  FakeBundleRepository,
+  FakeBusinessTypeRepository,
+  FakeMarketingProjectionRepository,
+  FakePlanRepository,
+  FakePlanVersionRepository,
+  FakeSubscriptionBundleRepository,
+  FakeSubscriptionContractRepository,
+  FakeSubscriptionRepository,
+  FakeTransactionRunner,
+  StubAuditPort,
+  StubMfaPort,
+  StubRlsBypassPort,
+  createSaasPlatformTestModule
+};