@saasicat/adapter-drizzle 0.4.0

package/dist/index.js

@@ -0,0 +1,1508 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/client.ts
+var DRIZZLE_DB_TOKEN = /* @__PURE__ */ Symbol.for("saasicat/adapter-drizzle/DrizzleDb");
+function resolveDb(client, tx) {
+  return tx ?? client;
+}
+__name(resolveDb, "resolveDb");
+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");
+function escapeLikePattern(value) {
+  return value.replace(/[\\%_]/g, "\\$&");
+}
+__name(escapeLikePattern, "escapeLikePattern");
+
+// src/async-local-rls-bypass.adapter.ts
+import { Injectable } from "@nestjs/common";
+import { AsyncLocalStorage } from "node:async_hooks";
+function _ts_decorate(decorators, target, key, desc4) {
+  var c = arguments.length, r = c < 3 ? target : desc4 === null ? desc4 = Object.getOwnPropertyDescriptor(target, key) : desc4, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc4);
+  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. */
+  isBypassActive() {
+    return this.storage.getStore()?.bypass === true;
+  }
+};
+AsyncLocalRlsBypassAdapter = _ts_decorate([
+  Injectable()
+], AsyncLocalRlsBypassAdapter);
+
+// src/drizzle-audit.adapter.ts
+import { randomUUID } from "node:crypto";
+import { Inject, Injectable as Injectable2 } from "@nestjs/common";
+
+// src/schema.ts
+var schema_exports = {};
+__export(schema_exports, {
+  auditLogs: () => auditLogs,
+  featureCatalogEntries: () => featureCatalogEntries,
+  planVersions: () => planVersions,
+  plans: () => plans,
+  promoCodeRedemptions: () => promoCodeRedemptions,
+  promoCodeValidationLogs: () => promoCodeValidationLogs,
+  promoCodes: () => promoCodes,
+  subscriptions: () => subscriptions,
+  superAdminMfa: () => superAdminMfa,
+  superAdminUsers: () => superAdminUsers
+});
+import { boolean, integer, jsonb, numeric, pgTable, text, timestamp } from "drizzle-orm/pg-core";
+var ts = /* @__PURE__ */ __name((name) => timestamp(name, {
+  precision: 3,
+  mode: "date"
+}), "ts");
+var subscriptions = pgTable("subscriptions", {
+  id: text("id").primaryKey(),
+  tenantId: text("tenantId").notNull(),
+  plan: text("plan").notNull(),
+  billingCycle: text("billingCycle").notNull().default("YEARLY"),
+  status: text("status").notNull().default("TRIAL"),
+  trialEntitlementPlan: text("trialEntitlementPlan"),
+  pendingPlan: text("pendingPlan"),
+  pendingEffectiveAt: ts("pendingEffectiveAt"),
+  customLimits: jsonb("customLimits"),
+  planVersionId: text("planVersionId"),
+  pendingPlanVersionId: text("pendingPlanVersionId"),
+  isPilot: boolean("isPilot").notNull().default(false),
+  startedAt: ts("startedAt"),
+  createdAt: ts("createdAt").notNull().defaultNow(),
+  updatedAt: ts("updatedAt").notNull()
+});
+var planVersions = pgTable("plan_versions", {
+  id: text("id").primaryKey(),
+  planId: text("planId").notNull(),
+  version: integer("version").notNull(),
+  baseVersionId: text("baseVersionId"),
+  features: jsonb("features").notNull(),
+  quotas: jsonb("quotas").notNull(),
+  monthlyNet: numeric("monthlyNet", {
+    precision: 10,
+    scale: 2
+  }).notNull(),
+  yearlyNet: numeric("yearlyNet", {
+    precision: 10,
+    scale: 2
+  }).notNull(),
+  marketed: boolean("marketed").notNull().default(true),
+  publishedAt: ts("publishedAt"),
+  supersededAt: ts("supersededAt"),
+  publishedChanges: jsonb("publishedChanges"),
+  changeNote: text("changeNote").notNull(),
+  nonRegressive: boolean("nonRegressive").notNull().default(true),
+  createdByUserId: text("createdByUserId"),
+  publishedByUserId: text("publishedByUserId"),
+  createdAt: ts("createdAt").notNull().defaultNow(),
+  updatedAt: ts("updatedAt").notNull()
+});
+var plans = pgTable("plans", {
+  id: text("id").primaryKey(),
+  projectKey: text("projectKey").notNull(),
+  planKey: text("planKey").notNull(),
+  label: text("label").notNull(),
+  description: text("description"),
+  icon: text("icon"),
+  sortOrder: integer("sortOrder").notNull().default(0),
+  createdAt: ts("createdAt").notNull().defaultNow(),
+  updatedAt: ts("updatedAt").notNull(),
+  deletedAt: ts("deletedAt")
+});
+var featureCatalogEntries = pgTable("feature_catalog_entries", {
+  id: text("id").primaryKey(),
+  projectKey: text("projectKey").notNull(),
+  featureKey: text("featureKey").notNull(),
+  label: text("label").notNull(),
+  description: text("description"),
+  marketingLabel: text("marketingLabel"),
+  marketingDescription: text("marketingDescription"),
+  icon: text("icon"),
+  tier: text("tier"),
+  core: boolean("core").notNull().default(false),
+  requires: text("requires").array(),
+  replaces: text("replaces").array(),
+  successorKey: text("successorKey"),
+  discoveryStatus: text("discoveryStatus").notNull().default("pending"),
+  approvedAt: ts("approvedAt"),
+  approvedBy: text("approvedBy"),
+  approvedSignature: text("approvedSignature"),
+  plannedOnly: boolean("plannedOnly").notNull().default(false),
+  i18n: jsonb("i18n").notNull().default({}),
+  sortOrder: integer("sortOrder").notNull().default(0),
+  createdAt: ts("createdAt").notNull().defaultNow(),
+  updatedAt: ts("updatedAt").notNull(),
+  deletedAt: ts("deletedAt")
+});
+var promoCodes = pgTable("promo_codes", {
+  id: text("id").primaryKey(),
+  code: text("code").notNull(),
+  valueType: text("valueType").notNull(),
+  value: numeric("value", {
+    precision: 8,
+    scale: 2
+  }).notNull(),
+  durationType: text("durationType").notNull().default("ONCE"),
+  durationValue: integer("durationValue"),
+  validFrom: ts("validFrom"),
+  validUntil: ts("validUntil"),
+  maxRedemptions: integer("maxRedemptions"),
+  redemptionsCount: integer("redemptionsCount").notNull().default(0),
+  appliesToPlans: text("appliesToPlans").array(),
+  appliesToBilling: text("appliesToBilling"),
+  firstTimeCustomersOnly: boolean("firstTimeCustomersOnly").notNull().default(true),
+  minimumPlanAmountGross: numeric("minimumPlanAmountGross", {
+    precision: 10,
+    scale: 2
+  }),
+  allowZeroInvoice: boolean("allowZeroInvoice").notNull().default(false),
+  status: text("status").notNull().default("ACTIVE"),
+  description: text("description"),
+  campaignTag: text("campaignTag"),
+  revenueDeductionAccount: text("revenueDeductionAccount"),
+  createdById: text("createdById").notNull(),
+  createdAt: ts("createdAt").notNull().defaultNow(),
+  updatedAt: ts("updatedAt").notNull(),
+  deletedAt: ts("deletedAt")
+});
+var promoCodeRedemptions = pgTable("promo_code_redemptions", {
+  id: text("id").primaryKey(),
+  promoCodeId: text("promoCodeId").notNull(),
+  subscriptionId: text("subscriptionId").notNull(),
+  tenantId: text("tenantId").notNull(),
+  appliedValueType: text("appliedValueType").notNull(),
+  appliedValue: numeric("appliedValue", {
+    precision: 8,
+    scale: 2
+  }).notNull(),
+  appliedDurationType: text("appliedDurationType").notNull(),
+  appliedDurationValue: integer("appliedDurationValue"),
+  startsAt: ts("startsAt").notNull(),
+  endsAt: ts("endsAt"),
+  status: text("status").notNull().default("ACTIVE"),
+  redeemedAt: ts("redeemedAt").notNull().defaultNow(),
+  reversedAt: ts("reversedAt")
+});
+var promoCodeValidationLogs = pgTable("promo_code_validation_logs", {
+  id: text("id").primaryKey(),
+  promoCodeId: text("promoCodeId"),
+  codeAttempt: text("codeAttempt").notNull(),
+  ipHash: text("ipHash"),
+  sessionId: text("sessionId"),
+  result: text("result").notNull(),
+  createdAt: ts("createdAt").notNull().defaultNow()
+});
+var auditLogs = pgTable("audit_logs", {
+  id: text("id").primaryKey(),
+  tenantId: text("tenantId"),
+  userId: text("userId"),
+  entity: text("entity").notNull(),
+  entityId: text("entityId").notNull(),
+  action: text("action").notNull(),
+  changes: jsonb("changes"),
+  actorTag: text("actorTag"),
+  ipAddress: text("ipAddress"),
+  userAgent: text("userAgent"),
+  createdAt: ts("createdAt").notNull().defaultNow()
+});
+var superAdminUsers = pgTable("super_admin_users", {
+  id: text("id").primaryKey(),
+  email: text("email").notNull(),
+  passwordHash: text("passwordHash").notNull(),
+  firstName: text("firstName"),
+  lastName: text("lastName"),
+  platformRole: text("platformRole").notNull().default("SUPER_ADMIN"),
+  isActive: boolean("isActive").notNull().default(true),
+  lastLoginAt: ts("lastLoginAt"),
+  deletedAt: ts("deletedAt"),
+  createdAt: ts("createdAt").notNull().defaultNow(),
+  updatedAt: ts("updatedAt").notNull()
+});
+var superAdminMfa = pgTable("super_admin_mfa", {
+  userId: text("userId").primaryKey(),
+  secret: text("secret"),
+  enabledAt: ts("enabledAt"),
+  updatedAt: ts("updatedAt").notNull()
+});
+
+// src/drizzle-audit.adapter.ts
+function _ts_decorate2(decorators, target, key, desc4) {
+  var c = arguments.length, r = c < 3 ? target : desc4 === null ? desc4 = Object.getOwnPropertyDescriptor(target, key) : desc4, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc4);
+  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 DrizzleAuditAdapter = class {
+  static {
+    __name(this, "DrizzleAuditAdapter");
+  }
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  async write(input) {
+    await this.db.insert(auditLogs).values({
+      id: randomUUID(),
+      tenantId: null,
+      userId: input.actor.userId,
+      entity: input.entity,
+      entityId: input.entityId,
+      action: input.action,
+      changes: input.changes ?? {},
+      actorTag: buildActorTag(input.actor)
+    });
+  }
+};
+DrizzleAuditAdapter = _ts_decorate2([
+  Injectable2(),
+  _ts_param(0, Inject(DRIZZLE_DB_TOKEN)),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof DrizzleClient === "undefined" ? Object : DrizzleClient
+  ])
+], DrizzleAuditAdapter);
+
+// src/drizzle-audit-query.adapter.ts
+import { Inject as Inject2, Injectable as Injectable3 } from "@nestjs/common";
+import { and, desc, eq, gte, like, lte } from "drizzle-orm";
+function _ts_decorate3(decorators, target, key, desc4) {
+  var c = arguments.length, r = c < 3 ? target : desc4 === null ? desc4 = Object.getOwnPropertyDescriptor(target, key) : desc4, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc4);
+  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 DrizzleAuditQueryAdapter = class {
+  static {
+    __name(this, "DrizzleAuditQueryAdapter");
+  }
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  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 conditions = [
+      filter.tenantId ? eq(auditLogs.tenantId, filter.tenantId) : void 0,
+      filter.userId ? eq(auditLogs.userId, filter.userId) : void 0,
+      filter.entity ? eq(auditLogs.entity, filter.entity) : void 0,
+      filter.entityId ? eq(auditLogs.entityId, filter.entityId) : void 0,
+      filter.action ? eq(auditLogs.action, filter.action) : void 0,
+      toActorTagCondition(filter.actorTag),
+      filter.from ? gte(auditLogs.createdAt, new Date(filter.from)) : void 0,
+      filter.to ? lte(auditLogs.createdAt, new Date(filter.to)) : void 0
+    ];
+    const rows = await this.db.select().from(auditLogs).where(and(...conditions)).orderBy(desc(auditLogs.createdAt)).limit(pageSize).offset((page - 1) * pageSize);
+    return rows.map(toAuditEntry);
+  }
+};
+DrizzleAuditQueryAdapter = _ts_decorate3([
+  Injectable3(),
+  _ts_param2(0, Inject2(DRIZZLE_DB_TOKEN)),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    typeof DrizzleClient === "undefined" ? Object : DrizzleClient
+  ])
+], DrizzleAuditQueryAdapter);
+function toActorTagCondition(actorTag) {
+  if (!actorTag) return void 0;
+  if (actorTag.endsWith("*")) {
+    return like(auditLogs.actorTag, `${escapeLikePattern(actorTag.slice(0, -1))}%`);
+  }
+  return eq(auditLogs.actorTag, actorTag);
+}
+__name(toActorTagCondition, "toActorTagCondition");
+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/drizzle-audit-stats.adapter.ts
+import { Inject as Inject3, Injectable as Injectable4 } from "@nestjs/common";
+import { count, gte as gte2 } from "drizzle-orm";
+function _ts_decorate4(decorators, target, key, desc4) {
+  var c = arguments.length, r = c < 3 ? target : desc4 === null ? desc4 = Object.getOwnPropertyDescriptor(target, key) : desc4, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc4);
+  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 DrizzleAuditStatsAdapter = class {
+  static {
+    __name(this, "DrizzleAuditStatsAdapter");
+  }
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  async countSince(since) {
+    const rows = await this.db.select({
+      value: count()
+    }).from(auditLogs).where(gte2(auditLogs.createdAt, since));
+    return rows[0]?.value ?? 0;
+  }
+};
+DrizzleAuditStatsAdapter = _ts_decorate4([
+  Injectable4(),
+  _ts_param3(0, Inject3(DRIZZLE_DB_TOKEN)),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof DrizzleClient === "undefined" ? Object : DrizzleClient
+  ])
+], DrizzleAuditStatsAdapter);
+
+// src/drizzle-mfa.adapter.ts
+import { Inject as Inject4, Injectable as Injectable5 } from "@nestjs/common";
+import { eq as eq2 } from "drizzle-orm";
+function _ts_decorate5(decorators, target, key, desc4) {
+  var c = arguments.length, r = c < 3 ? target : desc4 === null ? desc4 = Object.getOwnPropertyDescriptor(target, key) : desc4, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc4);
+  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 DrizzleMfaAdapter = class {
+  static {
+    __name(this, "DrizzleMfaAdapter");
+  }
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  async getSecret(userId) {
+    const rows = await this.db.select().from(superAdminMfa).where(eq2(superAdminMfa.userId, userId)).limit(1);
+    return rows[0]?.secret ?? null;
+  }
+  async setSecret(userId, secret) {
+    const enabledAt = secret ? /* @__PURE__ */ new Date() : null;
+    await this.db.insert(superAdminMfa).values({
+      userId,
+      secret,
+      enabledAt,
+      updatedAt: /* @__PURE__ */ new Date()
+    }).onConflictDoUpdate({
+      target: superAdminMfa.userId,
+      set: {
+        secret,
+        enabledAt,
+        updatedAt: /* @__PURE__ */ new Date()
+      }
+    });
+  }
+  async isEnabled(userId) {
+    const rows = await this.db.select().from(superAdminMfa).where(eq2(superAdminMfa.userId, userId)).limit(1);
+    const row = rows[0];
+    return !!row?.secret && !!row?.enabledAt;
+  }
+};
+DrizzleMfaAdapter = _ts_decorate5([
+  Injectable5(),
+  _ts_param4(0, Inject4(DRIZZLE_DB_TOKEN)),
+  _ts_metadata4("design:type", Function),
+  _ts_metadata4("design:paramtypes", [
+    typeof DrizzleClient === "undefined" ? Object : DrizzleClient
+  ])
+], DrizzleMfaAdapter);
+
+// src/drizzle-plan-catalog-import-sink.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { Inject as Inject5, Injectable as Injectable6 } from "@nestjs/common";
+import { and as and2, eq as eq3, isNotNull, isNull, lt } from "drizzle-orm";
+function _ts_decorate6(decorators, target, key, desc4) {
+  var c = arguments.length, r = c < 3 ? target : desc4 === null ? desc4 = Object.getOwnPropertyDescriptor(target, key) : desc4, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc4);
+  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 DrizzlePlanCatalogImportSink = class {
+  static {
+    __name(this, "DrizzlePlanCatalogImportSink");
+  }
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  async upsertPlan(input) {
+    const existing = await this.db.select({
+      id: plans.id
+    }).from(plans).where(and2(eq3(plans.projectKey, input.projectKey), eq3(plans.planKey, input.planKey))).limit(1);
+    if (existing[0]) return {
+      created: false,
+      skipReason: "exists"
+    };
+    await this.db.insert(plans).values({
+      id: randomUUID2(),
+      projectKey: input.projectKey,
+      planKey: input.planKey,
+      label: input.label,
+      description: input.description ?? null,
+      sortOrder: input.sortOrder ?? 0,
+      updatedAt: /* @__PURE__ */ new Date()
+    });
+    return {
+      created: true
+    };
+  }
+  async upsertPlanVersion(input) {
+    const existing = await this.db.select({
+      id: planVersions.id
+    }).from(planVersions).where(and2(eq3(planVersions.planId, input.planKey), eq3(planVersions.version, input.version))).limit(1);
+    if (existing[0]) return {
+      created: false,
+      skipReason: "exists"
+    };
+    const now = /* @__PURE__ */ new Date();
+    if (input.publish) {
+      await this.db.update(planVersions).set({
+        supersededAt: now,
+        updatedAt: now
+      }).where(and2(eq3(planVersions.planId, input.planKey), isNotNull(planVersions.publishedAt), isNull(planVersions.supersededAt), lt(planVersions.version, input.version)));
+    }
+    await this.db.insert(planVersions).values({
+      id: randomUUID2(),
+      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,
+      updatedAt: now
+    });
+    return {
+      created: true
+    };
+  }
+  async upsertFeatureCatalogEntry(input) {
+    const existing = await this.db.select({
+      id: featureCatalogEntries.id
+    }).from(featureCatalogEntries).where(and2(eq3(featureCatalogEntries.projectKey, input.projectKey), eq3(featureCatalogEntries.featureKey, input.featureKey))).limit(1);
+    if (existing[0]) return {
+      created: false,
+      skipReason: "exists"
+    };
+    await this.db.insert(featureCatalogEntries).values({
+      id: randomUUID2(),
+      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,
+      updatedAt: /* @__PURE__ */ new Date()
+    });
+    return {
+      created: true
+    };
+  }
+};
+DrizzlePlanCatalogImportSink = _ts_decorate6([
+  Injectable6(),
+  _ts_param5(0, Inject5(DRIZZLE_DB_TOKEN)),
+  _ts_metadata5("design:type", Function),
+  _ts_metadata5("design:paramtypes", [
+    typeof DrizzleClient === "undefined" ? Object : DrizzleClient
+  ])
+], DrizzlePlanCatalogImportSink);
+
+// src/drizzle-plan-catalog-read-sink.ts
+import { Inject as Inject6, Injectable as Injectable7 } from "@nestjs/common";
+import { and as and3, asc, eq as eq4, inArray, isNotNull as isNotNull2, isNull as isNull2 } from "drizzle-orm";
+function _ts_decorate7(decorators, target, key, desc4) {
+  var c = arguments.length, r = c < 3 ? target : desc4 === null ? desc4 = Object.getOwnPropertyDescriptor(target, key) : desc4, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc4);
+  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 DrizzlePlanCatalogReadSink = class {
+  static {
+    __name(this, "DrizzlePlanCatalogReadSink");
+  }
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  async loadSnapshot(projectKey) {
+    const planRows = await this.db.select().from(plans).where(and3(eq4(plans.projectKey, projectKey), isNull2(plans.deletedAt))).orderBy(asc(plans.sortOrder));
+    const planKeys = planRows.map((plan) => plan.planKey);
+    const liveVersionRows = planKeys.length === 0 ? [] : await this.db.select().from(planVersions).where(and3(inArray(planVersions.planId, planKeys), isNotNull2(planVersions.publishedAt), isNull2(planVersions.supersededAt)));
+    const featureRows = await this.db.select().from(featureCatalogEntries).where(and3(eq4(featureCatalogEntries.projectKey, projectKey), isNull2(featureCatalogEntries.deletedAt))).orderBy(asc(featureCatalogEntries.sortOrder));
+    return {
+      plans: planRows.map(toPlanRow),
+      livePlanVersions: liveVersionRows.map(toPlanVersionRow),
+      featureEntries: featureRows.map(toFeatureCatalogEntryRow)
+    };
+  }
+};
+DrizzlePlanCatalogReadSink = _ts_decorate7([
+  Injectable7(),
+  _ts_param6(0, Inject6(DRIZZLE_DB_TOKEN)),
+  _ts_metadata6("design:type", Function),
+  _ts_metadata6("design:paramtypes", [
+    typeof DrizzleClient === "undefined" ? Object : DrizzleClient
+  ])
+], DrizzlePlanCatalogReadSink);
+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/drizzle-plan-version.repository.ts
+import { Inject as Inject7, Injectable as Injectable8 } from "@nestjs/common";
+import { and as and4, desc as desc2, eq as eq5, isNotNull as isNotNull3, isNull as isNull3 } from "drizzle-orm";
+function _ts_decorate8(decorators, target, key, desc4) {
+  var c = arguments.length, r = c < 3 ? target : desc4 === null ? desc4 = Object.getOwnPropertyDescriptor(target, key) : desc4, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc4);
+  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 DrizzlePlanVersionRepository = class {
+  static {
+    __name(this, "DrizzlePlanVersionRepository");
+  }
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  async findLatestLive(planId, tx) {
+    const db = resolveDb(this.db, tx);
+    const rows = await db.select().from(planVersions).where(and4(eq5(planVersions.planId, planId), isNotNull3(planVersions.publishedAt), isNull3(planVersions.supersededAt))).orderBy(desc2(planVersions.version)).limit(1);
+    const row = rows[0];
+    if (!row) return null;
+    return {
+      planId: row.planId,
+      quotas: toQuotaMap(row.quotas),
+      features: toStringArray(row.features)
+    };
+  }
+};
+DrizzlePlanVersionRepository = _ts_decorate8([
+  Injectable8(),
+  _ts_param7(0, Inject7(DRIZZLE_DB_TOKEN)),
+  _ts_metadata7("design:type", Function),
+  _ts_metadata7("design:paramtypes", [
+    typeof DrizzleClient === "undefined" ? Object : DrizzleClient
+  ])
+], DrizzlePlanVersionRepository);
+
+// src/drizzle-promo-code-redemption.repository.ts
+import { randomUUID as randomUUID3 } from "node:crypto";
+import { Inject as Inject8, Injectable as Injectable9 } from "@nestjs/common";
+import { and as and5, desc as desc3, eq as eq6, lt as lt2 } from "drizzle-orm";
+function _ts_decorate9(decorators, target, key, desc4) {
+  var c = arguments.length, r = c < 3 ? target : desc4 === null ? desc4 = Object.getOwnPropertyDescriptor(target, key) : desc4, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc4);
+  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 DrizzlePromoCodeRedemptionRepository = class {
+  static {
+    __name(this, "DrizzlePromoCodeRedemptionRepository");
+  }
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  async findBySubscription(subscriptionId, tx) {
+    const db = resolveDb(this.db, tx);
+    const rows = await db.select().from(promoCodeRedemptions).where(eq6(promoCodeRedemptions.subscriptionId, subscriptionId)).limit(1);
+    const row = rows[0];
+    return row ? toRecord(row) : null;
+  }
+  async create(data, tx) {
+    const db = resolveDb(this.db, tx);
+    const rows = await db.insert(promoCodeRedemptions).values({
+      id: randomUUID3(),
+      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
+    }).returning();
+    return toRecord(rows[0]);
+  }
+  async setReversed(id, tx) {
+    const db = resolveDb(this.db, tx);
+    const rows = await db.update(promoCodeRedemptions).set({
+      status: "REVERSED",
+      reversedAt: /* @__PURE__ */ new Date()
+    }).where(eq6(promoCodeRedemptions.id, id)).returning();
+    const row = rows[0];
+    if (!row) {
+      throw new Error(`PromoCodeRedemption ${id} not found.`);
+    }
+    return toRecord(row);
+  }
+  async countByPromoCode(promoCodeId, status) {
+    const rows = await this.db.select({
+      id: promoCodeRedemptions.id
+    }).from(promoCodeRedemptions).where(and5(eq6(promoCodeRedemptions.promoCodeId, promoCodeId), status ? eq6(promoCodeRedemptions.status, status) : void 0));
+    return rows.length;
+  }
+  async listByPromoCode(promoCodeId) {
+    const rows = await this.db.select().from(promoCodeRedemptions).where(eq6(promoCodeRedemptions.promoCodeId, promoCodeId)).orderBy(desc3(promoCodeRedemptions.redeemedAt));
+    return rows.map(toRecord);
+  }
+  async expireDueRedemptions(now) {
+    const expired = await this.db.update(promoCodeRedemptions).set({
+      status: "EXPIRED"
+    }).where(and5(eq6(promoCodeRedemptions.status, "ACTIVE"), lt2(promoCodeRedemptions.endsAt, now))).returning({
+      id: promoCodeRedemptions.id
+    });
+    return expired.length;
+  }
+};
+DrizzlePromoCodeRedemptionRepository = _ts_decorate9([
+  Injectable9(),
+  _ts_param8(0, Inject8(DRIZZLE_DB_TOKEN)),
+  _ts_metadata8("design:type", Function),
+  _ts_metadata8("design:paramtypes", [
+    typeof DrizzleClient === "undefined" ? Object : DrizzleClient
+  ])
+], DrizzlePromoCodeRedemptionRepository);
+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/drizzle-promo-code.repository.ts
+import { randomUUID as randomUUID4 } from "node:crypto";
+import { Inject as Inject9, Injectable as Injectable10 } from "@nestjs/common";
+import { and as and6, eq as eq7, gte as gte3, inArray as inArray2, isNotNull as isNotNull4, isNull as isNull4, like as like2, lt as lt3, or, sql } from "drizzle-orm";
+function _ts_decorate10(decorators, target, key, desc4) {
+  var c = arguments.length, r = c < 3 ? target : desc4 === null ? desc4 = Object.getOwnPropertyDescriptor(target, key) : desc4, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc4);
+  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 DrizzlePromoCodeRepository = class {
+  static {
+    __name(this, "DrizzlePromoCodeRepository");
+  }
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  async findById(id) {
+    const rows = await this.db.select().from(promoCodes).where(eq7(promoCodes.id, id)).limit(1);
+    const row = rows[0];
+    return row ? toRecord2(row) : null;
+  }
+  async findByCode(code, tx) {
+    const db = resolveDb(this.db, tx);
+    const rows = await db.select().from(promoCodes).where(eq7(promoCodes.code, normalizeCode(code))).limit(1);
+    const row = rows[0];
+    if (!row || row.deletedAt) return null;
+    return toRecord2(row);
+  }
+  async findMany(filter) {
+    const conditions = [
+      isNull4(promoCodes.deletedAt),
+      filter.status ? eq7(promoCodes.status, filter.status) : void 0,
+      filter.campaignTag ? eq7(promoCodes.campaignTag, filter.campaignTag) : void 0,
+      filter.search ? like2(promoCodes.code, `%${escapeLikePattern(normalizeCode(filter.search))}%`) : void 0
+    ];
+    const rows = await this.db.select().from(promoCodes).where(and6(...conditions)).orderBy(sql`${promoCodes.createdAt} DESC`);
+    return rows.map(toRecord2);
+  }
+  async create(data) {
+    const rows = await this.db.insert(promoCodes).values({
+      id: randomUUID4(),
+      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,
+      updatedAt: /* @__PURE__ */ new Date()
+    }).returning();
+    return toRecord2(rows[0]);
+  }
+  async update(id, data) {
+    const rows = await this.db.update(promoCodes).set({
+      status: data.status,
+      description: data.description,
+      validUntil: data.validUntil,
+      maxRedemptions: data.maxRedemptions,
+      updatedAt: /* @__PURE__ */ new Date()
+    }).where(eq7(promoCodes.id, id)).returning();
+    const row = rows[0];
+    if (!row) {
+      throw new Error(`PromoCode ${id} not found.`);
+    }
+    return toRecord2(row);
+  }
+  async softDelete(id) {
+    await this.db.update(promoCodes).set({
+      deletedAt: /* @__PURE__ */ new Date(),
+      updatedAt: /* @__PURE__ */ new Date()
+    }).where(eq7(promoCodes.id, id));
+  }
+  async claimSlot(id, tx) {
+    const db = resolveDb(this.db, tx);
+    const claimed = await db.update(promoCodes).set({
+      redemptionsCount: sql`${promoCodes.redemptionsCount} + 1`,
+      updatedAt: /* @__PURE__ */ new Date()
+    }).where(and6(eq7(promoCodes.id, id), eq7(promoCodes.status, "ACTIVE"), isNull4(promoCodes.deletedAt), or(isNull4(promoCodes.maxRedemptions), lt3(promoCodes.redemptionsCount, promoCodes.maxRedemptions)))).returning({
+      id: promoCodes.id
+    });
+    return claimed.length === 1;
+  }
+  async markExhaustedIfFull(id, tx) {
+    const db = resolveDb(this.db, tx);
+    await db.update(promoCodes).set({
+      status: "EXHAUSTED",
+      updatedAt: /* @__PURE__ */ new Date()
+    }).where(and6(eq7(promoCodes.id, id), eq7(promoCodes.status, "ACTIVE"), isNotNull4(promoCodes.maxRedemptions), gte3(promoCodes.redemptionsCount, promoCodes.maxRedemptions)));
+  }
+  async releaseSlot(id, tx) {
+    const db = resolveDb(this.db, tx);
+    await db.update(promoCodes).set({
+      redemptionsCount: sql`GREATEST(${promoCodes.redemptionsCount} - 1, 0)`,
+      status: sql`CASE WHEN ${promoCodes.status} = 'EXHAUSTED' THEN 'ACTIVE' ELSE ${promoCodes.status} END`,
+      updatedAt: /* @__PURE__ */ new Date()
+    }).where(eq7(promoCodes.id, id));
+  }
+  async expireDueCodes(now) {
+    const expired = await this.db.update(promoCodes).set({
+      status: "EXPIRED",
+      updatedAt: /* @__PURE__ */ new Date()
+    }).where(and6(inArray2(promoCodes.status, [
+      "ACTIVE",
+      "PAUSED"
+    ]), lt3(promoCodes.validUntil, now))).returning({
+      id: promoCodes.id
+    });
+    return expired.length;
+  }
+};
+DrizzlePromoCodeRepository = _ts_decorate10([
+  Injectable10(),
+  _ts_param9(0, Inject9(DRIZZLE_DB_TOKEN)),
+  _ts_metadata9("design:type", Function),
+  _ts_metadata9("design:paramtypes", [
+    typeof DrizzleClient === "undefined" ? Object : DrizzleClient
+  ])
+], DrizzlePromoCodeRepository);
+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/drizzle-promo-code-validation-log.repository.ts
+import { randomUUID as randomUUID5 } from "node:crypto";
+import { Inject as Inject10, Injectable as Injectable11 } from "@nestjs/common";
+import { and as and7, eq as eq8 } from "drizzle-orm";
+function _ts_decorate11(decorators, target, key, desc4) {
+  var c = arguments.length, r = c < 3 ? target : desc4 === null ? desc4 = Object.getOwnPropertyDescriptor(target, key) : desc4, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc4);
+  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 DrizzlePromoCodeValidationLogRepository = class {
+  static {
+    __name(this, "DrizzlePromoCodeValidationLogRepository");
+  }
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  async log(args) {
+    await this.db.insert(promoCodeValidationLogs).values({
+      id: randomUUID5(),
+      promoCodeId: args.promoCodeId,
+      codeAttempt: args.codeAttempt.trim().toUpperCase(),
+      result: args.result,
+      ipHash: args.ipHash ?? null,
+      sessionId: args.sessionId ?? null
+    });
+  }
+  async countValid(promoCodeId) {
+    const rows = await this.db.select({
+      id: promoCodeValidationLogs.id
+    }).from(promoCodeValidationLogs).where(and7(eq8(promoCodeValidationLogs.promoCodeId, promoCodeId), eq8(promoCodeValidationLogs.result, "VALID")));
+    return rows.length;
+  }
+};
+DrizzlePromoCodeValidationLogRepository = _ts_decorate11([
+  Injectable11(),
+  _ts_param10(0, Inject10(DRIZZLE_DB_TOKEN)),
+  _ts_metadata10("design:type", Function),
+  _ts_metadata10("design:paramtypes", [
+    typeof DrizzleClient === "undefined" ? Object : DrizzleClient
+  ])
+], DrizzlePromoCodeValidationLogRepository);
+
+// src/drizzle-promo-subscription-lookup.ts
+import { Inject as Inject11, Injectable as Injectable12 } from "@nestjs/common";
+import { eq as eq9 } from "drizzle-orm";
+function _ts_decorate12(decorators, target, key, desc4) {
+  var c = arguments.length, r = c < 3 ? target : desc4 === null ? desc4 = Object.getOwnPropertyDescriptor(target, key) : desc4, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc4);
+  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 DrizzlePromoSubscriptionLookup = class {
+  static {
+    __name(this, "DrizzlePromoSubscriptionLookup");
+  }
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  async findById(subscriptionId, tx) {
+    const db = resolveDb(this.db, tx);
+    const rows = await db.select({
+      id: subscriptions.id,
+      tenantId: subscriptions.tenantId,
+      plan: subscriptions.plan,
+      billingCycle: subscriptions.billingCycle,
+      startedAt: subscriptions.startedAt
+    }).from(subscriptions).where(eq9(subscriptions.id, subscriptionId)).limit(1);
+    const row = rows[0];
+    if (!row) return null;
+    return {
+      id: row.id,
+      tenantId: row.tenantId,
+      plan: row.plan,
+      billingCycle: row.billingCycle,
+      startedAt: row.startedAt
+    };
+  }
+};
+DrizzlePromoSubscriptionLookup = _ts_decorate12([
+  Injectable12(),
+  _ts_param11(0, Inject11(DRIZZLE_DB_TOKEN)),
+  _ts_metadata11("design:type", Function),
+  _ts_metadata11("design:paramtypes", [
+    typeof DrizzleClient === "undefined" ? Object : DrizzleClient
+  ])
+], DrizzlePromoSubscriptionLookup);
+
+// src/drizzle-subscription.repository.ts
+import { Inject as Inject12, Injectable as Injectable13 } from "@nestjs/common";
+import { eq as eq10, inArray as inArray3, or as or2 } from "drizzle-orm";
+function _ts_decorate13(decorators, target, key, desc4) {
+  var c = arguments.length, r = c < 3 ? target : desc4 === null ? desc4 = Object.getOwnPropertyDescriptor(target, key) : desc4, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc4);
+  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 DrizzleSubscriptionRepository = class {
+  static {
+    __name(this, "DrizzleSubscriptionRepository");
+  }
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  async findByTenantId(tenantId) {
+    return this.loadByTenantId(this.db, tenantId);
+  }
+  async findByTenantIdLocked(tenantId, tx) {
+    const db = resolveDb(this.db, tx);
+    await db.select({
+      id: subscriptions.id
+    }).from(subscriptions).where(eq10(subscriptions.tenantId, tenantId)).for("update");
+    return this.loadByTenantId(db, tenantId);
+  }
+  async countByPlanVersionId(planVersionId) {
+    const rows = await this.db.select({
+      id: subscriptions.id
+    }).from(subscriptions).where(or2(eq10(subscriptions.planVersionId, planVersionId), eq10(subscriptions.pendingPlanVersionId, planVersionId)));
+    return rows.length;
+  }
+  async countActiveByPlanKey(_projectKey) {
+    const rows = await this.db.select({
+      plan: subscriptions.plan
+    }).from(subscriptions).where(inArray3(subscriptions.status, ACTIVE_STATUSES));
+    const counts = {};
+    for (const row of rows) {
+      counts[row.plan] = (counts[row.plan] ?? 0) + 1;
+    }
+    return counts;
+  }
+  async loadByTenantId(db, tenantId) {
+    const rows = await db.select().from(subscriptions).where(eq10(subscriptions.tenantId, tenantId)).limit(1);
+    const row = rows[0];
+    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-drizzle SubscriptionRepository does not support BusinessType aggregation \u2014 provide a custom SubscriptionRepository adapter.`);
+    }
+    const versionRows = await db.select().from(planVersions).where(eq10(planVersions.id, row.planVersionId)).limit(1);
+    const planVersion = versionRows[0];
+    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)
+      }
+    };
+  }
+};
+DrizzleSubscriptionRepository = _ts_decorate13([
+  Injectable13(),
+  _ts_param12(0, Inject12(DRIZZLE_DB_TOKEN)),
+  _ts_metadata12("design:type", Function),
+  _ts_metadata12("design:paramtypes", [
+    typeof DrizzleClient === "undefined" ? Object : DrizzleClient
+  ])
+], DrizzleSubscriptionRepository);
+
+// src/drizzle-super-admin-bootstrap.adapter.ts
+import { randomUUID as randomUUID6 } from "node:crypto";
+import { Inject as Inject13, Injectable as Injectable14 } from "@nestjs/common";
+import { and as and8, count as count2, eq as eq11, isNull as isNull5 } from "drizzle-orm";
+import { PlatformUserExistsError } from "@saasicat/types";
+function _ts_decorate14(decorators, target, key, desc4) {
+  var c = arguments.length, r = c < 3 ? target : desc4 === null ? desc4 = Object.getOwnPropertyDescriptor(target, key) : desc4, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc4);
+  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-drizzle/PasswordHasher");
+var DrizzleSuperAdminBootstrapAdapter = class {
+  static {
+    __name(this, "DrizzleSuperAdminBootstrapAdapter");
+  }
+  db;
+  passwordHasher;
+  constructor(db, passwordHasher) {
+    this.db = db;
+    this.passwordHasher = passwordHasher;
+  }
+  async countSuperAdmins() {
+    const rows = await this.db.select({
+      value: count2()
+    }).from(superAdminUsers).where(and8(eq11(superAdminUsers.isActive, true), isNull5(superAdminUsers.deletedAt)));
+    return rows[0]?.value ?? 0;
+  }
+  async createSuperAdmin(input) {
+    const email = input.email.trim().toLowerCase();
+    const existing = await this.db.select().from(superAdminUsers).where(eq11(superAdminUsers.email, email)).limit(1);
+    if (existing[0]) {
+      throw new PlatformUserExistsError(email, existing[0].platformRole);
+    }
+    const rows = await this.db.insert(superAdminUsers).values({
+      id: randomUUID6(),
+      email,
+      passwordHash: await this.passwordHasher.hash(input.password),
+      firstName: input.firstName ?? null,
+      lastName: input.lastName ?? null,
+      updatedAt: /* @__PURE__ */ new Date()
+    }).returning();
+    const row = rows[0];
+    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
+    };
+  }
+};
+DrizzleSuperAdminBootstrapAdapter = _ts_decorate14([
+  Injectable14(),
+  _ts_param13(0, Inject13(DRIZZLE_DB_TOKEN)),
+  _ts_param13(1, Inject13(PASSWORD_HASHER_TOKEN)),
+  _ts_metadata13("design:type", Function),
+  _ts_metadata13("design:paramtypes", [
+    typeof DrizzleClient === "undefined" ? Object : DrizzleClient,
+    typeof PasswordHasher === "undefined" ? Object : PasswordHasher
+  ])
+], DrizzleSuperAdminBootstrapAdapter);
+
+// src/drizzle-transaction-runner.ts
+import { Inject as Inject14, Injectable as Injectable15 } from "@nestjs/common";
+function _ts_decorate15(decorators, target, key, desc4) {
+  var c = arguments.length, r = c < 3 ? target : desc4 === null ? desc4 = Object.getOwnPropertyDescriptor(target, key) : desc4, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc4);
+  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 DrizzleTransactionRunner = class {
+  static {
+    __name(this, "DrizzleTransactionRunner");
+  }
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  async run(fn) {
+    return this.db.transaction((tx) => fn(tx));
+  }
+};
+DrizzleTransactionRunner = _ts_decorate15([
+  Injectable15(),
+  _ts_param14(0, Inject14(DRIZZLE_DB_TOKEN)),
+  _ts_metadata14("design:type", Function),
+  _ts_metadata14("design:paramtypes", [
+    typeof DrizzleClient === "undefined" ? Object : DrizzleClient
+  ])
+], DrizzleTransactionRunner);
+
+// src/zero-promo-revenue-aggregator.ts
+import { Injectable as Injectable16 } from "@nestjs/common";
+function _ts_decorate16(decorators, target, key, desc4) {
+  var c = arguments.length, r = c < 3 ? target : desc4 === null ? desc4 = Object.getOwnPropertyDescriptor(target, key) : desc4, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc4);
+  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/drizzle-persistence.ts
+function drizzlePersistence(options) {
+  const { db } = options;
+  const provide = /* @__PURE__ */ __name((build) => isInjectionToken(db) ? {
+    useFactory: /* @__PURE__ */ __name((client) => build(client), "useFactory"),
+    inject: [
+      db
+    ]
+  } : build(db), "provide");
+  return {
+    capabilities: {
+      transactions: true,
+      pessimisticLocking: true,
+      rowLevelSecurity: options.rlsIntegration ?? false,
+      advisoryLocks: false
+    },
+    core: {
+      mfa: provide((client) => new DrizzleMfaAdapter(client)),
+      audit: provide((client) => new DrizzleAuditAdapter(client)),
+      rlsBypass: new AsyncLocalRlsBypassAdapter(),
+      transactionRunner: provide((client) => new DrizzleTransactionRunner(client)),
+      auditQuery: provide((client) => new DrizzleAuditQueryAdapter(client)),
+      auditStats: provide((client) => new DrizzleAuditStatsAdapter(client)),
+      superAdminProvisioning: buildProvisioning(db, options.passwordHasher)
+    },
+    entitlement: {
+      subscriptionRepository: provide((client) => new DrizzleSubscriptionRepository(client)),
+      planVersionRepository: provide((client) => new DrizzlePlanVersionRepository(client))
+    },
+    promo: {
+      promoCodeRepository: provide((client) => new DrizzlePromoCodeRepository(client)),
+      redemptionRepository: provide((client) => new DrizzlePromoCodeRedemptionRepository(client)),
+      validationLogRepository: provide((client) => new DrizzlePromoCodeValidationLogRepository(client)),
+      subscriptionLookup: provide((client) => new DrizzlePromoSubscriptionLookup(client)),
+      revenueAggregator: new ZeroPromoRevenueDeductionAggregator()
+    },
+    planCatalogReadSink: provide((client) => new DrizzlePlanCatalogReadSink(client)),
+    planCatalogImportSink: provide((client) => new DrizzlePlanCatalogImportSink(client))
+  };
+}
+__name(drizzlePersistence, "drizzlePersistence");
+function isInjectionToken(value) {
+  return typeof value === "function" || typeof value === "symbol" || typeof value === "string";
+}
+__name(isInjectionToken, "isInjectionToken");
+function buildProvisioning(db, hasher) {
+  if (hasher === void 0) return void 0;
+  const dbIsToken = isInjectionToken(db);
+  const hasherIsToken = isInjectionToken(hasher);
+  if (dbIsToken && hasherIsToken) {
+    return {
+      useFactory: /* @__PURE__ */ __name((client, h) => new DrizzleSuperAdminBootstrapAdapter(client, h), "useFactory"),
+      inject: [
+        db,
+        hasher
+      ]
+    };
+  }
+  if (dbIsToken) {
+    return {
+      useFactory: /* @__PURE__ */ __name((client) => new DrizzleSuperAdminBootstrapAdapter(client, hasher), "useFactory"),
+      inject: [
+        db
+      ]
+    };
+  }
+  if (hasherIsToken) {
+    return {
+      useFactory: /* @__PURE__ */ __name((h) => new DrizzleSuperAdminBootstrapAdapter(db, h), "useFactory"),
+      inject: [
+        hasher
+      ]
+    };
+  }
+  return new DrizzleSuperAdminBootstrapAdapter(db, hasher);
+}
+__name(buildProvisioning, "buildProvisioning");
+export {
+  AsyncLocalRlsBypassAdapter,
+  DRIZZLE_DB_TOKEN,
+  DrizzleAuditAdapter,
+  DrizzleAuditQueryAdapter,
+  DrizzleAuditStatsAdapter,
+  DrizzleMfaAdapter,
+  DrizzlePlanCatalogImportSink,
+  DrizzlePlanCatalogReadSink,
+  DrizzlePlanVersionRepository,
+  DrizzlePromoCodeRedemptionRepository,
+  DrizzlePromoCodeRepository,
+  DrizzlePromoCodeValidationLogRepository,
+  DrizzlePromoSubscriptionLookup,
+  DrizzleSubscriptionRepository,
+  DrizzleSuperAdminBootstrapAdapter,
+  DrizzleTransactionRunner,
+  PASSWORD_HASHER_TOKEN,
+  ZeroPromoRevenueDeductionAggregator,
+  buildActorTag,
+  drizzlePersistence,
+  schema_exports as saasicatSchema
+};