@withwiz/coupon 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1928 @@
+'use strict';
+
+var cuid2 = require('@paralleldrive/cuid2');
+var nanoid = require('nanoid');
+var zod = require('zod');
+
+// src/domain/constants.ts
+var COUPON_STATUS = {
+  DRAFT: "DRAFT",
+  ACTIVE: "ACTIVE",
+  PAUSED: "PAUSED",
+  EXPIRED: "EXPIRED",
+  EXHAUSTED: "EXHAUSTED",
+  ARCHIVED: "ARCHIVED"
+};
+var CAMPAIGN_STATUS = {
+  ACTIVE: "ACTIVE",
+  CLOSED: "CLOSED"
+};
+var COUPON_REJECT_REASON = {
+  NOT_FOUND: "NOT_FOUND",
+  NOT_STARTED: "NOT_STARTED",
+  EXPIRED: "EXPIRED",
+  EXHAUSTED: "EXHAUSTED",
+  PER_USER_LIMIT: "PER_USER_LIMIT",
+  MIN_ORDER_NOT_MET: "MIN_ORDER_NOT_MET",
+  INELIGIBLE_USER: "INELIGIBLE_USER",
+  INELIGIBLE_PLAN: "INELIGIBLE_PLAN",
+  INELIGIBLE_PRODUCT: "INELIGIBLE_PRODUCT",
+  INELIGIBLE_CATEGORY: "INELIGIBLE_CATEGORY",
+  PAUSED: "PAUSED",
+  ARCHIVED: "ARCHIVED",
+  TENANT_MISMATCH: "TENANT_MISMATCH"
+};
+var LIMITS = {
+  CODE_MAX_LENGTH: 64,
+  CODE_MIN_LENGTH: 1,
+  /**
+   * Default character set for generated codes (confusing chars removed).
+   * Excludes `0/O`, `1/I/L` and lower-case to avoid user transcription errors.
+   */
+  CODE_DEFAULT_ALPHABET: "ABCDEFGHJKMNPQRSTUVWXYZ23456789",
+  CODE_DEFAULT_LENGTH: 8,
+  /**
+   * [A] whitelist for accepted coupon codes (after NFKC normalization + upper-case).
+   * Only uppercase ASCII letters, digits, underscore, hyphen are allowed.
+   * SQL meta characters / quotes / spaces / CJK / emoji are all rejected.
+   */
+  CODE_ALLOWED_REGEX: /^[A-Z0-9_-]+$/,
+  TENANT_ID_MAX_LENGTH: 64,
+  TENANT_ID_REGEX: /^[a-zA-Z0-9_\-:.]+$/,
+  BULK_MAX_COUNT: 1e4,
+  BULK_MAX_ATTEMPTS: 5,
+  BULK_DEFAULT_MAX_ATTEMPTS: 3,
+  PAGINATION_DEFAULT_LIMIT: 50,
+  PAGINATION_MAX_LIMIT: 200,
+  NAME_MAX_LENGTH: 200,
+  CURRENCY_LENGTH: 3
+};
+var AUDIT_ACTION = {
+  COUPON_CREATED: "coupon.created",
+  COUPON_PAUSED: "coupon.paused",
+  COUPON_RESUMED: "coupon.resumed",
+  COUPON_ARCHIVED: "coupon.archived",
+  COUPON_ISSUED: "coupon.issued",
+  COUPON_ISSUED_BULK: "coupon.issued.bulk",
+  COUPON_REDEEMED: "coupon.redeemed",
+  COUPON_REDEEM_REJECTED: "coupon.redeem.rejected",
+  CAMPAIGN_CREATED: "campaign.created",
+  CAMPAIGN_CLOSED: "campaign.closed"
+};
+var RESOURCE_TYPE = {
+  COUPON: "coupon",
+  CAMPAIGN: "campaign"
+};
+var FORBIDDEN_METADATA_KEYS = [
+  "__proto__",
+  "constructor",
+  "prototype"
+];
+
+// src/domain/errors.ts
+var CouponError = class extends Error {
+  name;
+  code;
+  tenantId;
+  couponId;
+  couponCode;
+  cause;
+  constructor(message, code, ctx) {
+    super(message);
+    this.name = new.target.name;
+    this.code = code;
+    this.tenantId = ctx?.tenantId;
+    this.couponId = ctx?.couponId;
+    this.couponCode = ctx?.couponCode;
+    this.cause = ctx?.cause;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var ValidationError = class _ValidationError extends CouponError {
+  static code = "VALIDATION_ERROR";
+  details;
+  constructor(message, details, ctx) {
+    super(message, _ValidationError.code, ctx);
+    this.details = details;
+  }
+};
+var InvalidDiscountPolicyError = class _InvalidDiscountPolicyError extends CouponError {
+  static code = "INVALID_DISCOUNT_POLICY";
+  constructor(message, ctx) {
+    super(message, _InvalidDiscountPolicyError.code, ctx);
+  }
+};
+var InvalidDateRangeError = class _InvalidDateRangeError extends CouponError {
+  static code = "INVALID_DATE_RANGE";
+  constructor(message, ctx) {
+    super(message, _InvalidDateRangeError.code, ctx);
+  }
+};
+var CurrencyMismatchError = class _CurrencyMismatchError extends CouponError {
+  static code = "CURRENCY_MISMATCH";
+  constructor(message, ctx) {
+    super(message, _CurrencyMismatchError.code, ctx);
+  }
+};
+var InvalidModelNameError = class _InvalidModelNameError extends CouponError {
+  static code = "INVALID_MODEL_NAME";
+  constructor(message, ctx) {
+    super(message, _InvalidModelNameError.code, ctx);
+  }
+};
+var CouponNotFoundError = class _CouponNotFoundError extends CouponError {
+  static code = "NOT_FOUND";
+  constructor(message = "Coupon not found", ctx) {
+    super(message, _CouponNotFoundError.code, ctx);
+  }
+};
+var CouponArchivedError = class _CouponArchivedError extends CouponError {
+  static code = "ARCHIVED";
+  constructor(message = "Coupon is archived", ctx) {
+    super(message, _CouponArchivedError.code, ctx);
+  }
+};
+var CouponInactiveError = class _CouponInactiveError extends CouponError {
+  static code = "PAUSED";
+  constructor(message = "Coupon is not active", ctx) {
+    super(message, _CouponInactiveError.code, ctx);
+  }
+};
+var CouponExpiredError = class _CouponExpiredError extends CouponError {
+  static code = "EXPIRED";
+  constructor(message = "Coupon is expired", ctx, codeOverride) {
+    super(message, codeOverride ?? _CouponExpiredError.code, ctx);
+  }
+};
+var CouponExhaustedError = class _CouponExhaustedError extends CouponError {
+  static code = "EXHAUSTED";
+  constructor(message = "Coupon fully redeemed", ctx) {
+    super(message, _CouponExhaustedError.code, ctx);
+  }
+};
+var CouponAlreadyRedeemedError = class _CouponAlreadyRedeemedError extends CouponError {
+  static code = "ALREADY_REDEEMED";
+  constructor(message = "Coupon already redeemed for this order", ctx) {
+    super(message, _CouponAlreadyRedeemedError.code, ctx);
+  }
+};
+var PerUserLimitExceededError = class _PerUserLimitExceededError extends CouponError {
+  static code = "PER_USER_LIMIT";
+  constructor(message = "Per-user redemption limit exceeded", ctx) {
+    super(message, _PerUserLimitExceededError.code, ctx);
+  }
+};
+var IneligibleUserError = class _IneligibleUserError extends CouponError {
+  static code = "INELIGIBLE_USER";
+  constructor(message = "User is not eligible for this coupon", ctx) {
+    super(message, _IneligibleUserError.code, ctx);
+  }
+};
+var IneligiblePlanError = class _IneligiblePlanError extends CouponError {
+  static code = "INELIGIBLE_PLAN";
+  constructor(message = "Plan is not eligible for this coupon", ctx) {
+    super(message, _IneligiblePlanError.code, ctx);
+  }
+};
+var IneligibleProductError = class _IneligibleProductError extends CouponError {
+  static code = "INELIGIBLE_PRODUCT";
+  constructor(message = "Product is not eligible for this coupon", ctx) {
+    super(message, _IneligibleProductError.code, ctx);
+  }
+};
+var IneligibleCategoryError = class _IneligibleCategoryError extends CouponError {
+  static code = "INELIGIBLE_CATEGORY";
+  constructor(message = "Category is not eligible for this coupon", ctx) {
+    super(message, _IneligibleCategoryError.code, ctx);
+  }
+};
+var MinimumOrderNotMetError = class _MinimumOrderNotMetError extends CouponError {
+  static code = "MIN_ORDER_NOT_MET";
+  constructor(message = "Minimum order amount not met", ctx) {
+    super(message, _MinimumOrderNotMetError.code, ctx);
+  }
+};
+var CampaignClosedError = class _CampaignClosedError extends CouponError {
+  static code = "CAMPAIGN_CLOSED";
+  constructor(message = "Campaign is closed", ctx) {
+    super(message, _CampaignClosedError.code, ctx);
+  }
+};
+var CampaignCapacityExceededError = class _CampaignCapacityExceededError extends CouponError {
+  static code = "CAMPAIGN_CAPACITY_EXCEEDED";
+  constructor(message = "Campaign capacity exceeded", ctx) {
+    super(message, _CampaignCapacityExceededError.code, ctx);
+  }
+};
+var TenantMismatchError = class _TenantMismatchError extends CouponError {
+  static code = "TENANT_MISMATCH";
+  constructor(message = "Tenant mismatch", ctx) {
+    super(message, _TenantMismatchError.code, ctx);
+  }
+};
+
+// src/discount.ts
+function ensureNonNegativeInteger(name, value) {
+  if (!Number.isFinite(value) || !Number.isInteger(value) || value < 0) {
+    throw new ValidationError(
+      `${name} must be a non-negative integer (got ${String(value)})`
+    );
+  }
+}
+function ensureCurrency(code) {
+  if (typeof code !== "string" || code.length !== 3) {
+    throw new ValidationError(
+      `currency must be a 3-letter ISO-4217 code (got ${String(code)})`
+    );
+  }
+}
+function validateDiscountPolicy(policy) {
+  if (!policy || typeof policy !== "object") {
+    throw new InvalidDiscountPolicyError("discount policy must be an object");
+  }
+  if (policy.kind === "PERCENT") {
+    const { percent } = policy;
+    if (typeof percent !== "number" || !Number.isFinite(percent) || percent <= 0 || percent > 100) {
+      throw new InvalidDiscountPolicyError(
+        `PERCENT.percent must be in (0, 100] (got ${String(percent)})`
+      );
+    }
+    if (policy.maxDiscount !== void 0) {
+      if (typeof policy.maxDiscount !== "number" || !Number.isInteger(policy.maxDiscount) || policy.maxDiscount < 0) {
+        throw new InvalidDiscountPolicyError(
+          "PERCENT.maxDiscount must be a non-negative integer"
+        );
+      }
+    }
+    if (policy.minOrder !== void 0) {
+      if (typeof policy.minOrder !== "number" || !Number.isInteger(policy.minOrder) || policy.minOrder < 0) {
+        throw new InvalidDiscountPolicyError(
+          "PERCENT.minOrder must be a non-negative integer"
+        );
+      }
+    }
+    if (policy.currency !== void 0) {
+      ensureCurrency(policy.currency);
+    }
+    return;
+  }
+  if (policy.kind === "FIXED") {
+    const { amount, currency } = policy;
+    if (typeof amount !== "number" || !Number.isInteger(amount) || amount <= 0) {
+      throw new InvalidDiscountPolicyError(
+        `FIXED.amount must be a positive integer (got ${String(amount)})`
+      );
+    }
+    ensureCurrency(currency);
+    if (policy.minOrder !== void 0) {
+      if (typeof policy.minOrder !== "number" || !Number.isInteger(policy.minOrder) || policy.minOrder < 0) {
+        throw new InvalidDiscountPolicyError(
+          "FIXED.minOrder must be a non-negative integer"
+        );
+      }
+    }
+    return;
+  }
+  throw new InvalidDiscountPolicyError(
+    `unknown discount policy kind: ${String(policy.kind)}`
+  );
+}
+function calculate(input) {
+  if (!input || typeof input !== "object") {
+    throw new ValidationError("discount input must be an object");
+  }
+  ensureNonNegativeInteger("subtotal", input.subtotal);
+  ensureCurrency(input.currency);
+  validateDiscountPolicy(input.policy);
+  const trace = [];
+  const policyCurrency = extractPolicyCurrency(input.policy);
+  if (policyCurrency && policyCurrency !== input.currency) {
+    throw new CurrencyMismatchError(
+      `currency mismatch: input=${input.currency} policy=${policyCurrency}`
+    );
+  }
+  const minOrder = input.policy.minOrder;
+  if (typeof minOrder === "number" && input.subtotal < minOrder) {
+    throw new MinimumOrderNotMetError(
+      `minimum order ${minOrder} not met (subtotal=${input.subtotal})`
+    );
+  }
+  let discountAmount = 0;
+  if (input.policy.kind === "PERCENT") {
+    const raw = Math.floor(input.subtotal * input.policy.percent / 100);
+    trace.push(`percent=${input.policy.percent}% raw=${raw}`);
+    if (typeof input.policy.maxDiscount === "number") {
+      const capped = Math.min(raw, input.policy.maxDiscount);
+      if (capped !== raw) {
+        trace.push(`capped by maxDiscount=${input.policy.maxDiscount} -> ${capped}`);
+      }
+      discountAmount = capped;
+    } else {
+      discountAmount = raw;
+    }
+  } else {
+    discountAmount = input.policy.amount;
+    trace.push(`fixed=${input.policy.amount}`);
+  }
+  if (discountAmount > input.subtotal) {
+    trace.push(`clamped discount ${discountAmount} to subtotal ${input.subtotal}`);
+    discountAmount = input.subtotal;
+  }
+  ensurePositiveIntegerIfNonZero(discountAmount);
+  const total = input.subtotal - discountAmount;
+  trace.push(`total=${total}`);
+  return {
+    subtotal: input.subtotal,
+    discountAmount,
+    total,
+    appliedPolicy: input.policy,
+    trace,
+    currency: input.currency
+  };
+}
+function ensurePositiveIntegerIfNonZero(value) {
+  if (value !== 0 && !Number.isInteger(value)) {
+    throw new ValidationError("discountAmount must be an integer");
+  }
+  if (value < 0) {
+    throw new ValidationError("discountAmount must be non-negative");
+  }
+}
+function extractPolicyCurrency(policy) {
+  if (policy.kind === "FIXED") return policy.currency;
+  if (policy.kind === "PERCENT") return policy.currency;
+  return void 0;
+}
+
+// src/eligibility.ts
+function checkEligibility(input) {
+  const { rules, userId, context } = input;
+  if (!rules) {
+    return { ok: true };
+  }
+  if (rules.allowedUserIds && rules.allowedUserIds.length > 0) {
+    if (!userId || !rules.allowedUserIds.includes(userId)) {
+      return { ok: false, reason: COUPON_REJECT_REASON.INELIGIBLE_USER };
+    }
+  }
+  if (rules.allowedPlans && rules.allowedPlans.length > 0) {
+    const plan = context?.plan;
+    if (!plan || !rules.allowedPlans.includes(plan)) {
+      return { ok: false, reason: COUPON_REJECT_REASON.INELIGIBLE_PLAN };
+    }
+  }
+  if (rules.allowedProductIds && rules.allowedProductIds.length > 0) {
+    const productId = context?.productId;
+    if (!productId || !rules.allowedProductIds.includes(productId)) {
+      return { ok: false, reason: COUPON_REJECT_REASON.INELIGIBLE_PRODUCT };
+    }
+  }
+  if (rules.allowedCategories && rules.allowedCategories.length > 0) {
+    const categoryId = context?.categoryId;
+    if (!categoryId || !rules.allowedCategories.includes(categoryId)) {
+      return { ok: false, reason: COUPON_REJECT_REASON.INELIGIBLE_CATEGORY };
+    }
+  }
+  return { ok: true };
+}
+function eligibilityReasonToError(reason) {
+  switch (reason) {
+    case COUPON_REJECT_REASON.INELIGIBLE_USER:
+      return new IneligibleUserError();
+    case COUPON_REJECT_REASON.INELIGIBLE_PLAN:
+      return new IneligiblePlanError();
+    case COUPON_REJECT_REASON.INELIGIBLE_PRODUCT:
+      return new IneligibleProductError();
+    case COUPON_REJECT_REASON.INELIGIBLE_CATEGORY:
+      return new IneligibleCategoryError();
+    default:
+      return new IneligibleUserError(`Unexpected eligibility reason: ${reason}`);
+  }
+}
+function defaultIdGenerator() {
+  return cuid2.createId();
+}
+function defaultCodeGenerator(opts) {
+  const alphabet = opts.alphabet ?? LIMITS.CODE_DEFAULT_ALPHABET;
+  const length = opts.length;
+  if (typeof length !== "number" || !Number.isInteger(length) || length < LIMITS.CODE_MIN_LENGTH || length > LIMITS.CODE_MAX_LENGTH) {
+    throw new ValidationError(
+      `code length must be an integer in [${LIMITS.CODE_MIN_LENGTH}, ${LIMITS.CODE_MAX_LENGTH}] (got ${String(length)})`
+    );
+  }
+  if (typeof alphabet !== "string" || alphabet.length === 0) {
+    throw new ValidationError("code alphabet must be a non-empty string");
+  }
+  const nano = nanoid.customAlphabet(alphabet, length);
+  return nano();
+}
+
+// src/mapping.ts
+function asString(v, field) {
+  if (typeof v !== "string") {
+    throw new Error(`mapping: expected string for ${field}, got ${typeof v}`);
+  }
+  return v;
+}
+function asStringOrNull(v) {
+  if (v === null || v === void 0) return null;
+  if (typeof v !== "string") return String(v);
+  return v;
+}
+function asNumber(v, field) {
+  if (typeof v !== "number") {
+    throw new Error(`mapping: expected number for ${field}, got ${typeof v}`);
+  }
+  return v;
+}
+function asNumberOrNull(v) {
+  if (v === null || v === void 0) return null;
+  if (typeof v !== "number") return Number(v);
+  return v;
+}
+function asDate(v, field) {
+  if (v instanceof Date) return v;
+  if (typeof v === "string" || typeof v === "number") return new Date(v);
+  throw new Error(`mapping: expected Date for ${field}, got ${typeof v}`);
+}
+function asDateOrNull(v) {
+  if (v === null || v === void 0) return null;
+  if (v instanceof Date) return v;
+  if (typeof v === "string" || typeof v === "number") return new Date(v);
+  return null;
+}
+function asJsonObject(v) {
+  if (v === null || v === void 0) return null;
+  if (typeof v !== "object") return null;
+  return v;
+}
+function jsonAs(v) {
+  return asJsonObject(v) ?? {};
+}
+function rowToCoupon(row) {
+  return {
+    id: asString(row.id, "id"),
+    tenantId: asString(row.tenantId, "tenantId"),
+    campaignId: asStringOrNull(row.campaignId),
+    code: asString(row.code, "code"),
+    status: asString(row.status, "status"),
+    discount: jsonAs(row.discount),
+    startsAt: asDateOrNull(row.startsAt),
+    endsAt: asDateOrNull(row.endsAt),
+    maxRedemptions: asNumberOrNull(row.maxRedemptions),
+    redeemedCount: asNumber(row.redeemedCount, "redeemedCount"),
+    maxRedemptionsPerUser: asNumberOrNull(row.maxRedemptionsPerUser),
+    eligibility: asJsonObject(row.eligibility) ?? {},
+    metadata: asJsonObject(row.metadata),
+    createdAt: asDate(row.createdAt, "createdAt"),
+    updatedAt: asDate(row.updatedAt, "updatedAt")
+  };
+}
+function rowToCampaign(row) {
+  return {
+    id: asString(row.id, "id"),
+    tenantId: asString(row.tenantId, "tenantId"),
+    name: asString(row.name, "name"),
+    status: asString(row.status, "status"),
+    discount: jsonAs(row.discount),
+    eligibility: asJsonObject(row.eligibility) ?? {},
+    startsAt: asDateOrNull(row.startsAt),
+    endsAt: asDateOrNull(row.endsAt),
+    maxCoupons: asNumberOrNull(row.maxCoupons),
+    issuedCount: asNumber(row.issuedCount, "issuedCount"),
+    metadata: asJsonObject(row.metadata),
+    createdAt: asDate(row.createdAt, "createdAt"),
+    updatedAt: asDate(row.updatedAt, "updatedAt")
+  };
+}
+function rowToIssuance(row) {
+  return {
+    id: asString(row.id, "id"),
+    tenantId: asString(row.tenantId, "tenantId"),
+    couponId: asString(row.couponId, "couponId"),
+    issuedToUserId: asStringOrNull(row.issuedToUserId),
+    issuedBy: asStringOrNull(row.issuedBy),
+    issuedAt: asDate(row.issuedAt, "issuedAt"),
+    metadata: asJsonObject(row.metadata)
+  };
+}
+function rowToRedemption(row) {
+  return {
+    id: asString(row.id, "id"),
+    tenantId: asString(row.tenantId, "tenantId"),
+    couponId: asString(row.couponId, "couponId"),
+    redeemedByUserId: asStringOrNull(row.redeemedByUserId),
+    orderRef: asStringOrNull(row.orderRef),
+    discountAmount: asNumber(row.discountAmount, "discountAmount"),
+    currency: asString(row.currency, "currency"),
+    redeemedAt: asDate(row.redeemedAt, "redeemedAt"),
+    metadata: asJsonObject(row.metadata)
+  };
+}
+function rowToAuditLog(row) {
+  return {
+    id: asString(row.id, "id"),
+    tenantId: asString(row.tenantId, "tenantId"),
+    action: asString(row.action, "action"),
+    resourceId: asStringOrNull(row.resourceId),
+    resourceType: asStringOrNull(row.resourceType),
+    actorId: asStringOrNull(row.actorId),
+    details: asJsonObject(row.details),
+    createdAt: asDate(row.createdAt, "createdAt")
+  };
+}
+
+// src/audit.ts
+async function writeAudit(auditLog, input) {
+  await auditLog.create({
+    data: {
+      tenantId: input.tenantId,
+      action: input.action,
+      resourceId: input.resourceId ?? null,
+      resourceType: input.resourceType ?? null,
+      actorId: input.actorId ?? null,
+      details: input.details ?? null
+    }
+  });
+}
+
+// src/delegates.ts
+var MODEL_KEYS = [
+  "coupon",
+  "campaign",
+  "couponIssuance",
+  "couponRedemption",
+  "couponAuditLog"
+];
+var DEFAULT_MODEL_NAMES = {
+  coupon: "coupon",
+  campaign: "campaign",
+  couponIssuance: "couponIssuance",
+  couponRedemption: "couponRedemption",
+  couponAuditLog: "couponAuditLog"
+};
+var IDENTIFIER_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function assertIdentifier(kind, key, value) {
+  if (typeof value !== "string" || !IDENTIFIER_RE.test(value)) {
+    throw new InvalidModelNameError(
+      `Invalid ${kind} for model "${key}": ${JSON.stringify(value)}. Expected a plain identifier matching ${IDENTIFIER_RE.source}.`
+    );
+  }
+  return value;
+}
+function resolveModelNames(overrides) {
+  const out = { ...DEFAULT_MODEL_NAMES };
+  for (const key of MODEL_KEYS) {
+    const override = overrides?.[key];
+    if (override === void 0) continue;
+    out[key] = assertIdentifier("model name", key, override);
+  }
+  return out;
+}
+function resolveTableNames(models, overrides) {
+  const out = {};
+  for (const key of MODEL_KEYS) {
+    const override = overrides?.[key];
+    out[key] = override === void 0 ? models[key].charAt(0).toUpperCase() + models[key].slice(1) : assertIdentifier("table name", key, override);
+  }
+  return out;
+}
+function pick(db, key, name) {
+  const delegate = db[name];
+  if (!delegate || typeof delegate.findFirst !== "function") {
+    throw new InvalidModelNameError(
+      `Prisma delegate "${name}" (model "${key}") is missing on the client passed to createCouponClient. Either add the model to your schema or map it through config.models.${key}.`
+    );
+  }
+  return delegate;
+}
+function createDelegateResolver(models, tables) {
+  const resolver = {
+    models,
+    tables
+  };
+  for (const key of MODEL_KEYS) {
+    resolver[key] = (db) => pick(db, key, models[key]);
+  }
+  return resolver;
+}
+function lockCouponRow(tx, table, couponId, tenantId) {
+  const parts = [
+    `SELECT * FROM "${table}" WHERE "id" = `,
+    ` AND "tenantId" = `,
+    ` FOR UPDATE`
+  ];
+  const strings = Object.assign([...parts], {
+    raw: [...parts]
+  });
+  return tx.$queryRaw(strings, couponId, tenantId);
+}
+function assertTenantId(value) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new ValidationError("tenantId is required");
+  }
+  if (value.length > LIMITS.TENANT_ID_MAX_LENGTH) {
+    throw new ValidationError(
+      `tenantId length exceeds max (${LIMITS.TENANT_ID_MAX_LENGTH})`
+    );
+  }
+  if (!LIMITS.TENANT_ID_REGEX.test(value)) {
+    throw new ValidationError(
+      `tenantId contains invalid characters (allowed: [a-zA-Z0-9_-:.])`
+    );
+  }
+}
+function sanitizeCode(raw) {
+  if (typeof raw !== "string") {
+    throw new ValidationError("code must be a string");
+  }
+  const normalized = raw.normalize("NFKC");
+  if (normalized.length === 0 || normalized.length > LIMITS.CODE_MAX_LENGTH) {
+    throw new ValidationError(
+      `code length must be in [1, ${LIMITS.CODE_MAX_LENGTH}]`
+    );
+  }
+  for (let i = 0; i < normalized.length; i++) {
+    const cp = normalized.charCodeAt(i);
+    if (cp === 0) {
+      throw new ValidationError("code contains NUL");
+    }
+    if (cp < 32 || cp === 127) {
+      throw new ValidationError("code contains control characters");
+    }
+    if (cp === 32 || cp === 9 || cp === 10 || cp === 13) {
+      throw new ValidationError("code contains whitespace");
+    }
+  }
+  const upper = normalized.toUpperCase();
+  if (!LIMITS.CODE_ALLOWED_REGEX.test(upper)) {
+    throw new ValidationError(
+      "coupon code contains invalid characters; allowed: [A-Z0-9_-]"
+    );
+  }
+  return upper;
+}
+function canonicalizeCode(raw) {
+  return sanitizeCode(raw);
+}
+function assertMetadata(meta) {
+  if (meta === void 0 || meta === null) return meta;
+  if (typeof meta !== "object" || Array.isArray(meta)) {
+    throw new ValidationError("metadata must be a plain object");
+  }
+  const rec = meta;
+  for (const key of Object.keys(rec)) {
+    if (FORBIDDEN_METADATA_KEYS.includes(key)) {
+      throw new ValidationError(
+        `metadata key "${key}" is forbidden (prototype pollution guard)`
+      );
+    }
+  }
+  return rec;
+}
+function assertPaginationLimit(limit) {
+  if (limit === void 0) return LIMITS.PAGINATION_DEFAULT_LIMIT;
+  if (typeof limit !== "number" || !Number.isInteger(limit) || limit <= 0 || limit > LIMITS.PAGINATION_MAX_LIMIT) {
+    throw new ValidationError(
+      `limit must be an integer in [1, ${LIMITS.PAGINATION_MAX_LIMIT}]`
+    );
+  }
+  return limit;
+}
+function assertCurrency(currency) {
+  if (typeof currency !== "string" || currency.length !== LIMITS.CURRENCY_LENGTH) {
+    throw new ValidationError(
+      `currency must be a ${LIMITS.CURRENCY_LENGTH}-letter ISO-4217 code`
+    );
+  }
+}
+function assertDateRange(startsAt, endsAt) {
+  if (startsAt && endsAt) {
+    if (!(startsAt instanceof Date) || !(endsAt instanceof Date)) {
+      throw new ValidationError("startsAt/endsAt must be Date objects");
+    }
+    if (startsAt.getTime() >= endsAt.getTime()) {
+      throw new InvalidDateRangeError(
+        "startsAt must be strictly less than endsAt"
+      );
+    }
+  }
+}
+function assertEligibility(rules) {
+  if (rules === void 0 || rules === null) return {};
+  if (typeof rules !== "object" || Array.isArray(rules)) {
+    throw new ValidationError("eligibility must be a plain object");
+  }
+  const r = rules;
+  const allowed = [
+    "allowedUserIds",
+    "allowedPlans",
+    "allowedProductIds",
+    "allowedCategories"
+  ];
+  const out = {};
+  for (const key of allowed) {
+    const v = r[key];
+    if (v === void 0) continue;
+    if (!Array.isArray(v) || !v.every((x) => typeof x === "string" && x.length > 0)) {
+      throw new ValidationError(
+        `eligibility.${key} must be an array of non-empty strings`
+      );
+    }
+    out[key] = v;
+  }
+  return out;
+}
+function resolveTenantId(provided, defaultTenantId) {
+  const tid = provided ?? defaultTenantId;
+  assertTenantId(tid);
+  return tid;
+}
+function validateCreateCouponInput(input) {
+  if (!input || typeof input !== "object") {
+    throw new ValidationError("input must be an object");
+  }
+  validateDiscountPolicy(input.discount);
+  assertDateRange(input.startsAt ?? null, input.endsAt ?? null);
+  assertMetadata(input.metadata);
+  if (input.maxRedemptions !== void 0 && input.maxRedemptions !== null) {
+    if (typeof input.maxRedemptions !== "number" || !Number.isInteger(input.maxRedemptions) || input.maxRedemptions <= 0) {
+      throw new ValidationError("maxRedemptions must be a positive integer or null");
+    }
+  }
+  if (input.maxRedemptionsPerUser !== void 0 && input.maxRedemptionsPerUser !== null) {
+    if (typeof input.maxRedemptionsPerUser !== "number" || !Number.isInteger(input.maxRedemptionsPerUser) || input.maxRedemptionsPerUser <= 0) {
+      throw new ValidationError(
+        "maxRedemptionsPerUser must be a positive integer or null"
+      );
+    }
+  }
+}
+function validateIssueBulkInput(input) {
+  if (!input || typeof input !== "object") {
+    throw new ValidationError("input must be an object");
+  }
+  if (typeof input.count !== "number" || !Number.isInteger(input.count) || input.count <= 0) {
+    throw new ValidationError("count must be a positive integer");
+  }
+  if (input.count > LIMITS.BULK_MAX_COUNT) {
+    throw new ValidationError(
+      `count exceeds max bulk limit (${LIMITS.BULK_MAX_COUNT})`
+    );
+  }
+  if (input.maxAttempts !== void 0) {
+    if (typeof input.maxAttempts !== "number" || !Number.isInteger(input.maxAttempts) || input.maxAttempts <= 0 || input.maxAttempts > LIMITS.BULK_MAX_ATTEMPTS) {
+      throw new ValidationError(
+        `maxAttempts must be in [1, ${LIMITS.BULK_MAX_ATTEMPTS}]`
+      );
+    }
+  }
+  validateDiscountPolicy(input.discount);
+  assertDateRange(input.startsAt ?? null, input.endsAt ?? null);
+  assertMetadata(input.metadata);
+}
+function validateIssueCouponInput(input) {
+  if (!input || typeof input !== "object") {
+    throw new ValidationError("input must be an object");
+  }
+  if (typeof input.couponId !== "string" || input.couponId.length === 0) {
+    throw new ValidationError("couponId is required");
+  }
+  assertMetadata(input.metadata);
+}
+function validateValidateInput(input) {
+  if (!input || typeof input !== "object") {
+    throw new ValidationError("input must be an object");
+  }
+  if (typeof input.code !== "string" || input.code.length === 0) {
+    throw new ValidationError("code is required");
+  }
+  if (input.subtotal !== void 0) {
+    if (typeof input.subtotal !== "number" || !Number.isInteger(input.subtotal) || input.subtotal < 0) {
+      throw new ValidationError("subtotal must be a non-negative integer");
+    }
+  }
+  if (input.currency !== void 0) {
+    assertCurrency(input.currency);
+  }
+}
+function validateRedeemInput(input) {
+  if (!input || typeof input !== "object") {
+    throw new ValidationError("input must be an object");
+  }
+  if (typeof input.code !== "string" || input.code.length === 0) {
+    throw new ValidationError("code is required");
+  }
+  if (typeof input.subtotal !== "number" || !Number.isInteger(input.subtotal) || input.subtotal < 0) {
+    throw new ValidationError("subtotal must be a non-negative integer");
+  }
+  assertCurrency(input.currency);
+  assertMetadata(input.metadata);
+}
+function validateCreateCampaignInput(input) {
+  if (!input || typeof input !== "object") {
+    throw new ValidationError("input must be an object");
+  }
+  if (typeof input.name !== "string" || input.name.length === 0) {
+    throw new ValidationError("campaign name is required");
+  }
+  if (input.name.length > LIMITS.NAME_MAX_LENGTH) {
+    throw new ValidationError(
+      `campaign name exceeds max length (${LIMITS.NAME_MAX_LENGTH})`
+    );
+  }
+  validateDiscountPolicy(input.discount);
+  assertDateRange(input.startsAt ?? null, input.endsAt ?? null);
+  assertMetadata(input.metadata);
+  if (input.maxCoupons !== void 0 && input.maxCoupons !== null) {
+    if (typeof input.maxCoupons !== "number" || !Number.isInteger(input.maxCoupons) || input.maxCoupons <= 0) {
+      throw new ValidationError(
+        "maxCoupons must be a positive integer or null"
+      );
+    }
+    if (input.maxCoupons > LIMITS.BULK_MAX_COUNT) {
+      throw new ValidationError(
+        `maxCoupons exceeds bulk limit (${LIMITS.BULK_MAX_COUNT})`
+      );
+    }
+  }
+}
+zod.z.discriminatedUnion("kind", [
+  zod.z.object({
+    kind: zod.z.literal("PERCENT"),
+    percent: zod.z.number().gt(0).lte(100),
+    maxDiscount: zod.z.number().int().nonnegative().optional(),
+    minOrder: zod.z.number().int().nonnegative().optional(),
+    currency: zod.z.string().length(3).optional()
+  }),
+  zod.z.object({
+    kind: zod.z.literal("FIXED"),
+    amount: zod.z.number().int().positive(),
+    currency: zod.z.string().length(3),
+    minOrder: zod.z.number().int().nonnegative().optional()
+  })
+]);
+
+// src/client.ts
+function w(v) {
+  return v;
+}
+var NOOP_LOGGER = {
+  debug() {
+  },
+  info() {
+  },
+  warn() {
+  },
+  error() {
+  }
+};
+var NOOP_EVENTS = {
+  onEvent() {
+  }
+};
+function resolveConfig(config) {
+  if (!config || typeof config !== "object") {
+    throw new ValidationError("createCouponClient: config is required");
+  }
+  if (!config.prisma || typeof config.prisma !== "object") {
+    throw new ValidationError("createCouponClient: prisma client is required");
+  }
+  const models = resolveModelNames(config.models);
+  return {
+    prisma: config.prisma,
+    defaultTenantId: config.defaultTenantId,
+    idGenerator: config.idGenerator ?? defaultIdGenerator,
+    codeGenerator: config.codeGenerator ?? defaultCodeGenerator,
+    events: config.events ?? NOOP_EVENTS,
+    now: config.now ?? (() => /* @__PURE__ */ new Date()),
+    // allow-now: default fallback when config.now is omitted
+    logger: config.logger ?? NOOP_LOGGER,
+    models,
+    tables: resolveTableNames(models, config.tables)
+  };
+}
+async function safeEmit(handler, logger, event) {
+  try {
+    await handler.onEvent(event);
+  } catch (error) {
+    logger.warn("coupon.event.handler_failed", {
+      event: event.type,
+      error: error instanceof Error ? error.message : String(error)
+    });
+  }
+}
+async function resolveLazyStatus(delegates, tx, coupon, now) {
+  if (coupon.status === COUPON_STATUS.ARCHIVED) {
+    return { kind: "reject", reason: "ARCHIVED", coupon };
+  }
+  if (coupon.status === COUPON_STATUS.PAUSED) {
+    return { kind: "reject", reason: "PAUSED", coupon };
+  }
+  if (coupon.status === COUPON_STATUS.DRAFT) {
+    return { kind: "reject", reason: "PAUSED", coupon };
+  }
+  if (coupon.startsAt && now.getTime() < coupon.startsAt.getTime()) {
+    return { kind: "reject", reason: "NOT_STARTED", coupon };
+  }
+  if (coupon.endsAt && now.getTime() >= coupon.endsAt.getTime()) {
+    if (coupon.status !== COUPON_STATUS.EXPIRED) {
+      await delegates.coupon(tx).updateMany({
+        where: {
+          id: coupon.id,
+          tenantId: coupon.tenantId,
+          status: { notIn: [COUPON_STATUS.ARCHIVED, COUPON_STATUS.EXPIRED] }
+        },
+        data: { status: COUPON_STATUS.EXPIRED }
+      });
+    }
+    return {
+      kind: "reject",
+      reason: "EXPIRED",
+      coupon: { ...coupon, status: COUPON_STATUS.EXPIRED }
+    };
+  }
+  if (coupon.maxRedemptions !== null && coupon.redeemedCount >= coupon.maxRedemptions) {
+    if (coupon.status !== COUPON_STATUS.EXHAUSTED) {
+      await delegates.coupon(tx).updateMany({
+        where: {
+          id: coupon.id,
+          tenantId: coupon.tenantId,
+          status: { notIn: [COUPON_STATUS.ARCHIVED, COUPON_STATUS.EXHAUSTED] }
+        },
+        data: { status: COUPON_STATUS.EXHAUSTED }
+      });
+    }
+    return {
+      kind: "reject",
+      reason: "EXHAUSTED",
+      coupon: { ...coupon, status: COUPON_STATUS.EXHAUSTED }
+    };
+  }
+  return { kind: "ok", coupon };
+}
+function withIdTieBreak(orderBy) {
+  if ("id" in orderBy) return [orderBy];
+  const leading = Object.values(orderBy)[0];
+  const direction = leading === "asc" ? "asc" : "desc";
+  return [orderBy, { id: direction }];
+}
+function createCouponClient(config) {
+  const cfg = resolveConfig(config);
+  const prisma = cfg.prisma;
+  const delegates = createDelegateResolver(cfg.models, cfg.tables);
+  const tid = (v) => resolveTenantId(v, cfg.defaultTenantId);
+  async function paginate(delegate, where, limit, cursor, mapFn, orderBy = { createdAt: "desc" }) {
+    const take = limit + 1;
+    const findArgs = {
+      where,
+      take,
+      orderBy: withIdTieBreak(orderBy)
+    };
+    if (cursor) {
+      findArgs.cursor = { id: cursor };
+      findArgs.skip = 1;
+    }
+    const rows = await delegate.findMany(findArgs);
+    const hasMore = rows.length > limit;
+    const sliced = hasMore ? rows.slice(0, limit) : rows;
+    const items = sliced.map(mapFn);
+    const nextCursor = hasMore ? String(sliced[sliced.length - 1].id) : null;
+    return { items, nextCursor };
+  }
+  async function createOneCouponRow(tx, tenantId, data, maxAttempts) {
+    const baseCode = data.code ?? void 0;
+    const codeLength = data._codeLength ?? LIMITS.CODE_DEFAULT_LENGTH;
+    delete data._codeLength;
+    let lastError;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      const code = baseCode ?? cfg.codeGenerator({ length: codeLength });
+      sanitizeCode(code);
+      const row = { ...data, code: canonicalizeCode(code), tenantId };
+      try {
+        const created = await delegates.coupon(tx).create({ data: row });
+        return rowToCoupon(created);
+      } catch (err) {
+        lastError = err;
+        if (baseCode) {
+          throw new ValidationError(
+            `coupon code already exists in tenant`,
+            { prismaError: err instanceof Error ? err.message : String(err) },
+            { tenantId, couponCode: baseCode }
+          );
+        }
+      }
+    }
+    throw new ValidationError(
+      `failed to create coupon after ${maxAttempts} attempts (unique code collision)`,
+      { lastError: lastError instanceof Error ? lastError.message : String(lastError) },
+      { tenantId }
+    );
+  }
+  const coupons = {
+    async create(input) {
+      validateCreateCouponInput(input);
+      const tenantId = tid(input.tenantId);
+      const eligibility = assertEligibility(input.eligibility);
+      const metadata = assertMetadata(input.metadata);
+      const now = cfg.now();
+      const initialStatus = input.status ?? COUPON_STATUS.ACTIVE;
+      const coupon = await prisma.$transaction(async (tx) => {
+        const coupon2 = await createOneCouponRow(
+          tx,
+          tenantId,
+          {
+            id: cfg.idGenerator(),
+            code: input.code,
+            _codeLength: input.codeLength,
+            campaignId: input.campaignId ?? null,
+            status: initialStatus,
+            discount: w(input.discount),
+            startsAt: input.startsAt ?? null,
+            endsAt: input.endsAt ?? null,
+            maxRedemptions: input.maxRedemptions ?? null,
+            maxRedemptionsPerUser: input.maxRedemptionsPerUser ?? null,
+            eligibility: w(eligibility),
+            metadata: w(metadata ?? null)
+          },
+          1
+          // user-supplied code: no retry; generator: also fine with 1 here but default generator inherently retries below if needed
+        );
+        await writeAudit(delegates.couponAuditLog(tx), {
+          tenantId,
+          action: AUDIT_ACTION.COUPON_CREATED,
+          resourceId: coupon2.id,
+          resourceType: RESOURCE_TYPE.COUPON,
+          actorId: input.actorId,
+          details: { code: coupon2.code }
+        });
+        return coupon2;
+      });
+      await safeEmit(cfg.events, cfg.logger, {
+        type: "coupon.created",
+        at: now,
+        tenantId,
+        coupon
+      });
+      return coupon;
+    },
+    async issue(input) {
+      validateIssueCouponInput(input);
+      const tenantId = tid(input.tenantId);
+      const metadata = assertMetadata(input.metadata);
+      const now = cfg.now();
+      const issuance = await prisma.$transaction(async (tx) => {
+        const couponRow = await delegates.coupon(tx).findFirst({
+          where: { id: input.couponId, tenantId }
+        });
+        if (!couponRow) throw new CouponNotFoundError("Coupon not found", { tenantId, couponId: input.couponId });
+        const coupon = rowToCoupon(couponRow);
+        if (coupon.status === COUPON_STATUS.ARCHIVED) {
+          throw new CouponArchivedError(void 0, { tenantId, couponId: coupon.id });
+        }
+        const row = await delegates.couponIssuance(tx).create({
+          data: {
+            id: cfg.idGenerator(),
+            tenantId,
+            couponId: coupon.id,
+            issuedToUserId: input.issuedToUserId ?? null,
+            issuedBy: input.issuedBy ?? null,
+            metadata: w(metadata ?? null)
+          }
+        });
+        const issuance2 = rowToIssuance(row);
+        await writeAudit(delegates.couponAuditLog(tx), {
+          tenantId,
+          action: AUDIT_ACTION.COUPON_ISSUED,
+          resourceId: coupon.id,
+          resourceType: RESOURCE_TYPE.COUPON,
+          details: { issuanceId: issuance2.id, userId: issuance2.issuedToUserId }
+        });
+        return issuance2;
+      });
+      await safeEmit(cfg.events, cfg.logger, {
+        type: "coupon.issued",
+        at: now,
+        tenantId,
+        issuance
+      });
+      return issuance;
+    },
+    async issueBulk(input) {
+      validateIssueBulkInput(input);
+      const tenantId = tid(input.tenantId);
+      const eligibility = assertEligibility(input.eligibility);
+      const metadata = assertMetadata(input.metadata);
+      const now = cfg.now();
+      const maxAttempts = input.maxAttempts ?? LIMITS.BULK_DEFAULT_MAX_ATTEMPTS;
+      const codeLength = input.codeLength ?? LIMITS.CODE_DEFAULT_LENGTH;
+      const created = [];
+      const codes = [];
+      let skipped = 0;
+      let totalAttempts = 0;
+      await prisma.$transaction(async (tx) => {
+        for (let i = 0; i < input.count; i++) {
+          let placed = null;
+          for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+            totalAttempts++;
+            const code = cfg.codeGenerator({ length: codeLength });
+            try {
+              sanitizeCode(code);
+              const canonical = canonicalizeCode(code);
+              const row = await delegates.coupon(tx).create({
+                data: {
+                  id: cfg.idGenerator(),
+                  tenantId,
+                  code: canonical,
+                  campaignId: input.campaignId ?? null,
+                  status: COUPON_STATUS.ACTIVE,
+                  discount: w(input.discount),
+                  startsAt: input.startsAt ?? null,
+                  endsAt: input.endsAt ?? null,
+                  maxRedemptions: input.maxRedemptions ?? null,
+                  maxRedemptionsPerUser: input.maxRedemptionsPerUser ?? null,
+                  eligibility: w(eligibility),
+                  metadata: w(metadata ?? null)
+                }
+              });
+              placed = rowToCoupon(row);
+              break;
+            } catch (err) {
+              if (attempt === maxAttempts) {
+                skipped++;
+              }
+            }
+          }
+          if (placed) {
+            created.push(placed);
+            codes.push(placed.code);
+          }
+        }
+        if (created.length === 0 && input.count > 0) {
+          throw new ValidationError(
+            "bulk issuance failed: exhausted maxAttempts without any successful row"
+          );
+        }
+        if (input.campaignId && created.length > 0) {
+          const campRow = await delegates.campaign(tx).findFirst({
+            where: { id: input.campaignId, tenantId }
+          });
+          if (!campRow) {
+            throw new ValidationError("campaign not found", void 0, {
+              tenantId,
+              couponId: input.campaignId
+            });
+          }
+          const campaign = rowToCampaign(campRow);
+          if (campaign.status === CAMPAIGN_STATUS.CLOSED) {
+            throw new CampaignClosedError(void 0, {
+              tenantId,
+              couponId: campaign.id
+            });
+          }
+          const upd = await delegates.campaign(tx).updateMany({
+            where: {
+              id: input.campaignId,
+              tenantId,
+              status: { not: CAMPAIGN_STATUS.CLOSED },
+              // threshold: issuedCount <= maxCoupons - created.length
+              // (equivalent to "issuedCount + created.length <= maxCoupons").
+              // Omit the constraint entirely if maxCoupons is null (unbounded).
+              ...campaign.maxCoupons !== null ? { issuedCount: { lte: campaign.maxCoupons - created.length } } : {}
+            },
+            data: w({ issuedCount: { increment: created.length } })
+          });
+          if (upd.count === 0) {
+            const post = await delegates.campaign(tx).findFirst({
+              where: { id: input.campaignId, tenantId }
+            });
+            if (post) {
+              const after = rowToCampaign(post);
+              if (after.status === CAMPAIGN_STATUS.CLOSED) {
+                throw new CampaignClosedError(void 0, {
+                  tenantId,
+                  couponId: after.id
+                });
+              }
+            }
+            throw new CampaignCapacityExceededError(void 0, {
+              tenantId,
+              couponId: campaign.id
+            });
+          }
+        }
+        await writeAudit(delegates.couponAuditLog(tx), {
+          tenantId,
+          action: AUDIT_ACTION.COUPON_ISSUED_BULK,
+          resourceId: input.campaignId ?? null,
+          resourceType: RESOURCE_TYPE.CAMPAIGN,
+          actorId: input.actorId,
+          details: {
+            count: created.length,
+            skipped,
+            campaignId: input.campaignId ?? null
+          }
+        });
+      });
+      await safeEmit(cfg.events, cfg.logger, {
+        type: "coupon.issued.bulk",
+        at: now,
+        tenantId,
+        campaignId: input.campaignId,
+        count: created.length
+      });
+      return { created, skipped, codes, attempts: totalAttempts };
+    },
+    async findByCode(args) {
+      const tenantId = tid(args.tenantId);
+      sanitizeCode(args.code);
+      const canonical = canonicalizeCode(args.code);
+      const row = await delegates.coupon(prisma).findFirst({
+        where: { tenantId, code: canonical }
+      });
+      return row ? rowToCoupon(row) : null;
+    },
+    async get(args) {
+      const tenantId = tid(args.tenantId);
+      if (!args.id || typeof args.id !== "string") {
+        throw new ValidationError("id is required");
+      }
+      const row = await delegates.coupon(prisma).findFirst({
+        where: { id: args.id, tenantId }
+      });
+      return row ? rowToCoupon(row) : null;
+    },
+    async list(args) {
+      const tenantId = tid(args.tenantId);
+      const limit = assertPaginationLimit(args.limit);
+      const where = { tenantId };
+      if (args.campaignId) where.campaignId = args.campaignId;
+      if (args.status) where.status = args.status;
+      return paginate(
+        delegates.coupon(prisma),
+        where,
+        limit,
+        args.cursor,
+        rowToCoupon,
+        { createdAt: "desc" }
+      );
+    },
+    async pause(args) {
+      const tenantId = tid(args.tenantId);
+      const now = cfg.now();
+      const coupon = await prisma.$transaction(async (tx) => {
+        const row = await delegates.coupon(tx).findFirst({
+          where: { id: args.id, tenantId }
+        });
+        if (!row) throw new CouponNotFoundError("Coupon not found", { tenantId, couponId: args.id });
+        const existing = rowToCoupon(row);
+        if (existing.status === COUPON_STATUS.ARCHIVED) {
+          throw new CouponArchivedError(void 0, { tenantId, couponId: existing.id });
+        }
+        const updated = await delegates.coupon(tx).update({
+          where: { id: args.id },
+          data: { status: COUPON_STATUS.PAUSED }
+        });
+        await writeAudit(delegates.couponAuditLog(tx), {
+          tenantId,
+          action: AUDIT_ACTION.COUPON_PAUSED,
+          resourceId: args.id,
+          resourceType: RESOURCE_TYPE.COUPON,
+          actorId: args.actorId
+        });
+        return rowToCoupon(updated);
+      });
+      await safeEmit(cfg.events, cfg.logger, {
+        type: "coupon.paused",
+        at: now,
+        tenantId,
+        couponId: coupon.id
+      });
+      return coupon;
+    },
+    async resume(args) {
+      const tenantId = tid(args.tenantId);
+      const now = cfg.now();
+      const coupon = await prisma.$transaction(async (tx) => {
+        const row = await delegates.coupon(tx).findFirst({
+          where: { id: args.id, tenantId }
+        });
+        if (!row) throw new CouponNotFoundError("Coupon not found", { tenantId, couponId: args.id });
+        const existing = rowToCoupon(row);
+        if (existing.status === COUPON_STATUS.ARCHIVED) {
+          throw new CouponArchivedError(void 0, { tenantId, couponId: existing.id });
+        }
+        const updated = await delegates.coupon(tx).update({
+          where: { id: args.id },
+          data: { status: COUPON_STATUS.ACTIVE }
+        });
+        await writeAudit(delegates.couponAuditLog(tx), {
+          tenantId,
+          action: AUDIT_ACTION.COUPON_RESUMED,
+          resourceId: args.id,
+          resourceType: RESOURCE_TYPE.COUPON,
+          actorId: args.actorId
+        });
+        return rowToCoupon(updated);
+      });
+      await safeEmit(cfg.events, cfg.logger, {
+        type: "coupon.resumed",
+        at: now,
+        tenantId,
+        couponId: coupon.id
+      });
+      return coupon;
+    },
+    async archive(args) {
+      const tenantId = tid(args.tenantId);
+      const now = cfg.now();
+      const coupon = await prisma.$transaction(async (tx) => {
+        const row = await delegates.coupon(tx).findFirst({
+          where: { id: args.id, tenantId }
+        });
+        if (!row) throw new CouponNotFoundError("Coupon not found", { tenantId, couponId: args.id });
+        const existing = rowToCoupon(row);
+        if (existing.status === COUPON_STATUS.ARCHIVED) {
+          throw new CouponArchivedError(void 0, { tenantId, couponId: existing.id });
+        }
+        const updated = await delegates.coupon(tx).update({
+          where: { id: args.id },
+          data: { status: COUPON_STATUS.ARCHIVED }
+        });
+        await writeAudit(delegates.couponAuditLog(tx), {
+          tenantId,
+          action: AUDIT_ACTION.COUPON_ARCHIVED,
+          resourceId: args.id,
+          resourceType: RESOURCE_TYPE.COUPON,
+          actorId: args.actorId
+        });
+        return rowToCoupon(updated);
+      });
+      await safeEmit(cfg.events, cfg.logger, {
+        type: "coupon.archived",
+        at: now,
+        tenantId,
+        couponId: coupon.id
+      });
+      return coupon;
+    }
+  };
+  async function validate(input) {
+    validateValidateInput(input);
+    const tenantId = tid(input.tenantId);
+    sanitizeCode(input.code);
+    const canonical = canonicalizeCode(input.code);
+    const now = cfg.now();
+    return prisma.$transaction(async (tx) => {
+      const row = await delegates.coupon(tx).findFirst({
+        where: { tenantId, code: canonical }
+      });
+      if (!row) return { ok: false, reason: COUPON_REJECT_REASON.NOT_FOUND };
+      let coupon = rowToCoupon(row);
+      const lazy = await resolveLazyStatus(delegates, tx, coupon, now);
+      if (lazy.kind === "reject") {
+        return { ok: false, reason: COUPON_REJECT_REASON[lazy.reason] };
+      }
+      coupon = lazy.coupon;
+      const elig = checkEligibility({
+        rules: coupon.eligibility,
+        userId: input.userId ?? null,
+        context: input.context
+      });
+      if (!elig.ok) {
+        return { ok: false, reason: elig.reason };
+      }
+      if (coupon.maxRedemptionsPerUser !== null && input.userId) {
+        const count = await delegates.couponRedemption(tx).count({
+          where: {
+            tenantId,
+            couponId: coupon.id,
+            redeemedByUserId: input.userId
+          }
+        });
+        if (count >= coupon.maxRedemptionsPerUser) {
+          return { ok: false, reason: COUPON_REJECT_REASON.PER_USER_LIMIT };
+        }
+      }
+      let discountPreview = null;
+      if (typeof input.subtotal === "number" && typeof input.currency === "string") {
+        try {
+          discountPreview = calculate({
+            subtotal: input.subtotal,
+            currency: input.currency,
+            policy: coupon.discount
+          });
+        } catch (err) {
+          if (err instanceof MinimumOrderNotMetError) {
+            return { ok: false, reason: COUPON_REJECT_REASON.MIN_ORDER_NOT_MET };
+          }
+          throw err;
+        }
+      }
+      return { ok: true, coupon, discountPreview };
+    });
+  }
+  async function runRedeem(tx, input, tenantId, now) {
+    const canonical = canonicalizeCode(input.code);
+    const lookup = await delegates.coupon(tx).findFirst({
+      where: { tenantId, code: canonical },
+      select: { id: true }
+    });
+    if (!lookup) throw new CouponNotFoundError("Coupon not found", { tenantId, couponCode: canonical });
+    const couponId = String(lookup.id);
+    const locked = await lockCouponRow(
+      tx,
+      delegates.tables.coupon,
+      couponId,
+      tenantId
+    );
+    if (!Array.isArray(locked) || locked.length === 0) {
+      throw new CouponNotFoundError("Coupon not found", { tenantId, couponId });
+    }
+    let coupon = rowToCoupon(locked[0]);
+    if (coupon.status === COUPON_STATUS.ARCHIVED) {
+      throw new CouponArchivedError(void 0, { tenantId, couponId: coupon.id, couponCode: coupon.code });
+    }
+    if (coupon.status === COUPON_STATUS.PAUSED || coupon.status === COUPON_STATUS.DRAFT) {
+      throw new CouponInactiveError(void 0, { tenantId, couponId: coupon.id, couponCode: coupon.code });
+    }
+    if (coupon.startsAt && now.getTime() < coupon.startsAt.getTime()) {
+      throw new CouponExpiredError(
+        "Coupon has not started yet",
+        { tenantId, couponId: coupon.id, couponCode: coupon.code },
+        "NOT_STARTED"
+      );
+    }
+    if (coupon.endsAt && now.getTime() >= coupon.endsAt.getTime()) {
+      await delegates.coupon(tx).updateMany({
+        where: {
+          id: coupon.id,
+          tenantId,
+          status: { notIn: [COUPON_STATUS.ARCHIVED, COUPON_STATUS.EXPIRED] }
+        },
+        data: { status: COUPON_STATUS.EXPIRED }
+      });
+      throw new CouponExpiredError(void 0, {
+        tenantId,
+        couponId: coupon.id,
+        couponCode: coupon.code
+      });
+    }
+    const elig = checkEligibility({
+      rules: coupon.eligibility,
+      userId: input.userId ?? null,
+      context: input.context
+    });
+    if (!elig.ok) {
+      throw eligibilityReasonToError(elig.reason);
+    }
+    if (coupon.maxRedemptionsPerUser !== null && input.userId) {
+      const userCount = await delegates.couponRedemption(tx).count({
+        where: {
+          tenantId,
+          couponId: coupon.id,
+          redeemedByUserId: input.userId
+        }
+      });
+      if (userCount >= coupon.maxRedemptionsPerUser) {
+        throw new PerUserLimitExceededError(void 0, {
+          tenantId,
+          couponId: coupon.id,
+          couponCode: coupon.code
+        });
+      }
+    }
+    const discount = calculate({
+      subtotal: input.subtotal,
+      currency: input.currency,
+      policy: coupon.discount
+    });
+    const updWhere = {
+      id: coupon.id,
+      tenantId,
+      status: { notIn: [COUPON_STATUS.ARCHIVED, COUPON_STATUS.EXPIRED, COUPON_STATUS.EXHAUSTED, COUPON_STATUS.PAUSED, COUPON_STATUS.DRAFT] }
+    };
+    if (coupon.maxRedemptions !== null) {
+      updWhere.redeemedCount = { lt: coupon.maxRedemptions };
+    }
+    const upd = await delegates.coupon(tx).updateMany({
+      where: updWhere,
+      data: w({ redeemedCount: { increment: 1 } })
+    });
+    if (upd.count === 0) {
+      throw new CouponExhaustedError(void 0, {
+        tenantId,
+        couponId: coupon.id,
+        couponCode: coupon.code
+      });
+    }
+    const refreshed = await delegates.coupon(tx).findFirst({
+      where: { id: coupon.id, tenantId }
+    });
+    if (!refreshed) {
+      throw new CouponNotFoundError("Coupon vanished mid-transaction", { tenantId, couponId: coupon.id });
+    }
+    coupon = rowToCoupon(refreshed);
+    if (coupon.maxRedemptions !== null && coupon.redeemedCount >= coupon.maxRedemptions && coupon.status !== COUPON_STATUS.EXHAUSTED) {
+      await delegates.coupon(tx).updateMany({
+        where: {
+          id: coupon.id,
+          tenantId,
+          status: { notIn: [COUPON_STATUS.ARCHIVED, COUPON_STATUS.EXHAUSTED] }
+        },
+        data: { status: COUPON_STATUS.EXHAUSTED }
+      });
+      coupon = { ...coupon, status: COUPON_STATUS.EXHAUSTED };
+    }
+    let redemption;
+    try {
+      const inserted = await delegates.couponRedemption(tx).create({
+        data: {
+          id: cfg.idGenerator(),
+          tenantId,
+          couponId: coupon.id,
+          redeemedByUserId: input.userId ?? null,
+          orderRef: input.orderRef ?? null,
+          discountAmount: discount.discountAmount,
+          currency: input.currency,
+          metadata: w(input.metadata ?? null)
+        }
+      });
+      redemption = rowToRedemption(inserted);
+    } catch (err) {
+      throw new CouponAlreadyRedeemedError(void 0, {
+        tenantId,
+        couponId: coupon.id,
+        couponCode: coupon.code,
+        cause: err
+      });
+    }
+    if (coupon.maxRedemptionsPerUser !== null && input.userId) {
+      const userCountFinal = await delegates.couponRedemption(tx).count({
+        where: {
+          tenantId,
+          couponId: coupon.id,
+          redeemedByUserId: input.userId
+        }
+      });
+      if (userCountFinal > coupon.maxRedemptionsPerUser) {
+        throw new PerUserLimitExceededError(void 0, {
+          tenantId,
+          couponId: coupon.id,
+          couponCode: coupon.code
+        });
+      }
+    }
+    await writeAudit(delegates.couponAuditLog(tx), {
+      tenantId,
+      action: AUDIT_ACTION.COUPON_REDEEMED,
+      resourceId: coupon.id,
+      resourceType: RESOURCE_TYPE.COUPON,
+      actorId: input.userId ?? null,
+      details: {
+        redemptionId: redemption.id,
+        userId: redemption.redeemedByUserId,
+        orderRef: redemption.orderRef,
+        discountAmount: redemption.discountAmount,
+        currency: redemption.currency
+      }
+    });
+    return { redemption, coupon, discount };
+  }
+  async function redeem(input) {
+    validateRedeemInput(input);
+    const tenantId = tid(input.tenantId);
+    const now = cfg.now();
+    let result;
+    try {
+      if (input.tx) {
+        result = await runRedeem(input.tx, input, tenantId, now);
+      } else {
+        result = await prisma.$transaction((tx) => runRedeem(tx, input, tenantId, now));
+      }
+    } catch (err) {
+      if (err instanceof CouponError) {
+        try {
+          await delegates.couponAuditLog(prisma).create({
+            data: {
+              id: cfg.idGenerator(),
+              tenantId,
+              action: AUDIT_ACTION.COUPON_REDEEM_REJECTED,
+              resourceId: err.couponId ?? null,
+              resourceType: RESOURCE_TYPE.COUPON,
+              actorId: input.userId ?? null,
+              details: {
+                reason: err.code,
+                code: err.couponCode ?? canonicalizeCode(input.code),
+                userId: input.userId ?? null,
+                orderRef: input.orderRef ?? null
+              }
+            }
+          });
+        } catch (auditErr) {
+          cfg.logger.warn("coupon.redeem.rejected_audit_failed", {
+            error: auditErr instanceof Error ? auditErr.message : String(auditErr)
+          });
+        }
+        await safeEmit(cfg.events, cfg.logger, {
+          type: "coupon.redeem.rejected",
+          at: now,
+          tenantId,
+          code: canonicalizeCode(input.code),
+          reason: err.code,
+          userId: input.userId ?? null,
+          orderRef: input.orderRef ?? null
+        });
+      }
+      throw err;
+    }
+    await safeEmit(cfg.events, cfg.logger, {
+      type: "coupon.redeemed",
+      at: now,
+      tenantId,
+      redemption: result.redemption
+    });
+    return result;
+  }
+  const discountNs = {
+    calculate(input) {
+      return calculate(input);
+    }
+  };
+  const campaigns = {
+    async create(input) {
+      validateCreateCampaignInput(input);
+      const tenantId = tid(input.tenantId);
+      const eligibility = assertEligibility(input.eligibility);
+      const metadata = assertMetadata(input.metadata);
+      const now = cfg.now();
+      const campaign = await prisma.$transaction(async (tx) => {
+        const row = await delegates.campaign(tx).create({
+          data: {
+            id: cfg.idGenerator(),
+            tenantId,
+            name: input.name,
+            status: CAMPAIGN_STATUS.ACTIVE,
+            discount: w(input.discount),
+            eligibility: w(eligibility),
+            startsAt: input.startsAt ?? null,
+            endsAt: input.endsAt ?? null,
+            maxCoupons: input.maxCoupons ?? null,
+            metadata: w(metadata ?? null)
+          }
+        });
+        const campaign2 = rowToCampaign(row);
+        await writeAudit(delegates.couponAuditLog(tx), {
+          tenantId,
+          action: AUDIT_ACTION.CAMPAIGN_CREATED,
+          resourceId: campaign2.id,
+          resourceType: RESOURCE_TYPE.CAMPAIGN,
+          actorId: input.actorId,
+          details: { name: campaign2.name }
+        });
+        return campaign2;
+      });
+      await safeEmit(cfg.events, cfg.logger, {
+        type: "campaign.created",
+        at: now,
+        tenantId,
+        campaign
+      });
+      return campaign;
+    },
+    async get(args) {
+      const tenantId = tid(args.tenantId);
+      if (!args.id) throw new ValidationError("id is required");
+      const row = await delegates.campaign(prisma).findFirst({
+        where: { id: args.id, tenantId }
+      });
+      return row ? rowToCampaign(row) : null;
+    },
+    async list(args) {
+      const tenantId = tid(args.tenantId);
+      const limit = assertPaginationLimit(args.limit);
+      const where = { tenantId };
+      if (args.status) where.status = args.status;
+      return paginate(
+        delegates.campaign(prisma),
+        where,
+        limit,
+        args.cursor,
+        rowToCampaign,
+        { createdAt: "desc" }
+      );
+    },
+    async issue(args) {
+      if (!args || typeof args !== "object") throw new ValidationError("args required");
+      if (typeof args.campaignId !== "string" || !args.campaignId) {
+        throw new ValidationError("campaignId is required");
+      }
+      if (typeof args.count !== "number" || !Number.isInteger(args.count) || args.count <= 0 || args.count > LIMITS.BULK_MAX_COUNT) {
+        throw new ValidationError(
+          `count must be a positive integer <= ${LIMITS.BULK_MAX_COUNT}`
+        );
+      }
+      const tenantId = tid(args.tenantId);
+      const campRow = await delegates.campaign(prisma).findFirst({
+        where: { id: args.campaignId, tenantId }
+      });
+      if (!campRow) {
+        throw new ValidationError("campaign not found", void 0, {
+          tenantId,
+          couponId: args.campaignId
+        });
+      }
+      const campaign = rowToCampaign(campRow);
+      if (campaign.status === CAMPAIGN_STATUS.CLOSED) {
+        throw new CampaignClosedError(void 0, { tenantId, couponId: campaign.id });
+      }
+      return coupons.issueBulk({
+        tenantId,
+        count: args.count,
+        codeLength: args.codeLength,
+        campaignId: campaign.id,
+        discount: campaign.discount,
+        startsAt: campaign.startsAt,
+        endsAt: campaign.endsAt,
+        maxAttempts: args.maxAttempts,
+        eligibility: campaign.eligibility,
+        actorId: args.actorId
+      });
+    },
+    async summary(args) {
+      const tenantId = tid(args.tenantId);
+      if (!args.id) throw new ValidationError("id is required");
+      const campRow = await delegates.campaign(prisma).findFirst({
+        where: { id: args.id, tenantId }
+      });
+      if (!campRow) {
+        throw new ValidationError("campaign not found", void 0, {
+          tenantId,
+          couponId: args.id
+        });
+      }
+      const campaign = rowToCampaign(campRow);
+      const couponRows = await delegates.coupon(prisma).findMany({
+        where: { tenantId, campaignId: campaign.id }
+      });
+      const couponIds = couponRows.map((r) => String(r.id));
+      let redeemedCount = 0;
+      let totalDiscount = 0;
+      let lastRedeemedAt = null;
+      const uniqueUserSet = /* @__PURE__ */ new Set();
+      if (couponIds.length > 0) {
+        const reds = await delegates.couponRedemption(prisma).findMany({
+          where: { tenantId, couponId: { in: couponIds } }
+        });
+        redeemedCount = reds.length;
+        for (const r of reds) {
+          const row = r;
+          const amt = row.discountAmount;
+          if (typeof amt === "number") totalDiscount += amt;
+          const uid = row.redeemedByUserId;
+          if (typeof uid === "string" && uid.length > 0) uniqueUserSet.add(uid);
+          const ra = row.redeemedAt;
+          const raDate = ra instanceof Date ? ra : typeof ra === "string" || typeof ra === "number" ? new Date(ra) : null;
+          if (raDate && (!lastRedeemedAt || raDate.getTime() > lastRedeemedAt.getTime())) {
+            lastRedeemedAt = raDate;
+          }
+        }
+      }
+      const remaining = campaign.maxCoupons === null ? null : Math.max(campaign.maxCoupons - campaign.issuedCount, 0);
+      return {
+        id: campaign.id,
+        tenantId: campaign.tenantId,
+        name: campaign.name,
+        status: campaign.status,
+        issuedCount: campaign.issuedCount,
+        redeemedCount,
+        remaining,
+        totalDiscount,
+        uniqueUsers: uniqueUserSet.size,
+        lastRedeemedAt
+      };
+    },
+    async close(args) {
+      const tenantId = tid(args.tenantId);
+      if (!args.id) throw new ValidationError("id is required");
+      const now = cfg.now();
+      const campaign = await prisma.$transaction(async (tx) => {
+        const row = await delegates.campaign(tx).findFirst({
+          where: { id: args.id, tenantId }
+        });
+        if (!row) {
+          throw new ValidationError("campaign not found", void 0, {
+            tenantId,
+            couponId: args.id
+          });
+        }
+        const updated = await delegates.campaign(tx).update({
+          where: { id: args.id },
+          data: { status: CAMPAIGN_STATUS.CLOSED }
+        });
+        await writeAudit(delegates.couponAuditLog(tx), {
+          tenantId,
+          action: AUDIT_ACTION.CAMPAIGN_CLOSED,
+          resourceId: args.id,
+          resourceType: RESOURCE_TYPE.CAMPAIGN,
+          actorId: args.actorId
+        });
+        return rowToCampaign(updated);
+      });
+      await safeEmit(cfg.events, cfg.logger, {
+        type: "campaign.closed",
+        at: now,
+        tenantId,
+        campaignId: campaign.id
+      });
+      return campaign;
+    }
+  };
+  const audit = {
+    async listIssuances(args) {
+      const tenantId = tid(args.tenantId);
+      const limit = assertPaginationLimit(args.limit);
+      const where = { tenantId };
+      if (args.couponId) where.couponId = args.couponId;
+      if (args.issuedToUserId) where.issuedToUserId = args.issuedToUserId;
+      return paginate(
+        delegates.couponIssuance(prisma),
+        where,
+        limit,
+        args.cursor,
+        rowToIssuance,
+        { issuedAt: "desc" }
+      );
+    },
+    async listRedemptions(args) {
+      const tenantId = tid(args.tenantId);
+      const limit = assertPaginationLimit(args.limit);
+      const where = { tenantId };
+      if (args.couponId) where.couponId = args.couponId;
+      if (args.redeemedByUserId) where.redeemedByUserId = args.redeemedByUserId;
+      return paginate(
+        delegates.couponRedemption(prisma),
+        where,
+        limit,
+        args.cursor,
+        rowToRedemption,
+        { redeemedAt: "desc" }
+      );
+    },
+    async listLogs(args) {
+      const tenantId = tid(args.tenantId);
+      const limit = assertPaginationLimit(args.limit);
+      const where = { tenantId };
+      if (args.action) where.action = args.action;
+      if (args.resourceId) where.resourceId = args.resourceId;
+      if (args.resourceType) where.resourceType = args.resourceType;
+      return paginate(
+        delegates.couponAuditLog(prisma),
+        where,
+        limit,
+        args.cursor,
+        rowToAuditLog,
+        { createdAt: "desc" }
+      );
+    }
+  };
+  return {
+    coupons,
+    validate,
+    redeem,
+    discount: discountNs,
+    campaigns,
+    audit
+  };
+}
+
+exports.AUDIT_ACTION = AUDIT_ACTION;
+exports.CAMPAIGN_STATUS = CAMPAIGN_STATUS;
+exports.COUPON_REJECT_REASON = COUPON_REJECT_REASON;
+exports.COUPON_STATUS = COUPON_STATUS;
+exports.CampaignCapacityExceededError = CampaignCapacityExceededError;
+exports.CampaignClosedError = CampaignClosedError;
+exports.CouponAlreadyRedeemedError = CouponAlreadyRedeemedError;
+exports.CouponArchivedError = CouponArchivedError;
+exports.CouponError = CouponError;
+exports.CouponExhaustedError = CouponExhaustedError;
+exports.CouponExpiredError = CouponExpiredError;
+exports.CouponInactiveError = CouponInactiveError;
+exports.CouponNotFoundError = CouponNotFoundError;
+exports.CurrencyMismatchError = CurrencyMismatchError;
+exports.DEFAULT_MODEL_NAMES = DEFAULT_MODEL_NAMES;
+exports.IneligibleCategoryError = IneligibleCategoryError;
+exports.IneligiblePlanError = IneligiblePlanError;
+exports.IneligibleProductError = IneligibleProductError;
+exports.IneligibleUserError = IneligibleUserError;
+exports.InvalidDateRangeError = InvalidDateRangeError;
+exports.InvalidDiscountPolicyError = InvalidDiscountPolicyError;
+exports.InvalidModelNameError = InvalidModelNameError;
+exports.LIMITS = LIMITS;
+exports.MinimumOrderNotMetError = MinimumOrderNotMetError;
+exports.PerUserLimitExceededError = PerUserLimitExceededError;
+exports.TenantMismatchError = TenantMismatchError;
+exports.ValidationError = ValidationError;
+exports.calculateDiscount = calculate;
+exports.createCouponClient = createCouponClient;
+exports.validateDiscountPolicy = validateDiscountPolicy;