@saasicat/adapter-prisma 0.4.0 → 0.6.0

package/dist/index.js

@@ -1160,9 +1160,6 @@ var PrismaSubscriptionRepository = class {
     return this.toRecord(db, row);
   }
   async toRecord(db, row) {
-    if (!row.planVersionId) {
-      throw new Error(`Subscription ${row.id} binds no planVersionId (businessType-only composition). The shipped @saasicat/adapter-prisma SubscriptionRepository does not support BusinessType aggregation \u2014 provide a custom SubscriptionRepository adapter.`);
-    }
     const planVersion = await db.planVersion.findUnique({
       where: {
         id: row.planVersionId
@@ -1417,6 +1414,2259 @@ function buildProvisioning(client, hasher) {
   return new PrismaSuperAdminBootstrapAdapter(client, hasher);
 }
 __name(buildProvisioning, "buildProvisioning");
+
+// src/prisma-subscription-bundle.repository.ts
+import { Inject as Inject15, Injectable as Injectable17 } from "@nestjs/common";
+function _ts_decorate17(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_decorate17, "_ts_decorate");
+function _ts_metadata15(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata15, "_ts_metadata");
+function _ts_param15(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param15, "_ts_param");
+var PrismaSubscriptionBundleRepository = class {
+  static {
+    __name(this, "PrismaSubscriptionBundleRepository");
+  }
+  prisma;
+  constructor(prisma) {
+    this.prisma = prisma;
+  }
+  db(tx) {
+    return resolveClient(this.prisma, tx);
+  }
+  async listBySubscription(subscriptionId) {
+    const rows = await this.db().subscriptionBundle.findMany({
+      where: {
+        subscriptionId
+      },
+      orderBy: {
+        startedAt: "desc"
+      }
+    });
+    return rows.map(toRecord3);
+  }
+  async findById(subscriptionBundleId) {
+    const row = await this.db().subscriptionBundle.findUnique({
+      where: {
+        id: subscriptionBundleId
+      }
+    });
+    return row ? toRecord3(row) : null;
+  }
+  async listActiveBySubscription(subscriptionId, asOf = /* @__PURE__ */ new Date()) {
+    const rows = await this.db().subscriptionBundle.findMany({
+      where: {
+        subscriptionId,
+        OR: [
+          {
+            canceledAt: null
+          },
+          {
+            canceledEffectiveAt: {
+              gt: asOf
+            }
+          }
+        ]
+      },
+      orderBy: {
+        startedAt: "desc"
+      }
+    });
+    return rows.map(toRecord3);
+  }
+  async add(data) {
+    const row = await this.db().subscriptionBundle.create({
+      data: {
+        subscriptionId: data.subscriptionId,
+        bundleVersionId: data.bundleVersionId,
+        startedAt: data.startedAt,
+        minimumTermEndsAt: data.minimumTermEndsAt ?? null
+      }
+    });
+    return toRecord3(row);
+  }
+  async cancel(subscriptionBundleId, data) {
+    const row = await this.db().subscriptionBundle.update({
+      where: {
+        id: subscriptionBundleId
+      },
+      data: {
+        canceledAt: data.canceledAt,
+        canceledEffectiveAt: data.canceledEffectiveAt
+      }
+    });
+    return toRecord3(row);
+  }
+  async reactivate(subscriptionBundleId) {
+    const row = await this.db().subscriptionBundle.update({
+      where: {
+        id: subscriptionBundleId
+      },
+      data: {
+        canceledAt: null,
+        canceledEffectiveAt: null
+      }
+    });
+    return toRecord3(row);
+  }
+  async countActiveByBundleVersionId(bundleVersionId, asOf = /* @__PURE__ */ new Date()) {
+    return this.db().subscriptionBundle.count({
+      where: {
+        bundleVersionId,
+        OR: [
+          {
+            canceledAt: null
+          },
+          {
+            canceledEffectiveAt: {
+              gt: asOf
+            }
+          }
+        ]
+      }
+    });
+  }
+};
+PrismaSubscriptionBundleRepository = _ts_decorate17([
+  Injectable17(),
+  _ts_param15(0, Inject15(PRISMA_CLIENT_TOKEN)),
+  _ts_metadata15("design:type", Function),
+  _ts_metadata15("design:paramtypes", [
+    typeof PrismaLike === "undefined" ? Object : PrismaLike
+  ])
+], PrismaSubscriptionBundleRepository);
+function toRecord3(row) {
+  return {
+    id: row.id,
+    subscriptionId: row.subscriptionId,
+    bundleVersionId: row.bundleVersionId,
+    startedAt: row.startedAt,
+    minimumTermEndsAt: row.minimumTermEndsAt,
+    canceledAt: row.canceledAt,
+    canceledEffectiveAt: row.canceledEffectiveAt,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt
+  };
+}
+__name(toRecord3, "toRecord");
+
+// src/prisma-tenant-subscription-write.adapter.ts
+import { Inject as Inject16, Injectable as Injectable18 } from "@nestjs/common";
+function _ts_decorate18(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_decorate18, "_ts_decorate");
+function _ts_metadata16(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata16, "_ts_metadata");
+function _ts_param16(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param16, "_ts_param");
+var PrismaTenantSubscriptionWriteAdapter = class {
+  static {
+    __name(this, "PrismaTenantSubscriptionWriteAdapter");
+  }
+  prisma;
+  constructor(prisma) {
+    this.prisma = prisma;
+  }
+  db(tx) {
+    return resolveClient(this.prisma, tx);
+  }
+  async changePlanImmediate(tenantId, input) {
+    const updated = await this.db().subscription.update({
+      where: {
+        tenantId
+      },
+      data: {
+        plan: input.planId,
+        billingCycle: input.cycle,
+        pendingPlan: null,
+        pendingBillingCycle: null,
+        pendingEffectiveAt: null,
+        ...input.nextStatus ? {
+          status: input.nextStatus
+        } : {},
+        ...input.periodStart && input.periodEnd ? {
+          currentPeriodStart: input.periodStart,
+          currentPeriodEnd: input.periodEnd
+        } : {},
+        // #17: the platform changePlan path computes the carried-over
+        // trial end and passes it through; null/undefined leaves the
+        // existing trialEndsAt untouched.
+        ...input.trialEndsAt ? {
+          trialEndsAt: input.trialEndsAt
+        } : {}
+      }
+    });
+    return {
+      plan: updated.plan,
+      billingCycle: updated.billingCycle
+    };
+  }
+  async schedulePlanChange(tenantId, input) {
+    await this.db().subscription.update({
+      where: {
+        tenantId
+      },
+      data: {
+        pendingPlan: input.pendingPlan,
+        pendingBillingCycle: input.pendingBillingCycle,
+        pendingEffectiveAt: input.pendingEffectiveAt
+      }
+    });
+  }
+  async acceptPendingPlanVersion(tenantId, userId, now) {
+    const sub = await this.db().subscription.findUnique({
+      where: {
+        tenantId
+      }
+    });
+    if (!sub) {
+      throw new Error(`No subscription for tenant ${tenantId}.`);
+    }
+    if (sub.pendingPlanVersionAccepted) {
+      return {
+        accepted: true,
+        acceptedAt: sub.pendingPlanVersionAcceptedAt,
+        effectiveAt: sub.pendingPlanVersionEffectiveAt,
+        alreadyAccepted: true
+      };
+    }
+    const updated = await this.db().subscription.update({
+      where: {
+        id: sub.id
+      },
+      data: {
+        pendingPlanVersionAccepted: true,
+        pendingPlanVersionAcceptedAt: now,
+        pendingPlanVersionAcceptedByUserId: userId
+      }
+    });
+    return {
+      accepted: true,
+      acceptedAt: updated.pendingPlanVersionAcceptedAt,
+      effectiveAt: updated.pendingPlanVersionEffectiveAt,
+      alreadyAccepted: false
+    };
+  }
+  async cancelSubscription(tenantId, immediate, now) {
+    const sub = await this.db().subscription.findUnique({
+      where: {
+        tenantId
+      }
+    });
+    if (!sub) {
+      throw new Error(`No subscription for tenant ${tenantId}.`);
+    }
+    const canceledAt = immediate ? now : sub.currentPeriodEnd ?? now;
+    const updated = await this.db().subscription.update({
+      where: {
+        tenantId
+      },
+      data: {
+        canceledAt,
+        status: immediate ? "CANCELED" : sub.status
+      }
+    });
+    return {
+      canceledAt: updated.canceledAt,
+      status: updated.status
+    };
+  }
+};
+PrismaTenantSubscriptionWriteAdapter = _ts_decorate18([
+  Injectable18(),
+  _ts_param16(0, Inject16(PRISMA_CLIENT_TOKEN)),
+  _ts_metadata16("design:type", Function),
+  _ts_metadata16("design:paramtypes", [
+    typeof PrismaLike === "undefined" ? Object : PrismaLike
+  ])
+], PrismaTenantSubscriptionWriteAdapter);
+
+// src/prisma-plan.repository.ts
+import { Inject as Inject17, Injectable as Injectable19 } from "@nestjs/common";
+function _ts_decorate19(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_decorate19, "_ts_decorate");
+function _ts_metadata17(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata17, "_ts_metadata");
+function _ts_param17(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param17, "_ts_param");
+var PrismaPlanRepository = class {
+  static {
+    __name(this, "PrismaPlanRepository");
+  }
+  prisma;
+  constructor(prisma) {
+    this.prisma = prisma;
+  }
+  db(tx) {
+    return resolveClient(this.prisma, tx);
+  }
+  // ─── Stem operations (Pack 1) ───
+  async list(filter) {
+    const excludeDeleted = filter.excludeDeleted ?? true;
+    let publishedKeys = null;
+    if (filter.onlyPublished) {
+      const live = await this.db().planVersion.findMany({
+        where: {
+          publishedAt: {
+            not: null
+          },
+          supersededAt: null
+        }
+      });
+      publishedKeys = [
+        ...new Set(live.map((version) => version.planId))
+      ];
+    }
+    const rows = await this.db().plan.findMany({
+      where: {
+        projectKey: filter.projectKey,
+        ...excludeDeleted ? {
+          deletedAt: null
+        } : {},
+        ...publishedKeys ? {
+          planKey: {
+            in: publishedKeys
+          }
+        } : {}
+      },
+      orderBy: [
+        {
+          sortOrder: "asc"
+        },
+        {
+          planKey: "asc"
+        }
+      ]
+    });
+    return rows.map(toPlanRow2);
+  }
+  async findById(planId) {
+    const row = await this.db().plan.findUnique({
+      where: {
+        id: planId
+      }
+    });
+    return row ? toPlanRow2(row) : null;
+  }
+  async findByKey(projectKey, planKey) {
+    const row = await this.db().plan.findFirst({
+      where: {
+        projectKey,
+        planKey,
+        deletedAt: null
+      }
+    });
+    return row ? toPlanRow2(row) : null;
+  }
+  async create(data) {
+    const created = await this.db().plan.create({
+      data: {
+        projectKey: data.projectKey,
+        planKey: data.planKey,
+        label: data.label,
+        description: data.description ?? null,
+        icon: data.icon ?? null,
+        sortOrder: data.sortOrder ?? 0
+      }
+    });
+    return toPlanRow2(created);
+  }
+  async update(planId, data) {
+    const updated = await this.db().plan.update({
+      where: {
+        id: planId
+      },
+      data: {
+        ...data.label !== void 0 ? {
+          label: data.label
+        } : {},
+        ...data.description !== void 0 ? {
+          description: data.description
+        } : {},
+        ...data.icon !== void 0 ? {
+          icon: data.icon
+        } : {},
+        ...data.sortOrder !== void 0 ? {
+          sortOrder: data.sortOrder
+        } : {}
+      }
+    });
+    return toPlanRow2(updated);
+  }
+  async softDelete(planId) {
+    await this.db().plan.update({
+      where: {
+        id: planId
+      },
+      data: {
+        deletedAt: /* @__PURE__ */ new Date()
+      }
+    });
+  }
+  async hardDelete(planId) {
+    await this.db().plan.deleteMany({
+      where: {
+        id: planId
+      }
+    });
+  }
+  // ─── Lifecycle operations (Pack 2a) — keyed by planKey ───
+  async listVersions(planKey) {
+    const rows = await this.db().planVersion.findMany({
+      where: {
+        planId: planKey
+      },
+      orderBy: {
+        version: "asc"
+      }
+    });
+    return rows.map(toPlanVersionRow2);
+  }
+  async findVersionById(versionId) {
+    const row = await this.db().planVersion.findUnique({
+      where: {
+        id: versionId
+      }
+    });
+    return row ? toPlanVersionRow2(row) : null;
+  }
+  async findCurrentDraft(planKey) {
+    const row = await this.db().planVersion.findFirst({
+      where: {
+        planId: planKey,
+        publishedAt: null
+      }
+    });
+    return row ? toPlanVersionRow2(row) : null;
+  }
+  async findLatestLivePlanVersion(planKey, tx) {
+    const row = await this.db(tx).planVersion.findFirst({
+      where: {
+        planId: planKey,
+        publishedAt: {
+          not: null
+        },
+        supersededAt: null
+      },
+      orderBy: {
+        version: "desc"
+      }
+    });
+    return row ? toPlanVersionRow2(row) : null;
+  }
+  async findActivePlanVersion() {
+    throw new Error("findActivePlanVersion is not supported by the shipped @saasicat/adapter-prisma PlanRepository: the canonical plan_versions schema (03-plan-versions.prisma) has no validFrom/validUntil columns, so a version cannot be resolved by validity window. Use findLatestLivePlanVersion for the newest live version, or provide a custom PlanRepository adapter on a schema that carries the validity-window columns.");
+  }
+  async createPlanVersionDraft(data) {
+    const planKey = data.planId;
+    const latest = await this.db().planVersion.findFirst({
+      where: {
+        planId: planKey
+      },
+      orderBy: {
+        version: "desc"
+      }
+    });
+    const nextVersion = (latest?.version ?? 0) + 1;
+    const created = await this.db().planVersion.create({
+      data: {
+        planId: planKey,
+        version: nextVersion,
+        baseVersionId: data.baseVersionId ?? null,
+        features: data.features,
+        quotas: data.quotas,
+        monthlyNet: data.monthlyNet,
+        yearlyNet: data.yearlyNet,
+        marketed: data.marketed ?? true,
+        changeNote: data.changeNote ?? "",
+        createdByUserId: data.createdByUserId ?? null
+      }
+    });
+    return toPlanVersionRow2(created);
+  }
+  async updatePlanVersionDraft(versionId, data) {
+    const updated = await this.db().planVersion.update({
+      where: {
+        id: versionId
+      },
+      data: {
+        ...data.features !== void 0 ? {
+          features: data.features
+        } : {},
+        ...data.quotas !== void 0 ? {
+          quotas: data.quotas
+        } : {},
+        ...data.monthlyNet !== void 0 ? {
+          monthlyNet: data.monthlyNet
+        } : {},
+        ...data.yearlyNet !== void 0 ? {
+          yearlyNet: data.yearlyNet
+        } : {},
+        ...data.marketed !== void 0 ? {
+          marketed: data.marketed
+        } : {},
+        ...data.changeNote !== void 0 ? {
+          changeNote: data.changeNote
+        } : {}
+      }
+    });
+    return toPlanVersionRow2(updated);
+  }
+  async publishPlanVersionDraft(versionId, publishMeta, tx) {
+    const draft = await this.db(tx).planVersion.findUnique({
+      where: {
+        id: versionId
+      }
+    });
+    if (!draft) {
+      throw new Error(`PlanVersion ${versionId} not found.`);
+    }
+    const planKey = draft.planId;
+    const publish = /* @__PURE__ */ __name(async (db) => {
+      const previous = await db.planVersion.findFirst({
+        where: {
+          planId: planKey,
+          publishedAt: {
+            not: null
+          },
+          supersededAt: null,
+          id: {
+            not: versionId
+          }
+        },
+        orderBy: {
+          version: "desc"
+        }
+      });
+      const now = /* @__PURE__ */ new Date();
+      if (previous) {
+        await db.planVersion.update({
+          where: {
+            id: previous.id
+          },
+          data: {
+            supersededAt: now
+          }
+        });
+      }
+      return db.planVersion.update({
+        where: {
+          id: versionId
+        },
+        data: {
+          publishedAt: now,
+          publishedChanges: publishMeta.publishedChanges,
+          nonRegressive: publishMeta.nonRegressive,
+          publishedByUserId: publishMeta.publishedByUserId
+        }
+      });
+    }, "publish");
+    const published = tx ? await publish(this.db(tx)) : await this.prisma.$transaction((txClient) => publish(txClient));
+    return toPlanVersionRow2(published);
+  }
+  async deletePlanVersionDraft(versionId) {
+    const row = await this.db().planVersion.findUnique({
+      where: {
+        id: versionId
+      }
+    });
+    if (!row) return;
+    if (row.publishedAt !== null) {
+      throw new Error(`PlanVersion ${versionId} is already published and cannot be discarded (published versions are immutable \u2014 contract protection P1).`);
+    }
+    await this.db().planVersion.deleteMany({
+      where: {
+        id: versionId,
+        publishedAt: null
+      }
+    });
+  }
+  async terminate() {
+    throw new Error("terminate is not supported by the shipped @saasicat/adapter-prisma PlanRepository: the canonical plan_versions schema (03-plan-versions.prisma) has no endsAt column. Provide a custom PlanRepository adapter on a schema that carries endsAt to support SuperAdmin-initiated plan-version termination.");
+  }
+};
+PrismaPlanRepository = _ts_decorate19([
+  Injectable19(),
+  _ts_param17(0, Inject17(PRISMA_CLIENT_TOKEN)),
+  _ts_metadata17("design:type", Function),
+  _ts_metadata17("design:paramtypes", [
+    typeof PrismaLike === "undefined" ? Object : PrismaLike
+  ])
+], PrismaPlanRepository);
+function toPlanRow2(row) {
+  return {
+    id: row.id,
+    projectKey: row.projectKey,
+    planKey: row.planKey,
+    label: row.label,
+    description: row.description,
+    icon: row.icon,
+    sortOrder: row.sortOrder,
+    createdAt: row.createdAt.toISOString(),
+    updatedAt: row.updatedAt.toISOString(),
+    deletedAt: row.deletedAt?.toISOString() ?? null
+  };
+}
+__name(toPlanRow2, "toPlanRow");
+function toPlanVersionRow2(row) {
+  return {
+    id: row.id,
+    version: row.version,
+    baseVersionId: row.baseVersionId,
+    planId: row.planId,
+    features: toStringArray(row.features),
+    quotas: toQuotaMap(row.quotas),
+    monthlyNet: row.monthlyNet.toString(),
+    yearlyNet: row.yearlyNet.toString(),
+    marketed: row.marketed,
+    publishedAt: row.publishedAt?.toISOString() ?? null,
+    supersededAt: row.supersededAt?.toISOString() ?? null,
+    publishedChanges: Array.isArray(row.publishedChanges) ? row.publishedChanges : null,
+    changeNote: row.changeNote,
+    nonRegressive: row.nonRegressive,
+    // The canonical plan_versions schema carries no validity-window columns.
+    validFrom: null,
+    validUntil: null,
+    createdByUserId: row.createdByUserId,
+    publishedByUserId: row.publishedByUserId,
+    createdAt: row.createdAt.toISOString(),
+    updatedAt: row.updatedAt.toISOString()
+  };
+}
+__name(toPlanVersionRow2, "toPlanVersionRow");
+
+// src/prisma-bundle.repository.ts
+import { Inject as Inject18, Injectable as Injectable20 } from "@nestjs/common";
+function _ts_decorate20(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_decorate20, "_ts_decorate");
+function _ts_metadata18(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata18, "_ts_metadata");
+function _ts_param18(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param18, "_ts_param");
+var PrismaBundleRepository = class {
+  static {
+    __name(this, "PrismaBundleRepository");
+  }
+  prisma;
+  constructor(prisma) {
+    this.prisma = prisma;
+  }
+  db(tx) {
+    return resolveClient(this.prisma, tx);
+  }
+  // ─── Stem operations ───
+  async list(filter) {
+    const excludeDeleted = filter.excludeDeleted ?? true;
+    const rows = await this.db().bundle.findMany({
+      where: {
+        projectKey: filter.projectKey,
+        ...excludeDeleted ? {
+          deletedAt: null
+        } : {}
+      },
+      orderBy: [
+        {
+          sortOrder: "asc"
+        },
+        {
+          bundleKey: "asc"
+        }
+      ]
+    });
+    return rows.map(toBundleRow);
+  }
+  async findById(bundleId) {
+    const row = await this.db().bundle.findUnique({
+      where: {
+        id: bundleId
+      }
+    });
+    return row ? toBundleRow(row) : null;
+  }
+  async findByKey(projectKey, bundleKey) {
+    const row = await this.db().bundle.findFirst({
+      where: {
+        projectKey,
+        bundleKey,
+        deletedAt: null
+      }
+    });
+    return row ? toBundleRow(row) : null;
+  }
+  async create(data) {
+    const created = await this.db().bundle.create({
+      data: {
+        projectKey: data.projectKey,
+        bundleKey: data.bundleKey,
+        label: data.label,
+        description: data.description ?? null,
+        icon: data.icon ?? null,
+        sortOrder: data.sortOrder ?? 0,
+        i18n: data.i18n ?? {}
+      }
+    });
+    return toBundleRow(created);
+  }
+  async update(bundleId, data) {
+    const updated = await this.db().bundle.update({
+      where: {
+        id: bundleId
+      },
+      data: {
+        ...data.label !== void 0 ? {
+          label: data.label
+        } : {},
+        ...data.description !== void 0 ? {
+          description: data.description
+        } : {},
+        ...data.icon !== void 0 ? {
+          icon: data.icon
+        } : {},
+        ...data.sortOrder !== void 0 ? {
+          sortOrder: data.sortOrder
+        } : {},
+        ...data.i18n !== void 0 ? {
+          i18n: data.i18n
+        } : {}
+      }
+    });
+    return toBundleRow(updated);
+  }
+  async softDelete(bundleId) {
+    await this.db().bundle.update({
+      where: {
+        id: bundleId
+      },
+      data: {
+        deletedAt: /* @__PURE__ */ new Date()
+      }
+    });
+  }
+  // ─── Version operations ───
+  async listVersions(bundleId) {
+    const bundle = await this.db().bundle.findUnique({
+      where: {
+        id: bundleId
+      }
+    });
+    if (!bundle) return [];
+    const rows = await this.db().bundleVersion.findMany({
+      where: {
+        bundleId
+      },
+      orderBy: {
+        version: "asc"
+      }
+    });
+    return rows.map((row) => toBundleVersionRow(row, bundle));
+  }
+  async findVersionById(versionId) {
+    const row = await this.db().bundleVersion.findUnique({
+      where: {
+        id: versionId
+      }
+    });
+    if (!row) return null;
+    const bundle = await this.db().bundle.findUnique({
+      where: {
+        id: row.bundleId
+      }
+    });
+    return toBundleVersionRow(row, bundle);
+  }
+  async findCurrentDraft(bundleId) {
+    const row = await this.db().bundleVersion.findFirst({
+      where: {
+        bundleId,
+        publishedAt: null
+      }
+    });
+    if (!row) return null;
+    const bundle = await this.db().bundle.findUnique({
+      where: {
+        id: bundleId
+      }
+    });
+    return toBundleVersionRow(row, bundle);
+  }
+  async findLatestLive(bundleId, tx) {
+    const db = this.db(tx);
+    const row = await db.bundleVersion.findFirst({
+      where: {
+        bundleId,
+        publishedAt: {
+          not: null
+        },
+        supersededAt: null
+      },
+      orderBy: {
+        version: "desc"
+      }
+    });
+    if (!row) return null;
+    const bundle = await db.bundle.findUnique({
+      where: {
+        id: bundleId
+      }
+    });
+    return toBundleVersionRow(row, bundle);
+  }
+  async createDraft(data) {
+    const db = this.db();
+    const existingDraft = await db.bundleVersion.findFirst({
+      where: {
+        bundleId: data.bundleId,
+        publishedAt: null
+      }
+    });
+    if (existingDraft) {
+      throw new Error(`Bundle '${data.bundleId}' already has a draft version (v${existingDraft.version}); only one draft per bundle is allowed.`);
+    }
+    const latest = await db.bundleVersion.findFirst({
+      where: {
+        bundleId: data.bundleId
+      },
+      orderBy: {
+        version: "desc"
+      }
+    });
+    const nextVersion = latest ? latest.version + 1 : 1;
+    const created = await db.bundleVersion.create({
+      data: {
+        bundleId: data.bundleId,
+        version: nextVersion,
+        baseVersionId: data.baseVersionId ?? null,
+        features: data.features,
+        quotas: data.quotas ?? {},
+        compatibility: data.compatibility ?? {},
+        pricingOverrides: data.pricingOverrides ?? [],
+        monthlyNet: data.monthlyNet ?? null,
+        yearlyNet: data.yearlyNet ?? null,
+        marketed: data.marketed ?? true,
+        changeNote: data.changeNote ?? "",
+        createdByUserId: data.createdByUserId ?? null
+      }
+    });
+    const bundle = await db.bundle.findUnique({
+      where: {
+        id: data.bundleId
+      }
+    });
+    return toBundleVersionRow(created, bundle);
+  }
+  async updateDraft(versionId, data) {
+    const db = this.db();
+    const updated = await db.bundleVersion.update({
+      where: {
+        id: versionId
+      },
+      data: {
+        ...data.features !== void 0 ? {
+          features: data.features
+        } : {},
+        ...data.quotas !== void 0 ? {
+          quotas: data.quotas
+        } : {},
+        ...data.compatibility !== void 0 ? {
+          compatibility: data.compatibility
+        } : {},
+        ...data.pricingOverrides !== void 0 ? {
+          pricingOverrides: data.pricingOverrides
+        } : {},
+        ...data.monthlyNet !== void 0 ? {
+          monthlyNet: data.monthlyNet
+        } : {},
+        ...data.yearlyNet !== void 0 ? {
+          yearlyNet: data.yearlyNet
+        } : {},
+        ...data.marketed !== void 0 ? {
+          marketed: data.marketed
+        } : {},
+        ...data.changeNote !== void 0 ? {
+          changeNote: data.changeNote
+        } : {}
+      }
+    });
+    const bundle = await db.bundle.findUnique({
+      where: {
+        id: updated.bundleId
+      }
+    });
+    return toBundleVersionRow(updated, bundle);
+  }
+  async publishDraft(versionId, publishMeta, tx) {
+    const db = this.db(tx);
+    const draft = await db.bundleVersion.findUnique({
+      where: {
+        id: versionId
+      }
+    });
+    if (!draft) {
+      throw new Error(`BundleVersion '${versionId}' not found.`);
+    }
+    await db.bundleVersion.updateMany({
+      where: {
+        bundleId: draft.bundleId,
+        publishedAt: {
+          not: null
+        },
+        supersededAt: null,
+        NOT: {
+          id: versionId
+        }
+      },
+      data: {
+        supersededAt: /* @__PURE__ */ new Date()
+      }
+    });
+    const published = await db.bundleVersion.update({
+      where: {
+        id: versionId
+      },
+      data: {
+        publishedAt: /* @__PURE__ */ new Date(),
+        publishedByUserId: publishMeta.publishedByUserId,
+        publishedChanges: publishMeta.publishedChanges,
+        nonRegressive: publishMeta.nonRegressive
+      }
+    });
+    const bundle = await db.bundle.findUnique({
+      where: {
+        id: published.bundleId
+      }
+    });
+    return toBundleVersionRow(published, bundle);
+  }
+  async deleteDraft(versionId) {
+    const db = this.db();
+    const row = await db.bundleVersion.findUnique({
+      where: {
+        id: versionId
+      }
+    });
+    if (!row) return;
+    if (row.publishedAt !== null) {
+      throw new Error(`BundleVersion '${versionId}' is already published and cannot be discarded (published versions are immutable \u2014 contract protection P1).`);
+    }
+    try {
+      await db.bundleVersion.delete({
+        where: {
+          id: versionId
+        }
+      });
+    } catch (err) {
+      if (err?.code === "P2025") return;
+      throw err;
+    }
+  }
+};
+PrismaBundleRepository = _ts_decorate20([
+  Injectable20(),
+  _ts_param18(0, Inject18(PRISMA_CLIENT_TOKEN)),
+  _ts_metadata18("design:type", Function),
+  _ts_metadata18("design:paramtypes", [
+    typeof PrismaLike === "undefined" ? Object : PrismaLike
+  ])
+], PrismaBundleRepository);
+function isPlainObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+__name(isPlainObject, "isPlainObject");
+function toDecimalString(value) {
+  return value == null ? null : value.toString();
+}
+__name(toDecimalString, "toDecimalString");
+function toVersionChanges(value) {
+  return Array.isArray(value) ? value : null;
+}
+__name(toVersionChanges, "toVersionChanges");
+function toCompatibility(value) {
+  return isPlainObject(value) ? value : {};
+}
+__name(toCompatibility, "toCompatibility");
+function toPricingOverrides(value) {
+  return Array.isArray(value) ? value : [];
+}
+__name(toPricingOverrides, "toPricingOverrides");
+function toI18n(value) {
+  return isPlainObject(value) ? value : {};
+}
+__name(toI18n, "toI18n");
+function toBundleRow(row) {
+  return {
+    id: row.id,
+    projectKey: row.projectKey,
+    bundleKey: row.bundleKey,
+    label: row.label,
+    description: row.description,
+    icon: row.icon,
+    sortOrder: row.sortOrder,
+    i18n: toI18n(row.i18n),
+    createdAt: row.createdAt.toISOString(),
+    updatedAt: row.updatedAt.toISOString(),
+    deletedAt: row.deletedAt?.toISOString() ?? null
+  };
+}
+__name(toBundleRow, "toBundleRow");
+function toBundleVersionRow(row, bundle) {
+  return {
+    id: row.id,
+    bundleId: row.bundleId,
+    bundleKey: bundle?.bundleKey ?? "",
+    label: bundle?.label ?? "",
+    version: row.version,
+    baseVersionId: row.baseVersionId,
+    features: toStringArray(row.features),
+    quotas: toQuotaMap(row.quotas),
+    compatibility: toCompatibility(row.compatibility),
+    pricingOverrides: toPricingOverrides(row.pricingOverrides),
+    monthlyNet: toDecimalString(row.monthlyNet),
+    yearlyNet: toDecimalString(row.yearlyNet),
+    marketed: row.marketed,
+    publishedAt: row.publishedAt?.toISOString() ?? null,
+    supersededAt: row.supersededAt?.toISOString() ?? null,
+    // The canonical `bundle_versions` table has no validFrom/validUntil
+    // columns; time-aware validity is not expressible on this schema.
+    validFrom: null,
+    validUntil: null,
+    publishedChanges: toVersionChanges(row.publishedChanges),
+    changeNote: row.changeNote,
+    nonRegressive: row.nonRegressive,
+    createdByUserId: row.createdByUserId,
+    publishedByUserId: row.publishedByUserId,
+    createdAt: row.createdAt.toISOString(),
+    updatedAt: row.updatedAt.toISOString()
+  };
+}
+__name(toBundleVersionRow, "toBundleVersionRow");
+
+// src/prisma-catalog-entry.repository.ts
+import { Inject as Inject19, Injectable as Injectable21 } from "@nestjs/common";
+function _ts_decorate21(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_decorate21, "_ts_decorate");
+function _ts_metadata19(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata19, "_ts_metadata");
+function _ts_param19(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param19, "_ts_param");
+var PrismaCatalogEntryRepository = class {
+  static {
+    __name(this, "PrismaCatalogEntryRepository");
+  }
+  prisma;
+  constructor(prisma) {
+    this.prisma = prisma;
+  }
+  get db() {
+    return this.prisma;
+  }
+  async listCapabilities(filter) {
+    const rows = await this.db.capabilityCatalogEntry.findMany({
+      where: {
+        projectKey: filter.projectKey,
+        deletedAt: null,
+        ...filter.codeStatus ? {
+          codeStatus: filter.codeStatus
+        } : {}
+      },
+      orderBy: [
+        {
+          sortOrder: "asc"
+        },
+        {
+          capabilityKey: "asc"
+        }
+      ]
+    });
+    return rows.map(toCapabilityRow);
+  }
+  async listFeatures(filter) {
+    const rows = await this.db.featureCatalogEntry.findMany({
+      where: {
+        projectKey: filter.projectKey,
+        deletedAt: null,
+        ...filter.discoveryStatus ? {
+          discoveryStatus: filter.discoveryStatus
+        } : {}
+      },
+      orderBy: [
+        {
+          sortOrder: "asc"
+        },
+        {
+          featureKey: "asc"
+        }
+      ]
+    });
+    return rows.map(toFeatureRow);
+  }
+  async listQuotas(filter) {
+    const rows = await this.db.quotaCatalogEntry.findMany({
+      where: {
+        projectKey: filter.projectKey,
+        deletedAt: null,
+        ...filter.discoveryStatus ? {
+          discoveryStatus: filter.discoveryStatus
+        } : {}
+      },
+      orderBy: [
+        {
+          sortOrder: "asc"
+        },
+        {
+          quotaKey: "asc"
+        }
+      ]
+    });
+    return rows.map(toQuotaRow);
+  }
+  async upsertCapability(data) {
+    const codeFields = {
+      label: data.label,
+      description: data.description,
+      featureKey: data.featureKey,
+      bundleKey: data.bundleKey,
+      codeStatus: data.codeStatus,
+      owner: data.owner,
+      kind: data.kind,
+      replacementKey: data.replacementKey,
+      deprecatedAt: data.deprecatedAt ? new Date(data.deprecatedAt) : null,
+      removalPlannedAt: data.removalPlannedAt ? new Date(data.removalPlannedAt) : null,
+      reason: data.reason
+    };
+    const row = await this.db.capabilityCatalogEntry.upsert({
+      where: {
+        projectKey_capabilityKey: {
+          projectKey: data.projectKey,
+          capabilityKey: data.capabilityKey
+        }
+      },
+      create: {
+        projectKey: data.projectKey,
+        capabilityKey: data.capabilityKey,
+        ...codeFields
+      },
+      update: codeFields
+    });
+    return toCapabilityRow(row);
+  }
+  async upsertFeature(data) {
+    const codeFields = {
+      label: data.label,
+      description: data.description,
+      discoveryStatus: data.discoveryStatus,
+      requires: data.requires,
+      replaces: data.replaces,
+      ...data.core !== void 0 ? {
+        core: data.core
+      } : {}
+    };
+    const row = await this.db.featureCatalogEntry.upsert({
+      where: {
+        projectKey_featureKey: {
+          projectKey: data.projectKey,
+          featureKey: data.featureKey
+        }
+      },
+      create: {
+        projectKey: data.projectKey,
+        featureKey: data.featureKey,
+        ...codeFields
+      },
+      update: codeFields
+    });
+    return toFeatureRow(row);
+  }
+  async upsertQuota(data) {
+    const codeFields = {
+      label: data.label,
+      description: data.description,
+      unit: data.unit,
+      featureKey: data.featureKey,
+      usageProvider: data.usageProvider,
+      enforcementMode: data.enforcementMode,
+      discoveryStatus: data.discoveryStatus,
+      replaces: data.replaces
+    };
+    const row = await this.db.quotaCatalogEntry.upsert({
+      where: {
+        projectKey_quotaKey: {
+          projectKey: data.projectKey,
+          quotaKey: data.quotaKey
+        }
+      },
+      create: {
+        projectKey: data.projectKey,
+        quotaKey: data.quotaKey,
+        ...codeFields
+      },
+      update: codeFields
+    });
+    return toQuotaRow(row);
+  }
+  async retireMissing(projectKey, type, presentKeys) {
+    if (type === "capability") {
+      const res2 = await this.db.capabilityCatalogEntry.updateMany({
+        where: {
+          projectKey,
+          deletedAt: null,
+          codeStatus: {
+            not: "retired"
+          },
+          capabilityKey: {
+            notIn: presentKeys
+          }
+        },
+        data: {
+          codeStatus: "retired"
+        }
+      });
+      return res2.count;
+    }
+    if (type === "feature") {
+      const res2 = await this.db.featureCatalogEntry.updateMany({
+        where: {
+          projectKey,
+          deletedAt: null,
+          discoveryStatus: {
+            not: "obsolete"
+          },
+          featureKey: {
+            notIn: presentKeys
+          }
+        },
+        data: {
+          discoveryStatus: "obsolete"
+        }
+      });
+      return res2.count;
+    }
+    const res = await this.db.quotaCatalogEntry.updateMany({
+      where: {
+        projectKey,
+        deletedAt: null,
+        discoveryStatus: {
+          not: "obsolete"
+        },
+        quotaKey: {
+          notIn: presentKeys
+        }
+      },
+      data: {
+        discoveryStatus: "obsolete"
+      }
+    });
+    return res.count;
+  }
+  async setFeatureSuccessor(projectKey, featureKey, successorKey) {
+    const row = await this.db.featureCatalogEntry.update({
+      where: {
+        projectKey_featureKey: {
+          projectKey,
+          featureKey
+        }
+      },
+      data: {
+        successorKey
+      }
+    });
+    return toFeatureRow(row);
+  }
+  async setQuotaSuccessor(projectKey, quotaKey, successorKey) {
+    const row = await this.db.quotaCatalogEntry.update({
+      where: {
+        projectKey_quotaKey: {
+          projectKey,
+          quotaKey
+        }
+      },
+      data: {
+        successorKey
+      }
+    });
+    return toQuotaRow(row);
+  }
+  async findFeature(projectKey, featureKey) {
+    const row = await this.db.featureCatalogEntry.findUnique({
+      where: {
+        projectKey_featureKey: {
+          projectKey,
+          featureKey
+        }
+      }
+    });
+    return row ? toFeatureRow(row) : null;
+  }
+  async findQuota(projectKey, quotaKey) {
+    const row = await this.db.quotaCatalogEntry.findUnique({
+      where: {
+        projectKey_quotaKey: {
+          projectKey,
+          quotaKey
+        }
+      }
+    });
+    return row ? toQuotaRow(row) : null;
+  }
+  async setFeatureReview(projectKey, featureKey, data) {
+    const row = await this.db.featureCatalogEntry.update({
+      where: {
+        projectKey_featureKey: {
+          projectKey,
+          featureKey
+        }
+      },
+      data: {
+        discoveryStatus: data.discoveryStatus,
+        approvedAt: data.approvedAt ? new Date(data.approvedAt) : null,
+        approvedBy: data.approvedBy,
+        approvedSignature: data.approvedSignature
+      }
+    });
+    return toFeatureRow(row);
+  }
+  async setQuotaReview(projectKey, quotaKey, data) {
+    const row = await this.db.quotaCatalogEntry.update({
+      where: {
+        projectKey_quotaKey: {
+          projectKey,
+          quotaKey
+        }
+      },
+      data: {
+        discoveryStatus: data.discoveryStatus,
+        approvedAt: data.approvedAt ? new Date(data.approvedAt) : null,
+        approvedBy: data.approvedBy,
+        approvedSignature: data.approvedSignature
+      }
+    });
+    return toQuotaRow(row);
+  }
+  async setFeatureI18n(projectKey, featureKey, i18n) {
+    const row = await this.db.featureCatalogEntry.update({
+      where: {
+        projectKey_featureKey: {
+          projectKey,
+          featureKey
+        }
+      },
+      data: {
+        i18n
+      }
+    });
+    return toFeatureRow(row);
+  }
+  async setQuotaI18n(projectKey, quotaKey, i18n) {
+    const row = await this.db.quotaCatalogEntry.update({
+      where: {
+        projectKey_quotaKey: {
+          projectKey,
+          quotaKey
+        }
+      },
+      data: {
+        i18n
+      }
+    });
+    return toQuotaRow(row);
+  }
+  async setFeatureBase(projectKey, featureKey, data) {
+    const row = await this.db.featureCatalogEntry.update({
+      where: {
+        projectKey_featureKey: {
+          projectKey,
+          featureKey
+        }
+      },
+      data: {
+        ...data.label !== void 0 ? {
+          label: data.label
+        } : {},
+        ...data.description !== void 0 ? {
+          description: data.description
+        } : {},
+        ...data.icon !== void 0 ? {
+          icon: data.icon
+        } : {},
+        ...data.tier !== void 0 ? {
+          tier: data.tier
+        } : {}
+      }
+    });
+    return toFeatureRow(row);
+  }
+  async setQuotaBase(projectKey, quotaKey, data) {
+    const row = await this.db.quotaCatalogEntry.update({
+      where: {
+        projectKey_quotaKey: {
+          projectKey,
+          quotaKey
+        }
+      },
+      data: {
+        ...data.label !== void 0 ? {
+          label: data.label
+        } : {},
+        ...data.description !== void 0 ? {
+          description: data.description
+        } : {}
+      }
+    });
+    return toQuotaRow(row);
+  }
+};
+PrismaCatalogEntryRepository = _ts_decorate21([
+  Injectable21(),
+  _ts_param19(0, Inject19(PRISMA_CLIENT_TOKEN)),
+  _ts_metadata19("design:type", Function),
+  _ts_metadata19("design:paramtypes", [
+    typeof PrismaLike === "undefined" ? Object : PrismaLike
+  ])
+], PrismaCatalogEntryRepository);
+function toI18n2(value) {
+  if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+    return value;
+  }
+  return {};
+}
+__name(toI18n2, "toI18n");
+function toCapabilityRow(row) {
+  return {
+    id: row.id,
+    projectKey: row.projectKey,
+    capabilityKey: row.capabilityKey,
+    label: row.label,
+    description: row.description,
+    featureKey: row.featureKey,
+    bundleKey: row.bundleKey,
+    codeStatus: row.codeStatus,
+    owner: row.owner,
+    kind: row.kind,
+    replacementKey: row.replacementKey,
+    deprecatedAt: row.deprecatedAt ? row.deprecatedAt.toISOString() : null,
+    removalPlannedAt: row.removalPlannedAt ? row.removalPlannedAt.toISOString() : null,
+    reason: row.reason,
+    i18n: toI18n2(row.i18n),
+    sortOrder: row.sortOrder,
+    createdAt: row.createdAt.toISOString(),
+    updatedAt: row.updatedAt.toISOString(),
+    deletedAt: row.deletedAt ? row.deletedAt.toISOString() : null
+  };
+}
+__name(toCapabilityRow, "toCapabilityRow");
+function toFeatureRow(row) {
+  return {
+    id: row.id,
+    projectKey: row.projectKey,
+    featureKey: row.featureKey,
+    label: row.label,
+    description: row.description,
+    marketingLabel: row.marketingLabel,
+    marketingDescription: row.marketingDescription,
+    icon: row.icon,
+    tier: row.tier,
+    discoveryStatus: row.discoveryStatus,
+    requires: row.requires,
+    replaces: row.replaces,
+    successorKey: row.successorKey,
+    approvedAt: row.approvedAt ? row.approvedAt.toISOString() : null,
+    approvedBy: row.approvedBy,
+    approvedSignature: row.approvedSignature,
+    plannedOnly: row.plannedOnly,
+    core: row.core,
+    i18n: toI18n2(row.i18n),
+    sortOrder: row.sortOrder,
+    createdAt: row.createdAt.toISOString(),
+    updatedAt: row.updatedAt.toISOString(),
+    deletedAt: row.deletedAt ? row.deletedAt.toISOString() : null
+  };
+}
+__name(toFeatureRow, "toFeatureRow");
+function toQuotaRow(row) {
+  return {
+    id: row.id,
+    projectKey: row.projectKey,
+    quotaKey: row.quotaKey,
+    label: row.label,
+    description: row.description,
+    unit: row.unit,
+    featureKey: row.featureKey,
+    usageProvider: row.usageProvider,
+    enforcementMode: row.enforcementMode,
+    discoveryStatus: row.discoveryStatus,
+    replaces: row.replaces,
+    successorKey: row.successorKey,
+    approvedAt: row.approvedAt ? row.approvedAt.toISOString() : null,
+    approvedBy: row.approvedBy,
+    approvedSignature: row.approvedSignature,
+    i18n: toI18n2(row.i18n),
+    sortOrder: row.sortOrder,
+    createdAt: row.createdAt.toISOString(),
+    updatedAt: row.updatedAt.toISOString(),
+    deletedAt: row.deletedAt ? row.deletedAt.toISOString() : null
+  };
+}
+__name(toQuotaRow, "toQuotaRow");
+
+// src/prisma-marketing-projection.repository.ts
+import { Inject as Inject20, Injectable as Injectable22 } from "@nestjs/common";
+function _ts_decorate22(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_decorate22, "_ts_decorate");
+function _ts_metadata20(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata20, "_ts_metadata");
+function _ts_param20(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param20, "_ts_param");
+var PrismaMarketingProjectionRepository = class {
+  static {
+    __name(this, "PrismaMarketingProjectionRepository");
+  }
+  prisma;
+  constructor(prisma) {
+    this.prisma = prisma;
+  }
+  get db() {
+    return this.prisma;
+  }
+  async list(filter) {
+    const rows = await this.db.marketingProjection.findMany({
+      where: {
+        projectKey: filter.projectKey,
+        ...filter.targetType ? {
+          targetType: filter.targetType
+        } : {},
+        ...filter.targetVersionId ? {
+          targetVersionId: filter.targetVersionId
+        } : {},
+        ...filter.locale ? {
+          locale: filter.locale
+        } : {}
+      },
+      orderBy: [
+        {
+          priority: "desc"
+        },
+        {
+          displayLabel: "asc"
+        }
+      ]
+    });
+    return rows.map(toRow);
+  }
+  async findById(id) {
+    const row = await this.db.marketingProjection.findUnique({
+      where: {
+        id
+      }
+    });
+    return row ? toRow(row) : null;
+  }
+  async findByTarget(targetType, targetVersionId, locale) {
+    const row = await this.db.marketingProjection.findUnique({
+      where: {
+        targetType_targetVersionId_locale: {
+          targetType,
+          targetVersionId,
+          locale
+        }
+      }
+    });
+    return row ? toRow(row) : null;
+  }
+  async create(data) {
+    const row = await this.db.marketingProjection.create({
+      data: {
+        projectKey: data.projectKey,
+        targetType: data.targetType,
+        targetVersionId: data.targetVersionId,
+        locale: data.locale ?? "de",
+        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
+      }
+    });
+    return toRow(row);
+  }
+  async update(id, data) {
+    const row = await this.db.marketingProjection.update({
+      where: {
+        id
+      },
+      data: {
+        ...data.displayLabel !== void 0 ? {
+          displayLabel: data.displayLabel
+        } : {},
+        ...data.description !== void 0 ? {
+          description: data.description
+        } : {},
+        ...data.visible !== void 0 ? {
+          visible: data.visible
+        } : {},
+        ...data.badge !== void 0 ? {
+          badge: data.badge
+        } : {},
+        ...data.topFeatures !== void 0 ? {
+          topFeatures: data.topFeatures
+        } : {},
+        ...data.trialEnabled !== void 0 ? {
+          trialEnabled: data.trialEnabled
+        } : {},
+        ...data.trialDays !== void 0 ? {
+          trialDays: data.trialDays
+        } : {},
+        ...data.priceTag !== void 0 ? {
+          priceTag: data.priceTag
+        } : {},
+        ...data.ctaLabel !== void 0 ? {
+          ctaLabel: data.ctaLabel
+        } : {},
+        ...data.priority !== void 0 ? {
+          priority: data.priority
+        } : {},
+        ...data.highlight !== void 0 ? {
+          highlight: data.highlight
+        } : {}
+      }
+    });
+    return toRow(row);
+  }
+  async delete(id) {
+    await this.db.marketingProjection.delete({
+      where: {
+        id
+      }
+    });
+  }
+};
+PrismaMarketingProjectionRepository = _ts_decorate22([
+  Injectable22(),
+  _ts_param20(0, Inject20(PRISMA_CLIENT_TOKEN)),
+  _ts_metadata20("design:type", Function),
+  _ts_metadata20("design:paramtypes", [
+    typeof PrismaLike === "undefined" ? Object : PrismaLike
+  ])
+], PrismaMarketingProjectionRepository);
+function toTopFeatures(value) {
+  return Array.isArray(value) ? value : [];
+}
+__name(toTopFeatures, "toTopFeatures");
+function toRow(row) {
+  return {
+    id: row.id,
+    projectKey: row.projectKey,
+    targetType: row.targetType,
+    targetVersionId: row.targetVersionId,
+    locale: row.locale,
+    displayLabel: row.displayLabel,
+    description: row.description,
+    visible: row.visible,
+    badge: row.badge,
+    topFeatures: toTopFeatures(row.topFeatures),
+    trialEnabled: row.trialEnabled,
+    trialDays: row.trialDays,
+    priceTag: row.priceTag,
+    ctaLabel: row.ctaLabel,
+    priority: row.priority,
+    highlight: row.highlight,
+    createdAt: row.createdAt.toISOString(),
+    updatedAt: row.updatedAt.toISOString()
+  };
+}
+__name(toRow, "toRow");
+
+// src/prisma-marketing-settings.repository.ts
+import { Inject as Inject21, Injectable as Injectable23 } from "@nestjs/common";
+function _ts_decorate23(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_decorate23, "_ts_decorate");
+function _ts_metadata21(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata21, "_ts_metadata");
+function _ts_param21(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param21, "_ts_param");
+var PrismaMarketingSettingsRepository = class {
+  static {
+    __name(this, "PrismaMarketingSettingsRepository");
+  }
+  prisma;
+  constructor(prisma) {
+    this.prisma = prisma;
+  }
+  get db() {
+    return this.prisma;
+  }
+  async get(projectKey) {
+    const row = await this.db.marketingSettings.findUnique({
+      where: {
+        projectKey
+      }
+    });
+    return row ? toRow2(row) : null;
+  }
+  async upsert(projectKey, data) {
+    const row = await this.db.marketingSettings.upsert({
+      where: {
+        projectKey
+      },
+      create: {
+        projectKey,
+        activeLocales: data.activeLocales
+      },
+      update: {
+        activeLocales: data.activeLocales
+      }
+    });
+    return toRow2(row);
+  }
+};
+PrismaMarketingSettingsRepository = _ts_decorate23([
+  Injectable23(),
+  _ts_param21(0, Inject21(PRISMA_CLIENT_TOKEN)),
+  _ts_metadata21("design:type", Function),
+  _ts_metadata21("design:paramtypes", [
+    typeof PrismaLike === "undefined" ? Object : PrismaLike
+  ])
+], PrismaMarketingSettingsRepository);
+function toRow2(row) {
+  return {
+    projectKey: row.projectKey,
+    activeLocales: toStringArray(row.activeLocales),
+    updatedAt: row.updatedAt.toISOString()
+  };
+}
+__name(toRow2, "toRow");
+
+// src/prisma-promotion.repository.ts
+import { Inject as Inject22, Injectable as Injectable24 } from "@nestjs/common";
+function _ts_decorate24(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_decorate24, "_ts_decorate");
+function _ts_metadata22(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata22, "_ts_metadata");
+function _ts_param22(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param22, "_ts_param");
+var PrismaPromotionRepository = class {
+  static {
+    __name(this, "PrismaPromotionRepository");
+  }
+  prisma;
+  constructor(prisma) {
+    this.prisma = prisma;
+  }
+  get db() {
+    return this.prisma;
+  }
+  async list(filter) {
+    const rows = await this.db.promotion.findMany({
+      where: {
+        projectKey: filter.projectKey
+      },
+      orderBy: [
+        {
+          validFrom: "desc"
+        }
+      ]
+    });
+    return rows.map(toRow3);
+  }
+  async findById(id) {
+    const row = await this.db.promotion.findUnique({
+      where: {
+        id
+      }
+    });
+    return row ? toRow3(row) : null;
+  }
+  async create(data) {
+    const row = await this.db.promotion.create({
+      data: {
+        projectKey: data.projectKey,
+        internalLabel: data.internalLabel,
+        type: data.type,
+        value: data.value,
+        targetType: data.targetType ?? "PLAN",
+        appliesTo: data.appliesTo ?? [],
+        billingCycle: data.billingCycle ?? "both",
+        validFrom: new Date(data.validFrom),
+        validTo: new Date(data.validTo),
+        priority: data.priority ?? 0,
+        requiresCoupon: data.requiresCoupon ?? false,
+        codes: data.codes ?? [],
+        color: data.color ?? "#2563eb",
+        i18n: data.i18n ?? {},
+        // Null/undefined restriction is left off so the nullable column
+        // stays SQL NULL (= all locales).
+        ...Array.isArray(data.onlyLocales) ? {
+          onlyLocales: data.onlyLocales
+        } : {}
+      }
+    });
+    return toRow3(row);
+  }
+  async update(id, data) {
+    if (data.onlyLocales === null) {
+      await this.prisma.$executeRaw`
+                UPDATE promotions SET "onlyLocales" = NULL, "updatedAt" = NOW() WHERE id = ${id}`;
+    }
+    const row = await this.db.promotion.update({
+      where: {
+        id
+      },
+      data: {
+        ...data.internalLabel !== void 0 ? {
+          internalLabel: data.internalLabel
+        } : {},
+        ...data.type !== void 0 ? {
+          type: data.type
+        } : {},
+        ...data.value !== void 0 ? {
+          value: data.value
+        } : {},
+        ...data.appliesTo !== void 0 ? {
+          appliesTo: data.appliesTo
+        } : {},
+        ...data.targetType !== void 0 ? {
+          targetType: data.targetType
+        } : {},
+        ...data.billingCycle !== void 0 ? {
+          billingCycle: data.billingCycle
+        } : {},
+        ...data.validFrom !== void 0 ? {
+          validFrom: new Date(data.validFrom)
+        } : {},
+        ...data.validTo !== void 0 ? {
+          validTo: new Date(data.validTo)
+        } : {},
+        ...data.priority !== void 0 ? {
+          priority: data.priority
+        } : {},
+        ...data.requiresCoupon !== void 0 ? {
+          requiresCoupon: data.requiresCoupon
+        } : {},
+        ...data.codes !== void 0 ? {
+          codes: data.codes
+        } : {},
+        ...data.color !== void 0 ? {
+          color: data.color
+        } : {},
+        ...data.i18n !== void 0 ? {
+          i18n: data.i18n
+        } : {},
+        ...Array.isArray(data.onlyLocales) ? {
+          onlyLocales: data.onlyLocales
+        } : {}
+      }
+    });
+    return toRow3(row);
+  }
+  async delete(id) {
+    await this.db.promotion.delete({
+      where: {
+        id
+      }
+    });
+  }
+};
+PrismaPromotionRepository = _ts_decorate24([
+  Injectable24(),
+  _ts_param22(0, Inject22(PRISMA_CLIENT_TOKEN)),
+  _ts_metadata22("design:type", Function),
+  _ts_metadata22("design:paramtypes", [
+    typeof PrismaLike === "undefined" ? Object : PrismaLike
+  ])
+], PrismaPromotionRepository);
+function toPromotionValue(value) {
+  if (typeof value === "number") return value;
+  if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+    const obj = value;
+    return {
+      price: Number(obj.price),
+      months: Number(obj.months)
+    };
+  }
+  throw new Error(`Promotion.value has an unexpected shape: ${JSON.stringify(value)}`);
+}
+__name(toPromotionValue, "toPromotionValue");
+function toNullableStringArray(value) {
+  return Array.isArray(value) ? value : null;
+}
+__name(toNullableStringArray, "toNullableStringArray");
+function toPromotionI18n(value) {
+  if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+    return value;
+  }
+  return {};
+}
+__name(toPromotionI18n, "toPromotionI18n");
+function toRow3(row) {
+  return {
+    id: row.id,
+    projectKey: row.projectKey,
+    internalLabel: row.internalLabel,
+    type: row.type,
+    value: toPromotionValue(row.value),
+    appliesTo: toStringArray(row.appliesTo),
+    targetType: row.targetType,
+    billingCycle: row.billingCycle,
+    validFrom: row.validFrom.toISOString().slice(0, 10),
+    validTo: row.validTo.toISOString().slice(0, 10),
+    priority: row.priority,
+    onlyLocales: toNullableStringArray(row.onlyLocales),
+    requiresCoupon: row.requiresCoupon,
+    codes: toStringArray(row.codes),
+    color: row.color,
+    i18n: toPromotionI18n(row.i18n),
+    createdAt: row.createdAt.toISOString(),
+    updatedAt: row.updatedAt.toISOString()
+  };
+}
+__name(toRow3, "toRow");
+
+// src/prisma-subscription-contract.repository.ts
+import { Inject as Inject23, Injectable as Injectable25 } from "@nestjs/common";
+function _ts_decorate25(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_decorate25, "_ts_decorate");
+function _ts_metadata23(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata23, "_ts_metadata");
+function _ts_param23(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param23, "_ts_param");
+var ACTIVE_CONTRACT_STATUSES = [
+  "active",
+  "scheduled"
+];
+var PrismaSubscriptionContractRepository = class {
+  static {
+    __name(this, "PrismaSubscriptionContractRepository");
+  }
+  prisma;
+  constructor(prisma) {
+    this.prisma = prisma;
+  }
+  get db() {
+    return this.prisma;
+  }
+  async list(filter) {
+    const rows = await this.db.subscriptionContract.findMany({
+      where: {
+        ...filter.projectKey ? {
+          projectKey: filter.projectKey
+        } : {},
+        ...filter.tenantId ? {
+          tenantId: filter.tenantId
+        } : {},
+        ...filter.status ? {
+          status: filter.status
+        } : {},
+        ...filter.asOf ? {
+          effectiveFrom: {
+            lte: filter.asOf
+          },
+          OR: [
+            {
+              effectiveUntil: null
+            },
+            {
+              effectiveUntil: {
+                gt: filter.asOf
+              }
+            }
+          ]
+        } : {}
+      },
+      include: {
+        lineItems: true
+      },
+      orderBy: [
+        {
+          effectiveFrom: "desc"
+        },
+        {
+          createdAt: "desc"
+        }
+      ]
+    });
+    return rows.map(toRecord4);
+  }
+  async findById(contractId) {
+    const row = await this.db.subscriptionContract.findUnique({
+      where: {
+        id: contractId
+      },
+      include: {
+        lineItems: true
+      }
+    });
+    return row ? toRecord4(row) : null;
+  }
+  async findActiveByTenantId(tenantId, asOf = /* @__PURE__ */ new Date()) {
+    const row = await this.db.subscriptionContract.findFirst({
+      where: {
+        tenantId,
+        status: {
+          in: ACTIVE_CONTRACT_STATUSES
+        },
+        effectiveFrom: {
+          lte: asOf
+        },
+        OR: [
+          {
+            effectiveUntil: null
+          },
+          {
+            effectiveUntil: {
+              gt: asOf
+            }
+          }
+        ]
+      },
+      include: {
+        lineItems: true
+      },
+      orderBy: [
+        {
+          effectiveFrom: "desc"
+        },
+        {
+          createdAt: "desc"
+        }
+      ]
+    });
+    return row ? toRecord4(row) : null;
+  }
+  async create(data) {
+    const row = await this.db.subscriptionContract.create({
+      data: {
+        projectKey: data.projectKey,
+        tenantId: data.tenantId,
+        status: data.status ?? "active",
+        effectiveFrom: data.effectiveFrom,
+        effectiveUntil: data.effectiveUntil ?? null,
+        originalOfferId: data.originalOfferId ?? null,
+        originalPlanVersionId: data.originalPlanVersionId ?? null,
+        originalBundleVersionIds: data.originalBundleVersionIds ?? [],
+        priceSnapshot: data.priceSnapshot,
+        promotionSnapshots: data.promotionSnapshots ?? [],
+        promoCodeSnapshots: data.promoCodeSnapshots ?? [],
+        // Nullable JSON columns are omitted when absent so they stay SQL
+        // NULL (the DbNull sentinel is not available in this package).
+        ...data.entitlementSnapshot != null ? {
+          entitlementSnapshot: data.entitlementSnapshot
+        } : {},
+        ...data.termsSnapshot != null ? {
+          termsSnapshot: data.termsSnapshot
+        } : {},
+        lineItems: {
+          create: data.lineItems.map(toLineItemCreate)
+        }
+      },
+      include: {
+        lineItems: true
+      }
+    });
+    return toRecord4(row);
+  }
+  async terminate(contractId, data) {
+    const row = await this.db.subscriptionContract.update({
+      where: {
+        id: contractId
+      },
+      data: {
+        effectiveUntil: data.effectiveUntil,
+        status: data.status
+      },
+      include: {
+        lineItems: true
+      }
+    });
+    return toRecord4(row);
+  }
+};
+PrismaSubscriptionContractRepository = _ts_decorate25([
+  Injectable25(),
+  _ts_param23(0, Inject23(PRISMA_CLIENT_TOKEN)),
+  _ts_metadata23("design:type", Function),
+  _ts_metadata23("design:paramtypes", [
+    typeof PrismaLike === "undefined" ? Object : PrismaLike
+  ])
+], PrismaSubscriptionContractRepository);
+function toLineItemCreate(item) {
+  return {
+    kind: item.kind,
+    sourceKey: item.sourceKey,
+    sourceVersionId: item.sourceVersionId ?? null,
+    titleSnapshot: item.titleSnapshot,
+    descriptionSnapshot: item.descriptionSnapshot ?? null,
+    quantity: item.quantity,
+    unit: item.unit ?? null,
+    priceNet: item.priceNet,
+    priceGross: item.priceGross,
+    billingCycle: item.billingCycle,
+    minimumTermUntil: item.minimumTermUntil ?? null,
+    featuresSnapshot: item.featuresSnapshot,
+    quotaEffectsSnapshot: item.quotaEffectsSnapshot,
+    ...item.metadata != null ? {
+      metadata: item.metadata
+    } : {}
+  };
+}
+__name(toLineItemCreate, "toLineItemCreate");
+function isPlainObject2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+__name(isPlainObject2, "isPlainObject");
+function toUnknownArray(value) {
+  return Array.isArray(value) ? value : [];
+}
+__name(toUnknownArray, "toUnknownArray");
+function toRecordOrNull(value) {
+  return isPlainObject2(value) ? value : null;
+}
+__name(toRecordOrNull, "toRecordOrNull");
+function toLineItem(row) {
+  return {
+    id: row.id,
+    contractId: row.contractId,
+    kind: row.kind,
+    sourceKey: row.sourceKey,
+    sourceVersionId: row.sourceVersionId,
+    titleSnapshot: row.titleSnapshot,
+    descriptionSnapshot: row.descriptionSnapshot,
+    quantity: row.quantity,
+    unit: row.unit,
+    priceNet: Number(row.priceNet),
+    priceGross: Number(row.priceGross),
+    billingCycle: row.billingCycle,
+    minimumTermUntil: row.minimumTermUntil,
+    featuresSnapshot: toStringArray(row.featuresSnapshot),
+    quotaEffectsSnapshot: toQuotaMap(row.quotaEffectsSnapshot),
+    metadata: toRecordOrNull(row.metadata),
+    createdAt: row.createdAt
+  };
+}
+__name(toLineItem, "toLineItem");
+function toRecord4(row) {
+  return {
+    id: row.id,
+    projectKey: row.projectKey,
+    tenantId: row.tenantId,
+    status: row.status,
+    effectiveFrom: row.effectiveFrom,
+    effectiveUntil: row.effectiveUntil,
+    originalOfferId: row.originalOfferId,
+    originalPlanVersionId: row.originalPlanVersionId,
+    originalBundleVersionIds: toStringArray(row.originalBundleVersionIds),
+    entitlementSnapshot: isPlainObject2(row.entitlementSnapshot) ? row.entitlementSnapshot : null,
+    priceSnapshot: row.priceSnapshot,
+    promotionSnapshots: toUnknownArray(row.promotionSnapshots),
+    promoCodeSnapshots: toUnknownArray(row.promoCodeSnapshots),
+    termsSnapshot: toRecordOrNull(row.termsSnapshot),
+    lineItems: row.lineItems.map(toLineItem),
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt
+  };
+}
+__name(toRecord4, "toRecord");
 export {
   AsyncLocalRlsBypassAdapter,
   PASSWORD_HASHER_TOKEN,
@@ -1424,16 +3674,25 @@ export {
   PrismaAuditAdapter,
   PrismaAuditQueryAdapter,
   PrismaAuditStatsAdapter,
+  PrismaBundleRepository,
+  PrismaCatalogEntryRepository,
+  PrismaMarketingProjectionRepository,
+  PrismaMarketingSettingsRepository,
   PrismaMfaAdapter,
   PrismaPlanCatalogImportSink,
   PrismaPlanCatalogReadSink,
+  PrismaPlanRepository,
   PrismaPlanVersionRepository,
   PrismaPromoCodeRedemptionRepository,
   PrismaPromoCodeRepository,
   PrismaPromoCodeValidationLogRepository,
   PrismaPromoSubscriptionLookup,
+  PrismaPromotionRepository,
+  PrismaSubscriptionBundleRepository,
+  PrismaSubscriptionContractRepository,
   PrismaSubscriptionRepository,
   PrismaSuperAdminBootstrapAdapter,
+  PrismaTenantSubscriptionWriteAdapter,
   PrismaTransactionRunner,
   ZeroPromoRevenueDeductionAggregator,
   buildActorTag,