@krizaka/coupons 0.0.0-stage → 0.1.0

package/dist/chunk-ECCGFGSV.js

@@ -0,0 +1,940 @@
+import {
+  COUPON_ATTEMPT_ACTION,
+  COUPON_CODE,
+  COUPON_ERROR,
+  COUPON_STATUS,
+  CouponError,
+  KIND,
+  REDEMPTION_STATUS,
+  checkCoupon,
+  checkSettings,
+  countsAsUse,
+  effectOf,
+  generateCode,
+  normalizeCode,
+  refusalOf,
+  termsOf
+} from "./chunk-JMQO6PTK.js";
+
+// src/kernel.ts
+import { randomUUID } from "crypto";
+
+// src/events.ts
+import { createHash } from "crypto";
+var COUPONS_TOPIC = "coupons";
+var COUPON_EVENT = {
+  redeemed: "evt.coupon.redeemed.v1",
+  released: "evt.coupon.released.v1",
+  refunded: "evt.coupon.refunded.v1",
+  exhausted: "evt.coupon.exhausted.v1"
+};
+function uuidOf(seed) {
+  const h = createHash("sha256").update(`krizaka.coupons:${seed}`).digest();
+  h[6] = h[6] & 15 | 80;
+  h[8] = h[8] & 63 | 128;
+  const x = h.subarray(0, 16).toString("hex");
+  return `${x.slice(0, 8)}-${x.slice(8, 12)}-${x.slice(12, 16)}-${x.slice(16, 20)}-${x.slice(20, 32)}`;
+}
+var nullableString = { type: ["string", "null"] };
+var nullableInt = { type: ["integer", "null"] };
+var COUPON_EVENT_SCHEMAS = {
+  [COUPON_EVENT.redeemed]: {
+    type: "object",
+    additionalProperties: false,
+    required: ["redemptionId", "couponId", "kind", "purpose", "partnerId", "amountPaidMinor", "amountDiscountMinor", "currency", "credits", "overLimit"],
+    properties: {
+      redemptionId: { type: "string" },
+      couponId: { type: "string" },
+      kind: { enum: ["discount", "credit"] },
+      purpose: { enum: ["partner", "promo", "demo", "support"] },
+      partnerId: nullableString,
+      amountPaidMinor: nullableInt,
+      amountDiscountMinor: nullableInt,
+      currency: nullableString,
+      credits: nullableInt,
+      overLimit: { type: "boolean" }
+    }
+  },
+  [COUPON_EVENT.released]: { type: "object", additionalProperties: false, required: ["redemptionId", "couponId"], properties: { redemptionId: { type: "string" }, couponId: { type: "string" } } },
+  [COUPON_EVENT.refunded]: {
+    type: "object",
+    additionalProperties: false,
+    required: ["redemptionId", "couponId", "partnerId", "amountRefundedMinor", "currency", "useRestored"],
+    properties: { redemptionId: { type: "string" }, couponId: { type: "string" }, partnerId: nullableString, amountRefundedMinor: { type: "integer", minimum: 0 }, currency: nullableString, useRestored: { type: "boolean" } }
+  },
+  [COUPON_EVENT.exhausted]: { type: "object", additionalProperties: false, required: ["couponId", "partnerId"], properties: { couponId: { type: "string" }, partnerId: nullableString } }
+};
+
+// src/persistence.ts
+import { ident } from "@krizaka/db";
+var n = (v) => Number(v);
+var nOrNull = (v) => v === null || v === void 0 ? null : Number(v);
+var d = (v) => new Date(v);
+var dOrNull = (v) => v === null || v === void 0 ? null : new Date(v);
+var toCoupon = (r) => ({
+  id: r.id,
+  code: r.code,
+  codeKey: r.code_key,
+  kind: r.kind,
+  purpose: r.purpose,
+  partnerId: r.partner_id ?? null,
+  status: r.status,
+  startsAt: d(r.starts_at),
+  endsAt: dOrNull(r.ends_at),
+  maxRedemptions: nOrNull(r.max_redemptions),
+  maxPerAccount: n(r.max_per_account),
+  newCustomersOnly: r.new_customers_only,
+  plans: r.plans,
+  percentOffBp: nOrNull(r.percent_off_bp),
+  amountOffMinor: nOrNull(r.amount_off_minor),
+  currency: r.currency ?? null,
+  duration: r.duration ?? null,
+  durationMonths: nOrNull(r.duration_months),
+  minimumMinor: nOrNull(r.minimum_minor),
+  credits: nOrNull(r.credits),
+  capPerDay: nOrNull(r.cap_per_day),
+  capPerMonth: nOrNull(r.cap_per_month),
+  creditsValidDays: nOrNull(r.credits_valid_days),
+  onExhausted: r.on_exhausted ?? null,
+  termsVersion: n(r.terms_version),
+  createdAt: d(r.created_at),
+  createdBy: r.created_by ?? null,
+  updatedAt: d(r.updated_at)
+});
+var toPartner = (r) => ({
+  id: r.id,
+  displayName: r.display_name ?? null,
+  contactEmail: r.contact_email ?? null,
+  status: r.status,
+  createdAt: d(r.created_at),
+  createdBy: r.created_by ?? null,
+  erasedAt: dOrNull(r.erased_at)
+});
+var toRedemption = (r) => ({
+  id: r.id,
+  couponId: r.coupon_id,
+  accountId: r.account_id ?? null,
+  partnerId: r.partner_id ?? null,
+  status: r.status,
+  idempotencyKey: r.idempotency_key,
+  reservedUntil: dOrNull(r.reserved_until),
+  checkoutRef: r.checkout_ref ?? null,
+  paymentRef: r.payment_ref ?? null,
+  amountPaidMinor: nOrNull(r.amount_paid_minor),
+  amountDiscountMinor: nOrNull(r.amount_discount_minor),
+  amountRefundedMinor: n(r.amount_refunded_minor),
+  useRestored: r.use_restored,
+  currency: r.currency ?? null,
+  creditGrantId: r.credit_grant_id ?? null,
+  overLimit: r.over_limit,
+  createdAt: d(r.created_at),
+  confirmedAt: dOrNull(r.confirmed_at),
+  endedAt: dOrNull(r.ended_at)
+});
+var COUPON_COLUMNS = {
+  code: "code",
+  purpose: "purpose",
+  partnerId: "partner_id",
+  status: "status",
+  startsAt: "starts_at",
+  endsAt: "ends_at",
+  maxRedemptions: "max_redemptions",
+  maxPerAccount: "max_per_account",
+  newCustomersOnly: "new_customers_only",
+  plans: "plans",
+  percentOffBp: "percent_off_bp",
+  amountOffMinor: "amount_off_minor",
+  currency: "currency",
+  duration: "duration",
+  durationMonths: "duration_months",
+  minimumMinor: "minimum_minor",
+  credits: "credits",
+  capPerDay: "cap_per_day",
+  capPerMonth: "cap_per_month",
+  creditsValidDays: "credits_valid_days",
+  onExhausted: "on_exhausted",
+  termsVersion: "terms_version"
+};
+var REDEMPTION_COLUMNS = {
+  status: "status",
+  reservedUntil: "reserved_until",
+  checkoutRef: "checkout_ref",
+  paymentRef: "payment_ref",
+  amountPaidMinor: "amount_paid_minor",
+  amountDiscountMinor: "amount_discount_minor",
+  amountRefundedMinor: "amount_refunded_minor",
+  useRestored: "use_restored",
+  currency: "currency",
+  creditGrantId: "credit_grant_id",
+  overLimit: "over_limit",
+  confirmedAt: "confirmed_at",
+  endedAt: "ended_at"
+};
+var PARTNER_COLUMNS = { displayName: "display_name", contactEmail: "contact_email", status: "status", erasedAt: "erased_at" };
+function setClause(patch, columns, first) {
+  const keys = Object.keys(patch).filter((key) => patch[key] !== void 0 && key in columns);
+  return { sql: keys.map((key, i) => `${columns[key]} = $${first + i}`).join(", "), values: keys.map((key) => patch[key]) };
+}
+var COUNTS = `((status IN ('confirmed', 'revoked') AND NOT use_restored) OR (status = 'reserved' AND reserved_until > $NOW))`;
+function dbCouponStore(query, schema = "coupons") {
+  const s = ident(schema);
+  const coupon = `${s}.coupon`;
+  const partner = `${s}.partner`;
+  const redemption = `${s}.redemption`;
+  return {
+    async insertCoupon(c) {
+      try {
+        await query(
+          `INSERT INTO ${coupon} (id, code, code_key, kind, purpose, partner_id, status, starts_at, ends_at, max_redemptions, max_per_account, new_customers_only, plans, percent_off_bp, amount_off_minor, currency, duration, duration_months, minimum_minor, credits, cap_per_day, cap_per_month, credits_valid_days, on_exhausted, terms_version, created_at, created_by, updated_at)
+           VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18, $19, $20, $21, $22, $23, $24, $25, $26, $27, $28)`,
+          [c.id, c.code, c.codeKey, c.kind, c.purpose, c.partnerId, c.status, c.startsAt, c.endsAt, c.maxRedemptions, c.maxPerAccount, c.newCustomersOnly, c.plans, c.percentOffBp, c.amountOffMinor, c.currency, c.duration, c.durationMonths, c.minimumMinor, c.credits, c.capPerDay, c.capPerMonth, c.creditsValidDays, c.onExhausted, c.termsVersion, c.createdAt, c.createdBy, c.updatedAt]
+        );
+      } catch (error) {
+        if (error.code === "23505") throw new CouponError(COUPON_ERROR.codeTaken, "This code is already used");
+        throw error;
+      }
+    },
+    async couponById(id, forUpdate = false) {
+      const [row] = await query(`SELECT * FROM ${coupon} WHERE id = $1${forUpdate ? " FOR UPDATE" : ""}`, [id]);
+      return row ? toCoupon(row) : null;
+    },
+    async couponByKey(codeKey, forUpdate = false) {
+      const [row] = await query(`SELECT * FROM ${coupon} WHERE code_key = $1${forUpdate ? " FOR UPDATE" : ""}`, [codeKey]);
+      return row ? toCoupon(row) : null;
+    },
+    async updateCoupon(id, patch, at) {
+      const set = setClause(patch, COUPON_COLUMNS, 3);
+      const [row] = await query(`UPDATE ${coupon} SET ${set.sql ? `${set.sql}, ` : ""}updated_at = $2 WHERE id = $1 RETURNING *`, [id, at, ...set.values]);
+      return row ? toCoupon(row) : null;
+    },
+    async listCoupons(f) {
+      const rows = await query(
+        `SELECT * FROM ${coupon} WHERE ($1::text IS NULL OR status = $1) AND ($2::text IS NULL OR kind = $2) AND ($3::text IS NULL OR purpose = $3) AND ($4::uuid IS NULL OR partner_id = $4)
+          ORDER BY created_at DESC, id LIMIT $5 OFFSET $6`,
+        [f.status ?? null, f.kind ?? null, f.purpose ?? null, f.partnerId ?? null, f.limit, f.offset]
+      );
+      return rows.map(toCoupon);
+    },
+    async hasRedemptions(couponId) {
+      return (await query(`SELECT 1 FROM ${redemption} WHERE coupon_id = $1 LIMIT 1`, [couponId])).length > 0;
+    },
+    async insertPartner(p) {
+      await query(`INSERT INTO ${partner} (id, display_name, contact_email, status, created_at, created_by, erased_at) VALUES ($1, $2, $3, $4, $5, $6, $7)`, [p.id, p.displayName, p.contactEmail, p.status, p.createdAt, p.createdBy, p.erasedAt]);
+    },
+    async partnerById(id) {
+      const [row] = await query(`SELECT * FROM ${partner} WHERE id = $1`, [id]);
+      return row ? toPartner(row) : null;
+    },
+    async updatePartner(id, patch) {
+      const set = setClause(patch, PARTNER_COLUMNS, 2);
+      if (!set.sql) return await this.partnerById(id) ?? null;
+      const [row] = await query(`UPDATE ${partner} SET ${set.sql} WHERE id = $1 RETURNING *`, [id, ...set.values]);
+      return row ? toPartner(row) : null;
+    },
+    async listPartners(o) {
+      const rows = await query(`SELECT * FROM ${partner} WHERE ($1 OR status = 'active') ORDER BY created_at DESC, id LIMIT $2 OFFSET $3`, [o.includeArchived, o.limit, o.offset]);
+      return rows.map(toPartner);
+    },
+    async insertRedemption(r) {
+      await query(
+        `INSERT INTO ${redemption} (id, coupon_id, account_id, partner_id, status, idempotency_key, reserved_until, checkout_ref, payment_ref, amount_paid_minor, amount_discount_minor, amount_refunded_minor, use_restored, currency, credit_grant_id, over_limit, created_at, confirmed_at, ended_at)
+         VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18, $19)`,
+        [r.id, r.couponId, r.accountId, r.partnerId, r.status, r.idempotencyKey, r.reservedUntil, r.checkoutRef, r.paymentRef, r.amountPaidMinor, r.amountDiscountMinor, r.amountRefundedMinor, r.useRestored, r.currency, r.creditGrantId, r.overLimit, r.createdAt, r.confirmedAt, r.endedAt]
+      );
+    },
+    async redemptionById(id) {
+      const [row] = await query(`SELECT * FROM ${redemption} WHERE id = $1`, [id]);
+      return row ? toRedemption(row) : null;
+    },
+    async redemptionByKey(key) {
+      const [row] = await query(`SELECT * FROM ${redemption} WHERE idempotency_key = $1`, [key]);
+      return row ? toRedemption(row) : null;
+    },
+    async redemptionByCheckoutRef(ref) {
+      const [row] = await query(`SELECT * FROM ${redemption} WHERE checkout_ref = $1`, [ref]);
+      return row ? toRedemption(row) : null;
+    },
+    async redemptionByPaymentRef(ref) {
+      const [row] = await query(`SELECT * FROM ${redemption} WHERE payment_ref = $1`, [ref]);
+      return row ? toRedemption(row) : null;
+    },
+    async updateRedemption(id, from, patch) {
+      const set = setClause(patch, REDEMPTION_COLUMNS, 3);
+      const [row] = await query(`UPDATE ${redemption} SET ${set.sql} WHERE id = $1 AND ($2::text[] IS NULL OR status = ANY($2::text[])) RETURNING *`, [id, from ? [...from] : null, ...set.values]);
+      return row ? toRedemption(row) : null;
+    },
+    async usage(couponId, accountId, now) {
+      const counted = COUNTS.replaceAll("$NOW", () => "$3");
+      const [row] = await query(
+        `SELECT count(*) FILTER (WHERE ${counted})::int AS total, count(*) FILTER (WHERE ${counted} AND account_id = $2)::int AS account FROM ${redemption} WHERE coupon_id = $1`,
+        [couponId, accountId, now]
+      );
+      return { total: row?.total ?? 0, account: row?.account ?? 0 };
+    },
+    async listRedemptions(f) {
+      const rows = await query(
+        `SELECT r.* FROM ${redemption} r
+          WHERE ($1::uuid IS NULL OR r.coupon_id = $1) AND ($2::uuid IS NULL OR r.partner_id = $2) AND ($3::text IS NULL OR r.status = $3)
+            AND ($4::timestamptz IS NULL OR r.created_at >= $4) AND ($5::timestamptz IS NULL OR r.created_at < $5)
+          ORDER BY r.created_at DESC, r.id LIMIT $6 OFFSET $7`,
+        [f.couponId ?? null, f.partnerId ?? null, f.status ?? null, f.from ?? null, f.to ?? null, f.limit, f.offset]
+      );
+      return rows.map(toRedemption);
+    },
+    async releaseExpired(now, limit) {
+      const rows = await query(
+        `UPDATE ${redemption} SET status = 'released', reserved_until = NULL, ended_at = $1
+          WHERE id IN (SELECT id FROM ${redemption} WHERE status = 'reserved' AND reserved_until <= $1 ORDER BY reserved_until, id LIMIT $2 FOR UPDATE SKIP LOCKED)
+          RETURNING *`,
+        [now, limit]
+      );
+      return rows.map(toRedemption);
+    },
+    async partnerReport(partnerId, period, now) {
+      const rows = await query(
+        `SELECT c.id AS coupon_id, c.code, r.currency,
+                count(*)::int AS redemptions,
+                COALESCE(sum(r.amount_discount_minor), 0) AS discount,
+                COALESCE(sum(COALESCE(r.amount_paid_minor, 0) - r.amount_refunded_minor), 0) AS revenue,
+                COALESCE(sum(CASE WHEN c.kind = 'credit' THEN c.credits ELSE 0 END), 0) AS credits_granted
+           FROM ${redemption} r JOIN ${coupon} c ON c.id = r.coupon_id
+          WHERE r.partner_id = $1
+            AND ((r.status IN ('confirmed', 'revoked') AND NOT r.use_restored) OR (r.status = 'reserved' AND r.reserved_until > $2))
+            AND ($3::timestamptz IS NULL OR COALESCE(r.confirmed_at, r.created_at) >= $3) AND ($4::timestamptz IS NULL OR COALESCE(r.confirmed_at, r.created_at) < $4)
+          GROUP BY c.id, c.code, r.currency ORDER BY c.code, r.currency NULLS FIRST`,
+        [partnerId, now, period.from ?? null, period.to ?? null]
+      );
+      return rows.map((r) => ({ couponId: r.coupon_id, code: r.code, currency: r.currency ?? null, redemptions: n(r.redemptions), discountMinor: n(r.discount), revenueMinor: n(r.revenue), creditsGranted: n(r.credits_granted) }));
+    },
+    async activeAmountCoupons() {
+      return (await query(`SELECT * FROM ${coupon} WHERE status = 'active' AND amount_off_minor IS NOT NULL ORDER BY created_at, id`)).map(toCoupon);
+    }
+  };
+}
+
+// src/kernel.ts
+var SYSTEM = { id: null, label: "system" };
+function makeKernel(deps) {
+  const storeFor = deps.storeFor ?? ((query) => dbCouponStore(query, deps.schema ?? "coupons"));
+  return {
+    deps,
+    now: () => deps.clock.now(),
+    settings: async () => checkSettings(typeof deps.settings === "function" ? await deps.settings() : deps.settings),
+    store: storeFor,
+    newId: deps.newId ?? randomUUID,
+    record: (tx, actor, action, target, detail = {}) => deps.audit.record(tx, { actorId: actor.id, actorLabel: actor.label, action, target, detail }),
+    async announce(tx, type, seed, payload) {
+      await deps.outbox?.append(tx, { topic: COUPONS_TOPIC, type, payload, id: uuidOf(seed) });
+    }
+  };
+}
+
+// src/admin.ts
+var bad = (message) => new CouponError(COUPON_ERROR.badInput, message);
+var PAGE = 50;
+var MAX_PAGE = 200;
+var CODE_TRIES = 5;
+var TERMS = ["percentOffBp", "amountOffMinor", "currency", "duration", "durationMonths", "credits", "capPerDay", "capPerMonth", "creditsValidDays", "onExhausted"];
+var page = (limit, offset) => ({ limit: Math.min(Math.max(limit ?? PAGE, 1), MAX_PAGE), offset: Math.max(offset ?? 0, 0) });
+function makeAdmin(k) {
+  const must = async (found, code, what) => {
+    const value = await found;
+    if (!value) throw new CouponError(code, what);
+    return value;
+  };
+  const partnerOk = async (tx, partnerId) => {
+    if (partnerId) await must(k.store(tx).partnerById(partnerId), COUPON_ERROR.partnerNotFound, `No partner ${partnerId}`);
+  };
+  async function generateFreeCode(query) {
+    const length = (await k.settings()).generatedCodeLength;
+    for (let i = 0; i < CODE_TRIES; i += 1) {
+      const code = generateCode(length);
+      if (!await k.store(query).couponByKey(code)) return code;
+    }
+    throw bad("Could not find a free code, try again");
+  }
+  async function create(tx, actor, input) {
+    const settings = await k.settings();
+    checkCoupon(input, settings);
+    const codeKey = normalizeCode(input.code);
+    const store = k.store(tx);
+    if (await store.couponByKey(codeKey)) throw new CouponError(COUPON_ERROR.codeTaken, "This code is already used");
+    await partnerOk(tx, input.partnerId);
+    const now = k.now();
+    const coupon = {
+      id: k.newId(),
+      code: input.code.trim(),
+      codeKey,
+      kind: input.kind,
+      purpose: input.purpose,
+      partnerId: input.partnerId ?? null,
+      status: COUPON_STATUS.active,
+      startsAt: input.startsAt,
+      endsAt: input.endsAt ?? null,
+      maxRedemptions: input.maxRedemptions ?? null,
+      maxPerAccount: input.maxPerAccount ?? 1,
+      newCustomersOnly: input.newCustomersOnly ?? false,
+      plans: input.plans ?? [],
+      percentOffBp: input.percentOffBp ?? null,
+      amountOffMinor: input.amountOffMinor ?? null,
+      currency: input.currency ?? null,
+      duration: input.duration ?? null,
+      durationMonths: input.durationMonths ?? null,
+      minimumMinor: input.minimumMinor ?? null,
+      credits: input.credits ?? null,
+      capPerDay: input.capPerDay ?? null,
+      capPerMonth: input.capPerMonth ?? null,
+      creditsValidDays: input.creditsValidDays ?? null,
+      onExhausted: input.onExhausted ?? null,
+      termsVersion: 1,
+      createdAt: now,
+      createdBy: actor.id,
+      updatedAt: now
+    };
+    await store.insertCoupon(coupon);
+    await k.record(tx, actor, "coupon.created", { type: "coupon", id: coupon.id }, { code: coupon.code, kind: coupon.kind, purpose: coupon.purpose, partnerId: coupon.partnerId });
+    return coupon;
+  }
+  async function update(tx, actor, id, patch) {
+    const store = k.store(tx);
+    const before = await must(store.couponById(id, true), COUPON_ERROR.notFound, `No coupon ${id}`);
+    const changed = Object.keys(patch).filter((key) => patch[key] !== void 0 && JSON.stringify(patch[key]) !== JSON.stringify(before[key]));
+    if (changed.length === 0) return before;
+    if (changed.some((key) => TERMS.includes(key)) && await store.hasRedemptions(id)) throw new CouponError(COUPON_ERROR.termsLocked, "The terms of a coupon that has been used are locked: make a new coupon");
+    const next = { ...before, ...patch };
+    checkCoupon(next, await k.settings());
+    await partnerOk(tx, patch.partnerId);
+    const after = await store.updateCoupon(id, patch, k.now());
+    await k.record(tx, actor, "coupon.updated", { type: "coupon", id }, { changed, before: Object.fromEntries(changed.map((key) => [key, before[key]])), after: Object.fromEntries(changed.map((key) => [key, after[key]])) });
+    return after;
+  }
+  async function setStatus(tx, actor, id, status, action) {
+    const store = k.store(tx);
+    const before = await must(store.couponById(id, true), COUPON_ERROR.notFound, `No coupon ${id}`);
+    if (before.status === status) return before;
+    if (before.status === COUPON_STATUS.archived) throw bad("An archived coupon stays archived");
+    const after = await store.updateCoupon(id, { status }, k.now());
+    await k.record(tx, actor, action, { type: "coupon", id }, { from: before.status, to: status });
+    return after;
+  }
+  async function checkPrices(tx, prices) {
+    const { maxPercentOff } = await k.settings();
+    const paused = [];
+    for (const c of await k.store(tx).activeAmountCoupons()) {
+      const applicable = prices.filter((p) => p.currency === c.currency && (c.plans.length === 0 || c.plans.includes(p.plan)));
+      if (!applicable.some((p) => c.amountOffMinor * 100 > p.amountMinor * maxPercentOff)) continue;
+      await k.store(tx).updateCoupon(c.id, { status: COUPON_STATUS.paused }, k.now());
+      await k.record(tx, SYSTEM, "coupon.paused_by_price", { type: "coupon", id: c.id }, { maxPercentOff });
+      paused.push(c.id);
+    }
+    return paused;
+  }
+  async function createPartner(tx, actor, input) {
+    const name = input.displayName.trim();
+    const email = input.contactEmail?.trim().toLowerCase() || null;
+    if (name.length < 1 || name.length > 80) throw bad("A partner has a display name of 1 to 80 characters");
+    if (email !== null && !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email)) throw bad("A contact e-mail looks like a@b.c");
+    const partner = { id: k.newId(), displayName: name, contactEmail: email, status: "active", createdAt: k.now(), createdBy: actor.id, erasedAt: null };
+    await k.store(tx).insertPartner(partner);
+    await k.record(tx, actor, "partner.created", { type: "partner", id: partner.id }, {});
+    return partner;
+  }
+  async function setPartnerStatus(tx, actor, id, status) {
+    await must(k.store(tx).partnerById(id), COUPON_ERROR.partnerNotFound, `No partner ${id}`);
+    const after = await k.store(tx).updatePartner(id, { status });
+    await k.record(tx, actor, `partner.${status === "active" ? "restored" : "archived"}`, { type: "partner", id }, {});
+    return after;
+  }
+  async function erasePartner(tx, actor, id) {
+    const partner = await must(k.store(tx).partnerById(id), COUPON_ERROR.partnerNotFound, `No partner ${id}`);
+    if (partner.erasedAt) return partner;
+    const after = await k.store(tx).updatePartner(id, { displayName: null, contactEmail: null, status: "archived", erasedAt: k.now() });
+    await k.record(tx, actor, "partner.erased", { type: "partner", id }, {});
+    return after;
+  }
+  async function exportPartner(query, id) {
+    const partner = await must(k.store(query).partnerById(id), COUPON_ERROR.partnerNotFound, `No partner ${id}`);
+    return { partner, rows: await k.store(query).partnerReport(id, {}, k.now()) };
+  }
+  async function partnerReport(tx, actor, id, period = {}) {
+    await must(k.store(tx).partnerById(id), COUPON_ERROR.partnerNotFound, `No partner ${id}`);
+    await k.record(tx, actor, "partner.report_read", { type: "partner", id }, {});
+    return k.store(tx).partnerReport(id, period, k.now());
+  }
+  return {
+    generateCode: generateFreeCode,
+    create,
+    update,
+    pause: (tx, actor, id) => setStatus(tx, actor, id, COUPON_STATUS.paused, "coupon.paused"),
+    resume: (tx, actor, id) => setStatus(tx, actor, id, COUPON_STATUS.active, "coupon.resumed"),
+    archive: (tx, actor, id) => setStatus(tx, actor, id, COUPON_STATUS.archived, "coupon.archived"),
+    get: (query, id) => k.store(query).couponById(id),
+    list: (query, filter = {}) => k.store(query).listCoupons({ ...filter, ...page(filter.limit, filter.offset) }),
+    redemptions: (query, filter = {}) => k.store(query).listRedemptions({ ...filter, ...page(filter.limit, filter.offset) }),
+    checkPrices,
+    partners: {
+      create: createPartner,
+      archive: (tx, actor, id) => setPartnerStatus(tx, actor, id, "archived"),
+      restore: (tx, actor, id) => setPartnerStatus(tx, actor, id, "active"),
+      erase: erasePartner,
+      get: (query, id) => k.store(query).partnerById(id),
+      list: (query, options = {}) => k.store(query).listPartners({ includeArchived: options.includeArchived ?? false, ...page(options.limit, options.offset) }),
+      export: exportPartner,
+      report: partnerReport
+    }
+  };
+}
+
+// src/flows.ts
+import { addHours, addMinutes } from "@krizaka/time";
+var view = (c) => ({ id: c.id, code: c.code, kind: c.kind, purpose: c.purpose, endsAt: c.endsAt });
+var REFUSALS = Object.values(COUPON_CODE);
+var isRefusal = (code) => REFUSALS.includes(code);
+var refuse = (code, retryAfterSeconds) => new CouponError(code, code, retryAfterSeconds);
+var ATTACH_GRACE_MINUTES = 5;
+var SWEEP_BATCH = 500;
+function makeFlows(k) {
+  async function attempt(ctx) {
+    const r = await k.deps.rateLimit.check(COUPON_ATTEMPT_ACTION, { ip: ctx.ip, subject: ctx.accountId });
+    if (!r.ok) throw refuse(COUPON_CODE.rateLimited, r.retryAfterSeconds);
+  }
+  async function lookup(tx, code, forUpdate) {
+    const key = normalizeCode(code);
+    const coupon = key ? await k.store(tx).couponByKey(key, forUpdate) : null;
+    if (!coupon) throw refuse(COUPON_CODE.unknown);
+    return coupon;
+  }
+  async function check(tx, coupon, ctx) {
+    const settings = await k.settings();
+    const now = k.now();
+    const usage = await k.store(tx).usage(coupon.id, ctx.accountId, now);
+    const refusal = refusalOf(coupon, ctx, usage, now, settings);
+    if (refusal) throw refuse(refusal);
+  }
+  const mustBeEnabled = async () => {
+    if (!(await k.settings()).enabled) throw refuse(COUPON_CODE.disabled);
+  };
+  const needsAmount = (ctx) => {
+    if (ctx.mode === "checkout" && (ctx.plan === void 0 || ctx.amountMinor === void 0 || ctx.currency === void 0)) {
+      throw new CouponError(COUPON_ERROR.badInput, "A checkout names its plan, amount and currency");
+    }
+  };
+  async function validate(query, code, ctx) {
+    try {
+      await mustBeEnabled();
+      needsAmount(ctx);
+      await attempt(ctx);
+      const coupon = await lookup(query, code, false);
+      await check(query, coupon, ctx);
+      return { ok: true, coupon: view(coupon), effect: effectOf(coupon, ctx.amountMinor ?? 0) };
+    } catch (error) {
+      if (error instanceof CouponError && isRefusal(error.code)) return { ok: false, code: error.code, ...error.retryAfterSeconds === void 0 ? {} : { retryAfterSeconds: error.retryAfterSeconds } };
+      throw error;
+    }
+  }
+  async function apply(tx, input) {
+    const ctx = { ...input, mode: "checkout" };
+    await mustBeEnabled();
+    needsAmount(ctx);
+    await attempt(ctx);
+    const coupon = await lookup(tx, input.code, true);
+    const store = k.store(tx);
+    const known = await store.redemptionByKey(input.idempotencyKey);
+    if (known) {
+      if (known.couponId !== coupon.id || known.accountId !== input.accountId) throw new CouponError(COUPON_ERROR.keyReused, "This idempotency key was used for another coupon or account");
+      return { redemptionId: known.id, discount: termsOf(coupon), effect: effectOf(coupon, input.amountMinor), reservedUntil: known.reservedUntil ?? known.createdAt, replayed: true };
+    }
+    await check(tx, coupon, ctx);
+    const now = k.now();
+    const reservedUntil = addMinutes(now, (await k.settings()).reservationMinutes);
+    const redemption = {
+      id: k.newId(),
+      couponId: coupon.id,
+      accountId: input.accountId,
+      partnerId: coupon.partnerId,
+      status: REDEMPTION_STATUS.reserved,
+      idempotencyKey: input.idempotencyKey,
+      reservedUntil,
+      checkoutRef: null,
+      paymentRef: null,
+      amountPaidMinor: null,
+      amountDiscountMinor: null,
+      amountRefundedMinor: 0,
+      useRestored: false,
+      currency: input.currency ?? null,
+      creditGrantId: null,
+      overLimit: false,
+      createdAt: now,
+      confirmedAt: null,
+      endedAt: null
+    };
+    await store.insertRedemption(redemption);
+    return { redemptionId: redemption.id, discount: termsOf(coupon), effect: effectOf(coupon, input.amountMinor), reservedUntil, replayed: false };
+  }
+  async function attachCheckout(tx, redemptionId, checkoutRef, sessionExpiresAt) {
+    const store = k.store(tx);
+    const r = await store.redemptionById(redemptionId);
+    if (!r) throw new CouponError(COUPON_ERROR.redemptionNotFound, `No redemption ${redemptionId}`);
+    await store.updateRedemption(redemptionId, null, { checkoutRef });
+    if (r.status !== REDEMPTION_STATUS.reserved || !sessionExpiresAt) return;
+    const wanted = addMinutes(sessionExpiresAt, ATTACH_GRACE_MINUTES);
+    if (!r.reservedUntil || wanted > r.reservedUntil) await store.updateRedemption(redemptionId, [REDEMPTION_STATUS.reserved], { reservedUntil: wanted });
+  }
+  async function findFor(tx, ref) {
+    const store = k.store(tx);
+    return (ref.redemptionId ? await store.redemptionById(ref.redemptionId) : null) ?? (ref.checkoutRef ? await store.redemptionByCheckoutRef(ref.checkoutRef) : null);
+  }
+  async function redeem(tx, input) {
+    const store = k.store(tx);
+    const found = await findFor(tx, input);
+    if (!found) return "unknown";
+    const coupon = await store.couponById(found.couponId, true);
+    const r = await store.redemptionById(found.id);
+    const withRef = input.paymentRef ? await store.redemptionByPaymentRef(input.paymentRef) : null;
+    if (withRef || r.status !== REDEMPTION_STATUS.reserved && r.status !== REDEMPTION_STATUS.released) return "already";
+    const now = k.now();
+    const others = (await store.usage(coupon.id, null, now)).total - (countsAsUse(r, now) ? 1 : 0);
+    const late = r.status === REDEMPTION_STATUS.released;
+    const overLimit = late || coupon.maxRedemptions !== null && others + 1 > coupon.maxRedemptions;
+    const done = await store.updateRedemption(r.id, [REDEMPTION_STATUS.reserved, REDEMPTION_STATUS.released], {
+      status: REDEMPTION_STATUS.confirmed,
+      paymentRef: input.paymentRef,
+      amountPaidMinor: input.amountPaidMinor,
+      amountDiscountMinor: input.amountDiscountMinor,
+      currency: input.currency ?? r.currency,
+      reservedUntil: null,
+      confirmedAt: now,
+      endedAt: null,
+      overLimit
+    });
+    if (!done) return "already";
+    await confirmed(tx, coupon, done, others + 1);
+    return "confirmed";
+  }
+  async function confirmed(tx, coupon, r, usesNow) {
+    await k.record(tx, SYSTEM, "coupon.redeemed", { type: "coupon", id: coupon.id }, { redemptionId: r.id, kind: coupon.kind, overLimit: r.overLimit, amountPaidMinor: r.amountPaidMinor, amountDiscountMinor: r.amountDiscountMinor });
+    await k.announce(tx, COUPON_EVENT.redeemed, `redeemed:${r.id}`, {
+      redemptionId: r.id,
+      couponId: coupon.id,
+      kind: coupon.kind,
+      purpose: coupon.purpose,
+      partnerId: r.partnerId,
+      amountPaidMinor: r.amountPaidMinor,
+      amountDiscountMinor: r.amountDiscountMinor,
+      currency: r.currency,
+      credits: coupon.kind === KIND.credit ? coupon.credits : null,
+      overLimit: r.overLimit
+    });
+    if (coupon.maxRedemptions !== null && usesNow === coupon.maxRedemptions) await k.announce(tx, COUPON_EVENT.exhausted, `exhausted:${coupon.id}`, { couponId: coupon.id, partnerId: coupon.partnerId });
+  }
+  async function release(tx, ref) {
+    const found = await findFor(tx, ref);
+    if (!found) return false;
+    const done = await k.store(tx).updateRedemption(found.id, [REDEMPTION_STATUS.reserved], { status: REDEMPTION_STATUS.released, reservedUntil: null, endedAt: k.now() });
+    if (!done) return false;
+    await k.announce(tx, COUPON_EVENT.released, `released:${done.id}`, { redemptionId: done.id, couponId: done.couponId });
+    return true;
+  }
+  async function releaseExpired(tx) {
+    const released = await k.store(tx).releaseExpired(k.now(), SWEEP_BATCH);
+    for (const r of released) await k.announce(tx, COUPON_EVENT.released, `released:${r.id}`, { redemptionId: r.id, couponId: r.couponId });
+    return released.length;
+  }
+  async function refund(tx, input) {
+    const store = k.store(tx);
+    const r = (input.paymentRef ? await store.redemptionByPaymentRef(input.paymentRef) : null) ?? (input.invoiceRef ? await store.redemptionByPaymentRef(input.invoiceRef) : null);
+    if (!r) return "unknown";
+    const total = Math.max(r.amountRefundedMinor, input.amountRefunded);
+    if (total === r.amountRefundedMinor) return "already";
+    const full = r.amountPaidMinor !== null && r.amountPaidMinor > 0 && total >= r.amountPaidMinor;
+    const restore = full && (await k.settings()).refundRestoresUse && !r.useRestored;
+    const done = await store.updateRedemption(r.id, null, { amountRefundedMinor: total, ...restore ? { useRestored: true } : {} });
+    await k.record(tx, SYSTEM, "coupon.refunded", { type: "coupon", id: r.couponId }, { redemptionId: r.id, amountRefundedMinor: total, useRestored: done.useRestored });
+    await k.announce(tx, COUPON_EVENT.refunded, `refunded:${r.id}:${total}`, { redemptionId: r.id, couponId: r.couponId, partnerId: r.partnerId, amountRefundedMinor: total, currency: r.currency, useRestored: done.useRestored });
+    return "refunded";
+  }
+  async function redeemCredit(tx, input) {
+    const credits = k.deps.credits;
+    if (!credits) throw new CouponError(COUPON_ERROR.badSettings, "Credit coupons need the credits ledger in the module's dependencies");
+    await mustBeEnabled();
+    await attempt(input);
+    const coupon = await lookup(tx, input.code, true);
+    const store = k.store(tx);
+    const known = await store.redemptionByKey(input.idempotencyKey);
+    if (known) return replayOf(known, coupon, input.accountId);
+    await check(tx, coupon, { mode: "redeem", accountId: input.accountId, ...input.hasPaidBefore === void 0 ? {} : { hasPaidBefore: input.hasPaidBefore } });
+    const now = k.now();
+    const expiresAt = addHours(now, coupon.creditsValidDays * 24);
+    const redemption = {
+      id: k.newId(),
+      couponId: coupon.id,
+      accountId: input.accountId,
+      partnerId: coupon.partnerId,
+      status: REDEMPTION_STATUS.confirmed,
+      idempotencyKey: input.idempotencyKey,
+      reservedUntil: null,
+      checkoutRef: null,
+      paymentRef: null,
+      amountPaidMinor: null,
+      amountDiscountMinor: null,
+      amountRefundedMinor: 0,
+      useRestored: false,
+      currency: null,
+      creditGrantId: null,
+      overLimit: false,
+      createdAt: now,
+      confirmedAt: now,
+      endedAt: null
+    };
+    await store.insertRedemption(redemption);
+    const { grantId } = await credits.grant(tx, { accountId: input.accountId, amount: coupon.credits, capPerDay: coupon.capPerDay, capPerMonth: coupon.capPerMonth, expiresAt, onExhausted: coupon.onExhausted, source: `coupon:${redemption.id}`, idempotencyKey: `coupon-${redemption.id}` });
+    const done = await store.updateRedemption(redemption.id, null, { creditGrantId: grantId });
+    await confirmed(tx, coupon, done, (await store.usage(coupon.id, null, now)).total);
+    return { redemptionId: done.id, grantId, credits: coupon.credits, expiresAt, replayed: false };
+  }
+  function replayOf(known, coupon, accountId) {
+    if (known.couponId !== coupon.id || known.accountId !== accountId || !known.creditGrantId) throw new CouponError(COUPON_ERROR.keyReused, "This idempotency key was used for another coupon or account");
+    return { redemptionId: known.id, grantId: known.creditGrantId, credits: coupon.credits, expiresAt: addHours(known.createdAt, coupon.creditsValidDays * 24), replayed: true };
+  }
+  async function revoke(tx, actor, redemptionId) {
+    const store = k.store(tx);
+    const r = await store.redemptionById(redemptionId);
+    if (!r) throw new CouponError(COUPON_ERROR.redemptionNotFound, `No redemption ${redemptionId}`);
+    if (r.status === REDEMPTION_STATUS.revoked) return;
+    if (r.status !== REDEMPTION_STATUS.confirmed || !r.creditGrantId || !k.deps.credits) throw new CouponError(COUPON_ERROR.notRevocable, "Only a confirmed credit redemption can be revoked");
+    await store.couponById(r.couponId, true);
+    const done = await store.updateRedemption(r.id, [REDEMPTION_STATUS.confirmed], { status: REDEMPTION_STATUS.revoked, endedAt: k.now() });
+    if (!done) return;
+    const { expired } = await k.deps.credits.expire(tx, r.creditGrantId);
+    await k.record(tx, actor, "coupon.revoked", { type: "coupon", id: r.couponId }, { redemptionId: r.id, creditsWrittenOff: expired });
+  }
+  return { validate, apply, attachCheckout, redeem, release, releaseExpired, refund, redeemCredit, revoke };
+}
+
+// src/coupons.ts
+function createCoupons(deps) {
+  const kernel = makeKernel(deps);
+  return { ...makeFlows(kernel), admin: makeAdmin(kernel) };
+}
+
+// src/memory.ts
+var PARTNER_ACTIVE = "active";
+var clone = (v) => ({ ...v });
+function memoryCouponStore() {
+  const coupons = /* @__PURE__ */ new Map();
+  const partners = /* @__PURE__ */ new Map();
+  const redemptions = /* @__PURE__ */ new Map();
+  const unique = (field, value, except) => {
+    if (value !== null && [...redemptions.values()].some((r) => r.id !== except && r[field] === value)) throw new Error(`duplicate ${field}`);
+  };
+  const page2 = (rows, limit, offset) => rows.slice(offset, offset + limit);
+  const newestFirst = (rows) => rows.sort((a, b) => b.createdAt.valueOf() - a.createdAt.valueOf() || a.id.localeCompare(b.id));
+  return {
+    async insertCoupon(c) {
+      if ([...coupons.values()].some((x) => x.codeKey === c.codeKey)) throw Object.assign(new Error("duplicate code_key"), { code: "23505" });
+      coupons.set(c.id, clone(c));
+    },
+    async couponById(id) {
+      const c = coupons.get(id);
+      return c ? clone(c) : null;
+    },
+    async couponByKey(codeKey) {
+      const c = [...coupons.values()].find((x) => x.codeKey === codeKey);
+      return c ? clone(c) : null;
+    },
+    async updateCoupon(id, patch, at) {
+      const c = coupons.get(id);
+      if (!c) return null;
+      for (const [key, value] of Object.entries(patch)) if (value !== void 0) c[key] = value;
+      c.updatedAt = at;
+      return clone(c);
+    },
+    async listCoupons(f) {
+      const rows = [...coupons.values()].filter((c) => (!f.status || c.status === f.status) && (!f.kind || c.kind === f.kind) && (!f.purpose || c.purpose === f.purpose) && (!f.partnerId || c.partnerId === f.partnerId));
+      return page2(newestFirst(rows), f.limit, f.offset).map(clone);
+    },
+    async hasRedemptions(couponId) {
+      return [...redemptions.values()].some((r) => r.couponId === couponId);
+    },
+    async insertPartner(p) {
+      partners.set(p.id, clone(p));
+    },
+    async partnerById(id) {
+      const p = partners.get(id);
+      return p ? clone(p) : null;
+    },
+    async updatePartner(id, patch) {
+      const p = partners.get(id);
+      if (!p) return null;
+      for (const [key, value] of Object.entries(patch)) if (value !== void 0) p[key] = value;
+      return clone(p);
+    },
+    async listPartners(o) {
+      return page2(newestFirst([...partners.values()].filter((p) => o.includeArchived || p.status === PARTNER_ACTIVE)), o.limit, o.offset).map(clone);
+    },
+    async insertRedemption(r) {
+      unique("idempotencyKey", r.idempotencyKey, r.id);
+      unique("checkoutRef", r.checkoutRef, r.id);
+      unique("paymentRef", r.paymentRef, r.id);
+      redemptions.set(r.id, clone(r));
+    },
+    async redemptionById(id) {
+      const r = redemptions.get(id);
+      return r ? clone(r) : null;
+    },
+    async redemptionByKey(key) {
+      const r = [...redemptions.values()].find((x) => x.idempotencyKey === key);
+      return r ? clone(r) : null;
+    },
+    async redemptionByCheckoutRef(ref) {
+      const r = [...redemptions.values()].find((x) => x.checkoutRef === ref);
+      return r ? clone(r) : null;
+    },
+    async redemptionByPaymentRef(ref) {
+      const r = [...redemptions.values()].find((x) => x.paymentRef === ref);
+      return r ? clone(r) : null;
+    },
+    async updateRedemption(id, from, patch) {
+      const r = redemptions.get(id);
+      if (!r || from && !from.includes(r.status)) return null;
+      unique("checkoutRef", patch.checkoutRef ?? null, id);
+      unique("paymentRef", patch.paymentRef ?? null, id);
+      for (const [key, value] of Object.entries(patch)) if (value !== void 0) r[key] = value;
+      return clone(r);
+    },
+    async usage(couponId, accountId, now) {
+      const live = [...redemptions.values()].filter((r) => r.couponId === couponId && countsAsUse(r, now));
+      return { total: live.length, account: accountId === null ? 0 : live.filter((r) => r.accountId === accountId).length };
+    },
+    async listRedemptions(f) {
+      const rows = [...redemptions.values()].filter((r) => (!f.couponId || r.couponId === f.couponId) && (!f.partnerId || r.partnerId === f.partnerId) && (!f.status || r.status === f.status) && (!f.from || r.createdAt >= f.from) && (!f.to || r.createdAt < f.to));
+      return page2(newestFirst(rows), f.limit, f.offset).map(clone);
+    },
+    async releaseExpired(now, limit) {
+      const due = [...redemptions.values()].filter((r) => r.status === REDEMPTION_STATUS.reserved && r.reservedUntil !== null && r.reservedUntil <= now).sort((a, b) => a.reservedUntil.valueOf() - b.reservedUntil.valueOf() || a.id.localeCompare(b.id)).slice(0, limit);
+      for (const r of due) Object.assign(r, { status: REDEMPTION_STATUS.released, reservedUntil: null, endedAt: now });
+      return due.map(clone);
+    },
+    async partnerReport(partnerId, period, now) {
+      const rows = /* @__PURE__ */ new Map();
+      for (const r of redemptions.values()) {
+        const at = r.confirmedAt ?? r.createdAt;
+        if (r.partnerId !== partnerId || !countsAsUse(r, now) || period.from && at < period.from || period.to && at >= period.to) continue;
+        const c = coupons.get(r.couponId);
+        const key = `${c.id}|${r.currency ?? ""}`;
+        const row = rows.get(key) ?? { couponId: c.id, code: c.code, currency: r.currency, redemptions: 0, discountMinor: 0, revenueMinor: 0, creditsGranted: 0 };
+        row.redemptions += 1;
+        row.discountMinor += r.amountDiscountMinor ?? 0;
+        row.revenueMinor += (r.amountPaidMinor ?? 0) - r.amountRefundedMinor;
+        row.creditsGranted += c.kind === KIND.credit ? c.credits ?? 0 : 0;
+        rows.set(key, row);
+      }
+      return [...rows.values()].sort((a, b) => a.code.localeCompare(b.code) || (a.currency ?? "").localeCompare(b.currency ?? ""));
+    },
+    async activeAmountCoupons() {
+      return [...coupons.values()].filter((c) => c.status === COUPON_STATUS.active && c.amountOffMinor !== null).sort((a, b) => a.createdAt.valueOf() - b.createdAt.valueOf() || a.id.localeCompare(b.id)).map(clone);
+    }
+  };
+}
+
+// src/schema.ts
+import { defineModule } from "@krizaka/db";
+var couponsSchema = defineModule({
+  module: "coupons",
+  tables: ["owner"],
+  migrations: [
+    {
+      version: 1,
+      name: "partners, coupons and redemptions",
+      sql: (c) => `
+CREATE TABLE ${c.schema}.partner (
+  id            uuid PRIMARY KEY,
+  display_name  text CHECK (display_name IS NULL OR char_length(display_name) BETWEEN 1 AND 80),
+  contact_email text CHECK (contact_email IS NULL OR contact_email = lower(contact_email)),
+  status        text NOT NULL DEFAULT 'active' CHECK (status IN ('active', 'archived')),
+  created_at    timestamptz NOT NULL,
+  created_by    uuid REFERENCES ${c.tables.owner}(id) ON DELETE SET NULL,
+  erased_at     timestamptz,
+  CHECK (erased_at IS NOT NULL OR display_name IS NOT NULL),
+  CHECK (erased_at IS NULL OR (display_name IS NULL AND contact_email IS NULL))
+);
+CREATE TABLE ${c.schema}.coupon (
+  id                 uuid PRIMARY KEY,
+  code               text NOT NULL CHECK (char_length(code) BETWEEN 4 AND 60),
+  code_key           text NOT NULL UNIQUE CHECK (code_key = upper(code_key) AND char_length(code_key) BETWEEN 4 AND 40),
+  kind               text NOT NULL CHECK (kind IN ('discount', 'credit')),
+  purpose            text NOT NULL CHECK (purpose IN ('partner', 'promo', 'demo', 'support')),
+  partner_id         uuid REFERENCES ${c.schema}.partner(id) ON DELETE RESTRICT,
+  status             text NOT NULL DEFAULT 'active' CHECK (status IN ('active', 'paused', 'archived')),
+  starts_at          timestamptz NOT NULL,
+  ends_at            timestamptz,
+  max_redemptions    integer CHECK (max_redemptions > 0),
+  max_per_account    integer NOT NULL DEFAULT 1 CHECK (max_per_account > 0),
+  new_customers_only boolean NOT NULL DEFAULT false,
+  plans              text[] NOT NULL DEFAULT '{}',
+  percent_off_bp     integer CHECK (percent_off_bp BETWEEN 1 AND 9999),
+  amount_off_minor   integer CHECK (amount_off_minor > 0),
+  currency           text CHECK (currency ~ '^[a-z]{3}$'),
+  duration           text CHECK (duration IN ('once', 'repeating', 'forever')),
+  duration_months    integer CHECK (duration_months BETWEEN 1 AND 36),
+  minimum_minor      integer CHECK (minimum_minor >= 0),
+  credits            integer CHECK (credits > 0),
+  cap_per_day        integer CHECK (cap_per_day > 0),
+  cap_per_month      integer CHECK (cap_per_month > 0),
+  credits_valid_days integer CHECK (credits_valid_days > 0),
+  on_exhausted       text CHECK (on_exhausted IN ('stop', 'fallback_paid')),
+  terms_version      integer NOT NULL DEFAULT 1,
+  created_at         timestamptz NOT NULL,
+  created_by         uuid REFERENCES ${c.tables.owner}(id) ON DELETE SET NULL,
+  updated_at         timestamptz NOT NULL,
+  CHECK (ends_at IS NULL OR ends_at > starts_at),
+  CHECK ((purpose = 'partner') = (partner_id IS NOT NULL)),
+  CHECK (kind <> 'discount' OR (credits IS NULL AND num_nonnulls(percent_off_bp, amount_off_minor) = 1
+         AND (amount_off_minor IS NULL OR currency IS NOT NULL) AND duration IS NOT NULL
+         AND ((duration = 'repeating') = (duration_months IS NOT NULL))
+         AND (amount_off_minor IS NULL OR duration <> 'forever'))),
+  CHECK (kind <> 'credit' OR (credits IS NOT NULL AND on_exhausted IS NOT NULL
+         AND credits_valid_days IS NOT NULL
+         AND num_nulls(percent_off_bp, amount_off_minor, duration) = 3))
+);
+CREATE INDEX coupon_partner ON ${c.schema}.coupon (partner_id) WHERE partner_id IS NOT NULL;
+CREATE TABLE ${c.schema}.redemption (
+  id                    uuid PRIMARY KEY,
+  coupon_id             uuid NOT NULL REFERENCES ${c.schema}.coupon(id) ON DELETE RESTRICT,
+  account_id            uuid REFERENCES ${c.tables.owner}(id) ON DELETE SET NULL,
+  partner_id            uuid REFERENCES ${c.schema}.partner(id) ON DELETE SET NULL,
+  status                text NOT NULL CHECK (status IN ('reserved', 'confirmed', 'released', 'revoked')),
+  idempotency_key       text NOT NULL UNIQUE,
+  reserved_until        timestamptz,
+  checkout_ref          text UNIQUE,
+  payment_ref           text UNIQUE,
+  amount_paid_minor     bigint,
+  amount_discount_minor bigint,
+  amount_refunded_minor bigint NOT NULL DEFAULT 0 CHECK (amount_refunded_minor >= 0),
+  use_restored          boolean NOT NULL DEFAULT false,
+  currency              text,
+  credit_grant_id       uuid,
+  over_limit            boolean NOT NULL DEFAULT false,
+  created_at            timestamptz NOT NULL,
+  confirmed_at          timestamptz,
+  ended_at              timestamptz
+);
+CREATE INDEX redemption_uses ON ${c.schema}.redemption (coupon_id, account_id) WHERE status <> 'released' AND NOT use_restored;
+CREATE INDEX redemption_reserved ON ${c.schema}.redemption (reserved_until) WHERE status = 'reserved';
+CREATE INDEX redemption_partner ON ${c.schema}.redemption (partner_id, confirmed_at) WHERE partner_id IS NOT NULL;`
+    }
+  ]
+});
+
+export {
+  COUPONS_TOPIC,
+  COUPON_EVENT,
+  uuidOf,
+  COUPON_EVENT_SCHEMAS,
+  dbCouponStore,
+  SYSTEM,
+  createCoupons,
+  memoryCouponStore,
+  couponsSchema
+};
+//# sourceMappingURL=chunk-ECCGFGSV.js.map