@saasicat/adapter-prisma 0.3.0

package/dist/index.js

@@ -0,0 +1,1441 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/prisma-client-token.ts
+var PRISMA_CLIENT_TOKEN = /* @__PURE__ */ Symbol.for("saasicat/adapter-prisma/PrismaClient");
+
+// src/async-local-rls-bypass.adapter.ts
+import { Injectable } from "@nestjs/common";
+import { AsyncLocalStorage } from "async_hooks";
+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 AsyncLocalRlsBypassAdapter = class {
+  static {
+    __name(this, "AsyncLocalRlsBypassAdapter");
+  }
+  storage = new AsyncLocalStorage();
+  async runWithBypass(fn) {
+    return this.storage.run({
+      bypass: true
+    }, fn);
+  }
+  /**
+   * `true` during the execution of a `runWithBypass(...)` callback.
+   * Query this in the PrismaService or an interceptor.
+   */
+  isBypassActive() {
+    return this.storage.getStore()?.bypass === true;
+  }
+};
+AsyncLocalRlsBypassAdapter = _ts_decorate([
+  Injectable()
+], AsyncLocalRlsBypassAdapter);
+
+// src/prisma-audit.adapter.ts
+import { Inject, Injectable as Injectable2 } from "@nestjs/common";
+function _ts_decorate2(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_decorate2, "_ts_decorate");
+function _ts_metadata(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata, "_ts_metadata");
+function _ts_param(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param, "_ts_param");
+function buildActorTag(actor) {
+  return `${actor.source}:${actor.email}:${actor.context}`;
+}
+__name(buildActorTag, "buildActorTag");
+var PrismaAuditAdapter = class {
+  static {
+    __name(this, "PrismaAuditAdapter");
+  }
+  prisma;
+  constructor(prisma) {
+    this.prisma = prisma;
+  }
+  async write(input) {
+    await this.prisma.auditLog.create({
+      data: {
+        tenantId: null,
+        userId: input.actor.userId,
+        entity: input.entity,
+        entityId: input.entityId,
+        action: input.action,
+        changes: input.changes ?? {},
+        actorTag: buildActorTag(input.actor)
+      }
+    });
+  }
+};
+PrismaAuditAdapter = _ts_decorate2([
+  Injectable2(),
+  _ts_param(0, Inject(PRISMA_CLIENT_TOKEN)),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof PrismaLike === "undefined" ? Object : PrismaLike
+  ])
+], PrismaAuditAdapter);
+
+// src/prisma-audit-query.adapter.ts
+import { Inject as Inject2, Injectable as Injectable3 } from "@nestjs/common";
+function _ts_decorate3(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_decorate3, "_ts_decorate");
+function _ts_metadata2(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata2, "_ts_metadata");
+function _ts_param2(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param2, "_ts_param");
+var DEFAULT_PAGE_SIZE = 50;
+var MAX_PAGE_SIZE = 200;
+var PrismaAuditQueryAdapter = class {
+  static {
+    __name(this, "PrismaAuditQueryAdapter");
+  }
+  prisma;
+  constructor(prisma) {
+    this.prisma = prisma;
+  }
+  async list(filter) {
+    const page = Math.max(filter.page ?? 1, 1);
+    const pageSize = Math.min(Math.max(filter.pageSize ?? DEFAULT_PAGE_SIZE, 1), MAX_PAGE_SIZE);
+    const rows = await this.prisma.auditLog.findMany({
+      where: {
+        tenantId: filter.tenantId,
+        userId: filter.userId,
+        entity: filter.entity,
+        entityId: filter.entityId,
+        action: filter.action,
+        actorTag: toActorTagFilter(filter.actorTag),
+        createdAt: filter.from || filter.to ? {
+          gte: filter.from ? new Date(filter.from) : void 0,
+          lte: filter.to ? new Date(filter.to) : void 0
+        } : void 0
+      },
+      orderBy: {
+        createdAt: "desc"
+      },
+      skip: (page - 1) * pageSize,
+      take: pageSize
+    });
+    return rows.map(toAuditEntry);
+  }
+};
+PrismaAuditQueryAdapter = _ts_decorate3([
+  Injectable3(),
+  _ts_param2(0, Inject2(PRISMA_CLIENT_TOKEN)),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    typeof PrismaLike === "undefined" ? Object : PrismaLike
+  ])
+], PrismaAuditQueryAdapter);
+function toActorTagFilter(actorTag) {
+  if (!actorTag) return void 0;
+  if (actorTag.endsWith("*")) return {
+    startsWith: actorTag.slice(0, -1)
+  };
+  return actorTag;
+}
+__name(toActorTagFilter, "toActorTagFilter");
+function toAuditEntry(row) {
+  return {
+    id: row.id,
+    tenantId: row.tenantId,
+    userId: row.userId,
+    // The schema does not persist the email — the actorTag carries it.
+    userEmail: row.actorTag?.split(":")[1] ?? null,
+    entity: row.entity,
+    entityId: row.entityId,
+    action: row.action,
+    changes: row.changes ?? null,
+    actorTag: row.actorTag,
+    ipAddress: row.ipAddress,
+    userAgent: row.userAgent,
+    createdAt: row.createdAt.toISOString()
+  };
+}
+__name(toAuditEntry, "toAuditEntry");
+
+// src/prisma-audit-stats.adapter.ts
+import { Inject as Inject3, Injectable as Injectable4 } from "@nestjs/common";
+function _ts_decorate4(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_decorate4, "_ts_decorate");
+function _ts_metadata3(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata3, "_ts_metadata");
+function _ts_param3(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param3, "_ts_param");
+var PrismaAuditStatsAdapter = class {
+  static {
+    __name(this, "PrismaAuditStatsAdapter");
+  }
+  prisma;
+  constructor(prisma) {
+    this.prisma = prisma;
+  }
+  async countSince(since) {
+    return this.prisma.auditLog.count({
+      where: {
+        createdAt: {
+          gte: since
+        }
+      }
+    });
+  }
+};
+PrismaAuditStatsAdapter = _ts_decorate4([
+  Injectable4(),
+  _ts_param3(0, Inject3(PRISMA_CLIENT_TOKEN)),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof PrismaLike === "undefined" ? Object : PrismaLike
+  ])
+], PrismaAuditStatsAdapter);
+
+// src/prisma-mfa.adapter.ts
+import { Inject as Inject4, Injectable as Injectable5 } from "@nestjs/common";
+function _ts_decorate5(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_decorate5, "_ts_decorate");
+function _ts_metadata4(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata4, "_ts_metadata");
+function _ts_param4(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param4, "_ts_param");
+var PrismaMfaAdapter = class {
+  static {
+    __name(this, "PrismaMfaAdapter");
+  }
+  prisma;
+  constructor(prisma) {
+    this.prisma = prisma;
+  }
+  async getSecret(userId) {
+    const row = await this.prisma.superAdminMfa.findUnique({
+      where: {
+        userId
+      }
+    });
+    return row?.secret ?? null;
+  }
+  async setSecret(userId, secret) {
+    const enabledAt = secret ? /* @__PURE__ */ new Date() : null;
+    await this.prisma.superAdminMfa.upsert({
+      where: {
+        userId
+      },
+      create: {
+        userId,
+        secret,
+        enabledAt
+      },
+      update: {
+        secret,
+        enabledAt
+      }
+    });
+  }
+  async isEnabled(userId) {
+    const row = await this.prisma.superAdminMfa.findUnique({
+      where: {
+        userId
+      }
+    });
+    return !!row?.secret && !!row?.enabledAt;
+  }
+};
+PrismaMfaAdapter = _ts_decorate5([
+  Injectable5(),
+  _ts_param4(0, Inject4(PRISMA_CLIENT_TOKEN)),
+  _ts_metadata4("design:type", Function),
+  _ts_metadata4("design:paramtypes", [
+    typeof PrismaLike === "undefined" ? Object : PrismaLike
+  ])
+], PrismaMfaAdapter);
+
+// src/prisma-plan-catalog-import-sink.ts
+import { Inject as Inject5, Injectable as Injectable6 } from "@nestjs/common";
+function _ts_decorate6(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_decorate6, "_ts_decorate");
+function _ts_metadata5(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata5, "_ts_metadata");
+function _ts_param5(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param5, "_ts_param");
+var PrismaPlanCatalogImportSink = class {
+  static {
+    __name(this, "PrismaPlanCatalogImportSink");
+  }
+  prisma;
+  constructor(prisma) {
+    this.prisma = prisma;
+  }
+  async upsertPlan(input) {
+    const existing = await this.prisma.plan.findFirst({
+      where: {
+        projectKey: input.projectKey,
+        planKey: input.planKey
+      }
+    });
+    if (existing) return {
+      created: false,
+      skipReason: "exists"
+    };
+    await this.prisma.plan.create({
+      data: {
+        projectKey: input.projectKey,
+        planKey: input.planKey,
+        label: input.label,
+        description: input.description ?? null,
+        sortOrder: input.sortOrder ?? 0
+      }
+    });
+    return {
+      created: true
+    };
+  }
+  async upsertPlanVersion(input) {
+    const existing = await this.prisma.planVersion.findFirst({
+      where: {
+        planId: input.planKey,
+        version: input.version
+      }
+    });
+    if (existing) return {
+      created: false,
+      skipReason: "exists"
+    };
+    const now = /* @__PURE__ */ new Date();
+    if (input.publish) {
+      await this.prisma.planVersion.updateMany({
+        where: {
+          planId: input.planKey,
+          publishedAt: {
+            not: null
+          },
+          supersededAt: null,
+          version: {
+            lt: input.version
+          }
+        },
+        data: {
+          supersededAt: now
+        }
+      });
+    }
+    await this.prisma.planVersion.create({
+      data: {
+        planId: input.planKey,
+        version: input.version,
+        features: input.features,
+        quotas: input.quotas,
+        monthlyNet: input.monthlyNet,
+        yearlyNet: input.yearlyNet,
+        marketed: input.marketed,
+        publishedAt: input.publish ? now : null,
+        changeNote: input.changeNote
+      }
+    });
+    return {
+      created: true
+    };
+  }
+  async upsertFeatureCatalogEntry(input) {
+    const existing = await this.prisma.featureCatalogEntry.findFirst({
+      where: {
+        projectKey: input.projectKey,
+        featureKey: input.featureKey
+      }
+    });
+    if (existing) return {
+      created: false,
+      skipReason: "exists"
+    };
+    await this.prisma.featureCatalogEntry.create({
+      data: {
+        projectKey: input.projectKey,
+        featureKey: input.featureKey,
+        label: input.label ?? input.featureKey,
+        icon: input.icon ?? null,
+        tier: input.tier ?? null,
+        plannedOnly: input.plannedOnly ?? false,
+        core: input.core ?? false
+      }
+    });
+    return {
+      created: true
+    };
+  }
+};
+PrismaPlanCatalogImportSink = _ts_decorate6([
+  Injectable6(),
+  _ts_param5(0, Inject5(PRISMA_CLIENT_TOKEN)),
+  _ts_metadata5("design:type", Function),
+  _ts_metadata5("design:paramtypes", [
+    typeof PrismaLike === "undefined" ? Object : PrismaLike
+  ])
+], PrismaPlanCatalogImportSink);
+
+// src/prisma-plan-catalog-read-sink.ts
+import { Inject as Inject6, Injectable as Injectable7 } from "@nestjs/common";
+
+// src/tx.ts
+function resolveClient(client, tx) {
+  return tx ?? client;
+}
+__name(resolveClient, "resolveClient");
+function toQuotaMap(value) {
+  if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+    return value;
+  }
+  return {};
+}
+__name(toQuotaMap, "toQuotaMap");
+function toStringArray(value) {
+  return Array.isArray(value) ? value : [];
+}
+__name(toStringArray, "toStringArray");
+
+// src/prisma-plan-catalog-read-sink.ts
+function _ts_decorate7(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_decorate7, "_ts_decorate");
+function _ts_metadata6(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata6, "_ts_metadata");
+function _ts_param6(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param6, "_ts_param");
+var PrismaPlanCatalogReadSink = class {
+  static {
+    __name(this, "PrismaPlanCatalogReadSink");
+  }
+  prisma;
+  constructor(prisma) {
+    this.prisma = prisma;
+  }
+  async loadSnapshot(projectKey) {
+    const plans = await this.prisma.plan.findMany({
+      where: {
+        projectKey,
+        deletedAt: null
+      },
+      orderBy: {
+        sortOrder: "asc"
+      }
+    });
+    const planKeys = plans.map((plan) => plan.planKey);
+    const livePlanVersions = planKeys.length === 0 ? [] : await this.prisma.planVersion.findMany({
+      where: {
+        planId: {
+          in: planKeys
+        },
+        publishedAt: {
+          not: null
+        },
+        supersededAt: null
+      }
+    });
+    const featureEntries = await this.prisma.featureCatalogEntry.findMany({
+      where: {
+        projectKey,
+        deletedAt: null
+      },
+      orderBy: {
+        sortOrder: "asc"
+      }
+    });
+    return {
+      plans: plans.map(toPlanRow),
+      livePlanVersions: livePlanVersions.map(toPlanVersionRow),
+      featureEntries: featureEntries.map(toFeatureCatalogEntryRow)
+    };
+  }
+};
+PrismaPlanCatalogReadSink = _ts_decorate7([
+  Injectable7(),
+  _ts_param6(0, Inject6(PRISMA_CLIENT_TOKEN)),
+  _ts_metadata6("design:type", Function),
+  _ts_metadata6("design:paramtypes", [
+    typeof PrismaLike === "undefined" ? Object : PrismaLike
+  ])
+], PrismaPlanCatalogReadSink);
+function toPlanRow(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 ? row.deletedAt.toISOString() : null
+  };
+}
+__name(toPlanRow, "toPlanRow");
+function toPlanVersionRow(row) {
+  return {
+    id: row.id,
+    planId: row.planId,
+    version: row.version,
+    baseVersionId: row.baseVersionId,
+    publishedAt: row.publishedAt ? row.publishedAt.toISOString() : null,
+    supersededAt: row.supersededAt ? row.supersededAt.toISOString() : null,
+    publishedChanges: row.publishedChanges ?? null,
+    changeNote: row.changeNote,
+    nonRegressive: row.nonRegressive,
+    validFrom: null,
+    validUntil: null,
+    createdByUserId: row.createdByUserId,
+    publishedByUserId: row.publishedByUserId,
+    createdAt: row.createdAt.toISOString(),
+    updatedAt: row.updatedAt.toISOString(),
+    features: toStringArray(row.features),
+    quotas: toQuotaMap(row.quotas),
+    monthlyNet: String(row.monthlyNet),
+    yearlyNet: String(row.yearlyNet),
+    marketed: row.marketed
+  };
+}
+__name(toPlanVersionRow, "toPlanVersionRow");
+function toFeatureCatalogEntryRow(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: row.i18n ?? {},
+    sortOrder: row.sortOrder,
+    createdAt: row.createdAt.toISOString(),
+    updatedAt: row.updatedAt.toISOString(),
+    deletedAt: row.deletedAt ? row.deletedAt.toISOString() : null
+  };
+}
+__name(toFeatureCatalogEntryRow, "toFeatureCatalogEntryRow");
+
+// src/prisma-plan-version.repository.ts
+import { Inject as Inject7, Injectable as Injectable8 } from "@nestjs/common";
+function _ts_decorate8(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_decorate8, "_ts_decorate");
+function _ts_metadata7(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata7, "_ts_metadata");
+function _ts_param7(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param7, "_ts_param");
+var PrismaPlanVersionRepository = class {
+  static {
+    __name(this, "PrismaPlanVersionRepository");
+  }
+  prisma;
+  constructor(prisma) {
+    this.prisma = prisma;
+  }
+  async findLatestLive(planId, tx) {
+    const db = resolveClient(this.prisma, tx);
+    const row = await db.planVersion.findFirst({
+      where: {
+        planId,
+        publishedAt: {
+          not: null
+        },
+        supersededAt: null
+      },
+      orderBy: {
+        version: "desc"
+      }
+    });
+    if (!row) return null;
+    return {
+      planId: row.planId,
+      quotas: toQuotaMap(row.quotas),
+      features: toStringArray(row.features)
+    };
+  }
+};
+PrismaPlanVersionRepository = _ts_decorate8([
+  Injectable8(),
+  _ts_param7(0, Inject7(PRISMA_CLIENT_TOKEN)),
+  _ts_metadata7("design:type", Function),
+  _ts_metadata7("design:paramtypes", [
+    typeof PrismaLike === "undefined" ? Object : PrismaLike
+  ])
+], PrismaPlanVersionRepository);
+
+// src/prisma-promo-code-redemption.repository.ts
+import { Inject as Inject8, Injectable as Injectable9 } from "@nestjs/common";
+function _ts_decorate9(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_decorate9, "_ts_decorate");
+function _ts_metadata8(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata8, "_ts_metadata");
+function _ts_param8(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param8, "_ts_param");
+var PrismaPromoCodeRedemptionRepository = class {
+  static {
+    __name(this, "PrismaPromoCodeRedemptionRepository");
+  }
+  prisma;
+  constructor(prisma) {
+    this.prisma = prisma;
+  }
+  async findBySubscription(subscriptionId, tx) {
+    const db = resolveClient(this.prisma, tx);
+    const row = await db.promoCodeRedemption.findUnique({
+      where: {
+        subscriptionId
+      }
+    });
+    return row ? toRecord(row) : null;
+  }
+  async create(data, tx) {
+    const db = resolveClient(this.prisma, tx);
+    const row = await db.promoCodeRedemption.create({
+      data: {
+        promoCodeId: data.promoCodeId,
+        subscriptionId: data.subscriptionId,
+        tenantId: data.tenantId,
+        appliedValueType: data.appliedValueType,
+        appliedValue: data.appliedValue,
+        appliedDurationType: data.appliedDurationType,
+        appliedDurationValue: data.appliedDurationValue,
+        startsAt: data.startsAt,
+        endsAt: data.endsAt
+      }
+    });
+    return toRecord(row);
+  }
+  async setReversed(id, tx) {
+    const db = resolveClient(this.prisma, tx);
+    const row = await db.promoCodeRedemption.update({
+      where: {
+        id
+      },
+      data: {
+        status: "REVERSED",
+        reversedAt: /* @__PURE__ */ new Date()
+      }
+    });
+    return toRecord(row);
+  }
+  async countByPromoCode(promoCodeId, status) {
+    return this.prisma.promoCodeRedemption.count({
+      where: {
+        promoCodeId,
+        status
+      }
+    });
+  }
+  async listByPromoCode(promoCodeId) {
+    const rows = await this.prisma.promoCodeRedemption.findMany({
+      where: {
+        promoCodeId
+      },
+      orderBy: {
+        redeemedAt: "desc"
+      }
+    });
+    return rows.map(toRecord);
+  }
+  async expireDueRedemptions(now) {
+    const result = await this.prisma.promoCodeRedemption.updateMany({
+      where: {
+        status: "ACTIVE",
+        endsAt: {
+          lt: now
+        }
+      },
+      data: {
+        status: "EXPIRED"
+      }
+    });
+    return result.count;
+  }
+};
+PrismaPromoCodeRedemptionRepository = _ts_decorate9([
+  Injectable9(),
+  _ts_param8(0, Inject8(PRISMA_CLIENT_TOKEN)),
+  _ts_metadata8("design:type", Function),
+  _ts_metadata8("design:paramtypes", [
+    typeof PrismaLike === "undefined" ? Object : PrismaLike
+  ])
+], PrismaPromoCodeRedemptionRepository);
+function toRecord(row) {
+  return {
+    id: row.id,
+    promoCodeId: row.promoCodeId,
+    subscriptionId: row.subscriptionId,
+    tenantId: row.tenantId,
+    appliedValueType: row.appliedValueType,
+    appliedValue: String(row.appliedValue),
+    appliedDurationType: row.appliedDurationType,
+    appliedDurationValue: row.appliedDurationValue,
+    startsAt: row.startsAt,
+    endsAt: row.endsAt,
+    status: row.status,
+    redeemedAt: row.redeemedAt,
+    reversedAt: row.reversedAt
+  };
+}
+__name(toRecord, "toRecord");
+
+// src/prisma-promo-code.repository.ts
+import { Inject as Inject9, Injectable as Injectable10 } from "@nestjs/common";
+function _ts_decorate10(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_decorate10, "_ts_decorate");
+function _ts_metadata9(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata9, "_ts_metadata");
+function _ts_param9(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param9, "_ts_param");
+var PrismaPromoCodeRepository = class {
+  static {
+    __name(this, "PrismaPromoCodeRepository");
+  }
+  prisma;
+  constructor(prisma) {
+    this.prisma = prisma;
+  }
+  async findById(id) {
+    const row = await this.prisma.promoCode.findUnique({
+      where: {
+        id
+      }
+    });
+    return row ? toRecord2(row) : null;
+  }
+  async findByCode(code, tx) {
+    const db = resolveClient(this.prisma, tx);
+    const row = await db.promoCode.findUnique({
+      where: {
+        code: normalizeCode(code)
+      }
+    });
+    if (!row || row.deletedAt) return null;
+    return toRecord2(row);
+  }
+  async findMany(filter) {
+    const rows = await this.prisma.promoCode.findMany({
+      where: {
+        deletedAt: null,
+        status: filter.status,
+        campaignTag: filter.campaignTag,
+        code: filter.search ? {
+          contains: normalizeCode(filter.search)
+        } : void 0
+      },
+      orderBy: {
+        createdAt: "desc"
+      }
+    });
+    return rows.map(toRecord2);
+  }
+  async create(data) {
+    const row = await this.prisma.promoCode.create({
+      data: {
+        code: normalizeCode(data.code),
+        valueType: data.valueType,
+        value: data.value.toFixed(2),
+        durationType: data.durationType,
+        durationValue: data.durationValue ?? null,
+        validFrom: data.validFrom ?? null,
+        validUntil: data.validUntil ?? null,
+        maxRedemptions: data.maxRedemptions ?? null,
+        appliesToPlans: data.appliesToPlans ?? [],
+        appliesToBilling: data.appliesToBilling ?? null,
+        firstTimeCustomersOnly: data.firstTimeCustomersOnly ?? true,
+        minimumPlanAmountGross: data.minimumPlanAmountGross?.toFixed(2) ?? null,
+        allowZeroInvoice: data.allowZeroInvoice ?? false,
+        description: data.description ?? null,
+        campaignTag: data.campaignTag ?? null,
+        revenueDeductionAccount: data.revenueDeductionAccount ?? null,
+        createdById: data.createdById
+      }
+    });
+    return toRecord2(row);
+  }
+  async update(id, data) {
+    const row = await this.prisma.promoCode.update({
+      where: {
+        id
+      },
+      data: {
+        status: data.status,
+        description: data.description,
+        validUntil: data.validUntil,
+        maxRedemptions: data.maxRedemptions
+      }
+    });
+    return toRecord2(row);
+  }
+  async softDelete(id) {
+    await this.prisma.promoCode.update({
+      where: {
+        id
+      },
+      data: {
+        deletedAt: /* @__PURE__ */ new Date()
+      }
+    });
+  }
+  async claimSlot(id, tx) {
+    const db = resolveClient(this.prisma, tx);
+    const updated = await db.$executeRaw`
+            UPDATE promo_codes
+            SET "redemptionsCount" = "redemptionsCount" + 1, "updatedAt" = NOW()
+            WHERE id = ${id}
+              AND status = 'ACTIVE'
+              AND "deletedAt" IS NULL
+              AND ("maxRedemptions" IS NULL OR "redemptionsCount" < "maxRedemptions")`;
+    return updated === 1;
+  }
+  async markExhaustedIfFull(id, tx) {
+    const db = resolveClient(this.prisma, tx);
+    await db.$executeRaw`
+            UPDATE promo_codes
+            SET status = 'EXHAUSTED', "updatedAt" = NOW()
+            WHERE id = ${id}
+              AND status = 'ACTIVE'
+              AND "maxRedemptions" IS NOT NULL
+              AND "redemptionsCount" >= "maxRedemptions"`;
+  }
+  async releaseSlot(id, tx) {
+    const db = resolveClient(this.prisma, tx);
+    await db.$executeRaw`
+            UPDATE promo_codes
+            SET "redemptionsCount" = GREATEST("redemptionsCount" - 1, 0),
+                status = CASE WHEN status = 'EXHAUSTED' THEN 'ACTIVE' ELSE status END,
+                "updatedAt" = NOW()
+            WHERE id = ${id}`;
+  }
+  async expireDueCodes(now) {
+    const result = await this.prisma.promoCode.updateMany({
+      where: {
+        status: {
+          in: [
+            "ACTIVE",
+            "PAUSED"
+          ]
+        },
+        validUntil: {
+          lt: now
+        }
+      },
+      data: {
+        status: "EXPIRED"
+      }
+    });
+    return result.count;
+  }
+};
+PrismaPromoCodeRepository = _ts_decorate10([
+  Injectable10(),
+  _ts_param9(0, Inject9(PRISMA_CLIENT_TOKEN)),
+  _ts_metadata9("design:type", Function),
+  _ts_metadata9("design:paramtypes", [
+    typeof PrismaLike === "undefined" ? Object : PrismaLike
+  ])
+], PrismaPromoCodeRepository);
+function normalizeCode(code) {
+  return code.trim().toUpperCase();
+}
+__name(normalizeCode, "normalizeCode");
+function toRecord2(row) {
+  return {
+    id: row.id,
+    code: row.code,
+    valueType: row.valueType,
+    value: String(row.value),
+    durationType: row.durationType,
+    durationValue: row.durationValue,
+    validFrom: row.validFrom,
+    validUntil: row.validUntil,
+    maxRedemptions: row.maxRedemptions,
+    redemptionsCount: row.redemptionsCount,
+    appliesToPlans: row.appliesToPlans,
+    appliesToBilling: row.appliesToBilling ?? null,
+    firstTimeCustomersOnly: row.firstTimeCustomersOnly,
+    minimumPlanAmountGross: row.minimumPlanAmountGross === null ? null : String(row.minimumPlanAmountGross),
+    allowZeroInvoice: row.allowZeroInvoice,
+    status: row.status,
+    description: row.description,
+    campaignTag: row.campaignTag,
+    revenueDeductionAccount: row.revenueDeductionAccount,
+    createdById: row.createdById,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt,
+    deletedAt: row.deletedAt
+  };
+}
+__name(toRecord2, "toRecord");
+
+// src/prisma-promo-code-validation-log.repository.ts
+import { Inject as Inject10, Injectable as Injectable11 } from "@nestjs/common";
+function _ts_decorate11(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_decorate11, "_ts_decorate");
+function _ts_metadata10(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata10, "_ts_metadata");
+function _ts_param10(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param10, "_ts_param");
+var PrismaPromoCodeValidationLogRepository = class {
+  static {
+    __name(this, "PrismaPromoCodeValidationLogRepository");
+  }
+  prisma;
+  constructor(prisma) {
+    this.prisma = prisma;
+  }
+  async log(args) {
+    await this.prisma.promoCodeValidationLog.create({
+      data: {
+        promoCodeId: args.promoCodeId,
+        codeAttempt: args.codeAttempt.trim().toUpperCase(),
+        result: args.result,
+        ipHash: args.ipHash ?? null,
+        sessionId: args.sessionId ?? null
+      }
+    });
+  }
+  async countValid(promoCodeId) {
+    return this.prisma.promoCodeValidationLog.count({
+      where: {
+        promoCodeId,
+        result: "VALID"
+      }
+    });
+  }
+};
+PrismaPromoCodeValidationLogRepository = _ts_decorate11([
+  Injectable11(),
+  _ts_param10(0, Inject10(PRISMA_CLIENT_TOKEN)),
+  _ts_metadata10("design:type", Function),
+  _ts_metadata10("design:paramtypes", [
+    typeof PrismaLike === "undefined" ? Object : PrismaLike
+  ])
+], PrismaPromoCodeValidationLogRepository);
+
+// src/prisma-promo-subscription-lookup.ts
+import { Inject as Inject11, Injectable as Injectable12 } from "@nestjs/common";
+function _ts_decorate12(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_decorate12, "_ts_decorate");
+function _ts_metadata11(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata11, "_ts_metadata");
+function _ts_param11(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param11, "_ts_param");
+var PrismaPromoSubscriptionLookup = class {
+  static {
+    __name(this, "PrismaPromoSubscriptionLookup");
+  }
+  prisma;
+  constructor(prisma) {
+    this.prisma = prisma;
+  }
+  async findById(subscriptionId, tx) {
+    const db = resolveClient(this.prisma, tx);
+    const row = await db.subscription.findUnique({
+      where: {
+        id: subscriptionId
+      }
+    });
+    if (!row) return null;
+    return {
+      id: row.id,
+      tenantId: row.tenantId,
+      plan: row.plan,
+      billingCycle: row.billingCycle,
+      startedAt: row.startedAt
+    };
+  }
+};
+PrismaPromoSubscriptionLookup = _ts_decorate12([
+  Injectable12(),
+  _ts_param11(0, Inject11(PRISMA_CLIENT_TOKEN)),
+  _ts_metadata11("design:type", Function),
+  _ts_metadata11("design:paramtypes", [
+    typeof PrismaLike === "undefined" ? Object : PrismaLike
+  ])
+], PrismaPromoSubscriptionLookup);
+
+// src/prisma-subscription.repository.ts
+import { Inject as Inject12, Injectable as Injectable13 } from "@nestjs/common";
+function _ts_decorate13(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_decorate13, "_ts_decorate");
+function _ts_metadata12(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata12, "_ts_metadata");
+function _ts_param12(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param12, "_ts_param");
+var ACTIVE_STATUSES = [
+  "ACTIVE",
+  "TRIAL"
+];
+var PrismaSubscriptionRepository = class {
+  static {
+    __name(this, "PrismaSubscriptionRepository");
+  }
+  prisma;
+  constructor(prisma) {
+    this.prisma = prisma;
+  }
+  async findByTenantId(tenantId) {
+    return this.loadByTenantId(this.prisma, tenantId);
+  }
+  async findByTenantIdLocked(tenantId, tx) {
+    const db = resolveClient(this.prisma, tx);
+    await db.$queryRaw`SELECT id FROM subscriptions WHERE "tenantId" = ${tenantId} FOR UPDATE`;
+    return this.loadByTenantId(db, tenantId);
+  }
+  async countByPlanVersionId(planVersionId) {
+    return this.prisma.subscription.count({
+      where: {
+        OR: [
+          {
+            planVersionId
+          },
+          {
+            pendingPlanVersionId: planVersionId
+          }
+        ]
+      }
+    });
+  }
+  async countActiveByPlanKey(_projectKey) {
+    const rows = await this.prisma.subscription.findMany({
+      where: {
+        status: {
+          in: ACTIVE_STATUSES
+        }
+      }
+    });
+    const counts = {};
+    for (const row of rows) {
+      counts[row.plan] = (counts[row.plan] ?? 0) + 1;
+    }
+    return counts;
+  }
+  async loadByTenantId(db, tenantId) {
+    const row = await db.subscription.findUnique({
+      where: {
+        tenantId
+      }
+    });
+    if (!row) return null;
+    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
+      }
+    });
+    if (!planVersion) {
+      throw new Error(`Subscription ${row.id} references missing PlanVersion ${row.planVersionId}.`);
+    }
+    return {
+      id: row.id,
+      tenantId: row.tenantId,
+      plan: row.plan,
+      status: row.status,
+      isPilot: row.isPilot,
+      trialEntitlementPlan: row.trialEntitlementPlan,
+      pendingPlan: row.pendingPlan,
+      pendingEffectiveAt: row.pendingEffectiveAt,
+      customLimits: row.customLimits ?? null,
+      planVersionId: row.planVersionId,
+      planVersion: {
+        planId: planVersion.planId,
+        quotas: toQuotaMap(planVersion.quotas),
+        features: toStringArray(planVersion.features)
+      }
+    };
+  }
+};
+PrismaSubscriptionRepository = _ts_decorate13([
+  Injectable13(),
+  _ts_param12(0, Inject12(PRISMA_CLIENT_TOKEN)),
+  _ts_metadata12("design:type", Function),
+  _ts_metadata12("design:paramtypes", [
+    typeof PrismaLike === "undefined" ? Object : PrismaLike
+  ])
+], PrismaSubscriptionRepository);
+
+// src/prisma-super-admin-bootstrap.adapter.ts
+import { Inject as Inject13, Injectable as Injectable14 } from "@nestjs/common";
+import { PlatformUserExistsError } from "@saasicat/types";
+function _ts_decorate14(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_decorate14, "_ts_decorate");
+function _ts_metadata13(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata13, "_ts_metadata");
+function _ts_param13(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param13, "_ts_param");
+var PASSWORD_HASHER_TOKEN = /* @__PURE__ */ Symbol.for("saasicat/adapter-prisma/PasswordHasher");
+var PrismaSuperAdminBootstrapAdapter = class {
+  static {
+    __name(this, "PrismaSuperAdminBootstrapAdapter");
+  }
+  prisma;
+  passwordHasher;
+  constructor(prisma, passwordHasher) {
+    this.prisma = prisma;
+    this.passwordHasher = passwordHasher;
+  }
+  async countSuperAdmins() {
+    return this.prisma.superAdminUser.count({
+      where: {
+        isActive: true,
+        deletedAt: null
+      }
+    });
+  }
+  async createSuperAdmin(input) {
+    const email = input.email.trim().toLowerCase();
+    const existing = await this.prisma.superAdminUser.findUnique({
+      where: {
+        email
+      }
+    });
+    if (existing) {
+      throw new PlatformUserExistsError(email, existing.platformRole);
+    }
+    const row = await this.prisma.superAdminUser.create({
+      data: {
+        email,
+        passwordHash: await this.passwordHasher.hash(input.password),
+        firstName: input.firstName ?? null,
+        lastName: input.lastName ?? null
+      }
+    });
+    return {
+      id: row.id,
+      email: row.email,
+      firstName: row.firstName ?? void 0,
+      lastName: row.lastName ?? void 0,
+      platformRole: row.platformRole,
+      isActive: row.isActive,
+      lastLoginAt: null,
+      deletedAt: null
+    };
+  }
+};
+PrismaSuperAdminBootstrapAdapter = _ts_decorate14([
+  Injectable14(),
+  _ts_param13(0, Inject13(PRISMA_CLIENT_TOKEN)),
+  _ts_param13(1, Inject13(PASSWORD_HASHER_TOKEN)),
+  _ts_metadata13("design:type", Function),
+  _ts_metadata13("design:paramtypes", [
+    typeof PrismaLike === "undefined" ? Object : PrismaLike,
+    typeof PasswordHasher === "undefined" ? Object : PasswordHasher
+  ])
+], PrismaSuperAdminBootstrapAdapter);
+
+// src/prisma-transaction-runner.ts
+import { Inject as Inject14, Injectable as Injectable15 } from "@nestjs/common";
+function _ts_decorate15(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_decorate15, "_ts_decorate");
+function _ts_metadata14(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata14, "_ts_metadata");
+function _ts_param14(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param14, "_ts_param");
+var PrismaTransactionRunner = class {
+  static {
+    __name(this, "PrismaTransactionRunner");
+  }
+  prisma;
+  constructor(prisma) {
+    this.prisma = prisma;
+  }
+  async run(fn) {
+    return this.prisma.$transaction((tx) => fn(tx));
+  }
+};
+PrismaTransactionRunner = _ts_decorate15([
+  Injectable15(),
+  _ts_param14(0, Inject14(PRISMA_CLIENT_TOKEN)),
+  _ts_metadata14("design:type", Function),
+  _ts_metadata14("design:paramtypes", [
+    typeof PrismaLike === "undefined" ? Object : PrismaLike
+  ])
+], PrismaTransactionRunner);
+
+// src/zero-promo-revenue-aggregator.ts
+import { Injectable as Injectable16 } from "@nestjs/common";
+function _ts_decorate16(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_decorate16, "_ts_decorate");
+var ZeroPromoRevenueDeductionAggregator = class {
+  static {
+    __name(this, "ZeroPromoRevenueDeductionAggregator");
+  }
+  async sumGrossForPromoCode(_promoCodeId) {
+    return "0.00";
+  }
+};
+ZeroPromoRevenueDeductionAggregator = _ts_decorate16([
+  Injectable16()
+], ZeroPromoRevenueDeductionAggregator);
+
+// src/prisma-persistence.ts
+function prismaPersistence(options) {
+  const { client } = options;
+  const provide = /* @__PURE__ */ __name((build) => isInjectionToken(client) ? {
+    useFactory: /* @__PURE__ */ __name((prisma) => build(prisma), "useFactory"),
+    inject: [
+      client
+    ]
+  } : build(client), "provide");
+  return {
+    capabilities: {
+      transactions: true,
+      pessimisticLocking: true,
+      rowLevelSecurity: options.rlsIntegration ?? false,
+      advisoryLocks: false
+    },
+    core: {
+      mfa: provide((prisma) => new PrismaMfaAdapter(prisma)),
+      audit: provide((prisma) => new PrismaAuditAdapter(prisma)),
+      rlsBypass: new AsyncLocalRlsBypassAdapter(),
+      transactionRunner: provide((prisma) => new PrismaTransactionRunner(prisma)),
+      auditQuery: provide((prisma) => new PrismaAuditQueryAdapter(prisma)),
+      auditStats: provide((prisma) => new PrismaAuditStatsAdapter(prisma)),
+      superAdminProvisioning: buildProvisioning(client, options.passwordHasher)
+    },
+    entitlement: {
+      subscriptionRepository: provide((prisma) => new PrismaSubscriptionRepository(prisma)),
+      planVersionRepository: provide((prisma) => new PrismaPlanVersionRepository(prisma))
+    },
+    promo: {
+      promoCodeRepository: provide((prisma) => new PrismaPromoCodeRepository(prisma)),
+      redemptionRepository: provide((prisma) => new PrismaPromoCodeRedemptionRepository(prisma)),
+      validationLogRepository: provide((prisma) => new PrismaPromoCodeValidationLogRepository(prisma)),
+      subscriptionLookup: provide((prisma) => new PrismaPromoSubscriptionLookup(prisma)),
+      revenueAggregator: new ZeroPromoRevenueDeductionAggregator()
+    },
+    planCatalogReadSink: provide((prisma) => new PrismaPlanCatalogReadSink(prisma)),
+    planCatalogImportSink: provide((prisma) => new PrismaPlanCatalogImportSink(prisma))
+  };
+}
+__name(prismaPersistence, "prismaPersistence");
+function isInjectionToken(value) {
+  return typeof value === "function" || typeof value === "symbol" || typeof value === "string";
+}
+__name(isInjectionToken, "isInjectionToken");
+function buildProvisioning(client, hasher) {
+  if (hasher === void 0) return void 0;
+  const clientIsToken = isInjectionToken(client);
+  const hasherIsToken = isInjectionToken(hasher);
+  if (clientIsToken && hasherIsToken) {
+    return {
+      useFactory: /* @__PURE__ */ __name((prisma, h) => new PrismaSuperAdminBootstrapAdapter(prisma, h), "useFactory"),
+      inject: [
+        client,
+        hasher
+      ]
+    };
+  }
+  if (clientIsToken) {
+    return {
+      useFactory: /* @__PURE__ */ __name((prisma) => new PrismaSuperAdminBootstrapAdapter(prisma, hasher), "useFactory"),
+      inject: [
+        client
+      ]
+    };
+  }
+  if (hasherIsToken) {
+    return {
+      useFactory: /* @__PURE__ */ __name((h) => new PrismaSuperAdminBootstrapAdapter(client, h), "useFactory"),
+      inject: [
+        hasher
+      ]
+    };
+  }
+  return new PrismaSuperAdminBootstrapAdapter(client, hasher);
+}
+__name(buildProvisioning, "buildProvisioning");
+export {
+  AsyncLocalRlsBypassAdapter,
+  PASSWORD_HASHER_TOKEN,
+  PRISMA_CLIENT_TOKEN,
+  PrismaAuditAdapter,
+  PrismaAuditQueryAdapter,
+  PrismaAuditStatsAdapter,
+  PrismaMfaAdapter,
+  PrismaPlanCatalogImportSink,
+  PrismaPlanCatalogReadSink,
+  PrismaPlanVersionRepository,
+  PrismaPromoCodeRedemptionRepository,
+  PrismaPromoCodeRepository,
+  PrismaPromoCodeValidationLogRepository,
+  PrismaPromoSubscriptionLookup,
+  PrismaSubscriptionRepository,
+  PrismaSuperAdminBootstrapAdapter,
+  PrismaTransactionRunner,
+  ZeroPromoRevenueDeductionAggregator,
+  buildActorTag,
+  prismaPersistence
+};