payweave 0.0.0

package/dist/db/postgres/index.js

@@ -0,0 +1,791 @@
+import { applyMigrations, planMigrations } from '../../chunk-QJHXDZYC.js';
+import { PW_TABLES, PW_ACTIVE_SUBSCRIPTION_STATUSES, DEFAULT_STALE_CLAIM_AFTER_MS } from '../../chunk-NV3MZF7L.js';
+import { currentPeriod } from '../../chunk-4R5OGOCC.js';
+import { PayweaveConfigError, PayweaveNotFoundError, PayweaveError, PayweaveValidationError } from '../../chunk-HTRGMZFH.js';
+import { randomInt } from 'crypto';
+
+// src/db/postgres/errors.ts
+function installHintError(cause) {
+  return new PayweaveConfigError(
+    'payweave/db/postgres: this adapter requires the "pg" package, which is not installed (it is an optional peerDependency of "payweave"). Run `npm install pg` (or your package manager\'s equivalent) and try again.',
+    { cause }
+  );
+}
+var CONSTRAINT_VIOLATION_CODES = /* @__PURE__ */ new Set([
+  "23505",
+  // unique_violation — incl. the partial-unique active-subscription index
+  "23P01",
+  // exclusion_violation
+  "23503",
+  // foreign_key_violation
+  "23514"
+  // check_violation
+]);
+function pgErrorCode(error) {
+  const code = error?.code;
+  return typeof code === "string" ? code : void 0;
+}
+function isConstraintViolation(error) {
+  const code = pgErrorCode(error);
+  return code !== void 0 && CONSTRAINT_VIOLATION_CODES.has(code);
+}
+function wrapDriverError(error, message) {
+  if (error instanceof PayweaveError) return error;
+  if (isConstraintViolation(error)) {
+    return new PayweaveValidationError(message, { cause: error });
+  }
+  return new PayweaveError(message, { cause: error, isRetryable: false });
+}
+
+// src/db/postgres/runner.ts
+var PoolRunner = class {
+  #pool;
+  constructor(pool) {
+    this.#pool = pool;
+  }
+  query(text, params = []) {
+    return this.#pool.query(text, params);
+  }
+  async transaction(fn) {
+    const client = await this.#pool.connect();
+    try {
+      await client.query("BEGIN");
+      const txRunner = new ClientRunner(client);
+      try {
+        const result = await fn(txRunner);
+        await client.query("COMMIT");
+        return result;
+      } catch (error) {
+        await client.query("ROLLBACK").catch(() => void 0);
+        throw error;
+      }
+    } finally {
+      client.release();
+    }
+  }
+};
+var ClientRunner = class {
+  #client;
+  constructor(client) {
+    this.#client = client;
+  }
+  query(text, params = []) {
+    return this.#client.query(text, params);
+  }
+  // Reentrant: already inside one atomic unit, so nested `transaction()`
+  // calls (e.g. a user's `db.transaction(tx => tx.plans.pushVersion(...))`)
+  // just run inline rather than attempting a nested BEGIN.
+  transaction(fn) {
+    return fn(this);
+  }
+};
+
+// src/db/postgres/url.ts
+var VALID_SCHEMES = ["postgres://", "postgresql://"];
+function assertPostgresConnectionString(value) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new PayweaveConfigError(
+      `payweave/db/postgres: postgresAdapter({ connectionString }) requires a non-empty string \u2014 got ${JSON.stringify(value)}.`
+    );
+  }
+  if (!VALID_SCHEMES.some((scheme) => value.startsWith(scheme))) {
+    throw new PayweaveConfigError(
+      `payweave/db/postgres: connectionString must start with "postgres://" or "postgresql://" \u2014 got an unsupported scheme. Never log or include the full string in an error message (it may carry credentials); check the beginning of your DATABASE_URL.`
+    );
+  }
+  return value;
+}
+function looksLikePgPool(value) {
+  const candidate = value;
+  return typeof candidate.query === "function" && typeof candidate.connect === "function";
+}
+function resolvePostgresInput(input) {
+  if (input === null || typeof input !== "object") {
+    throw new PayweaveConfigError(
+      `payweave/db/postgres: postgresAdapter(...) expects { connectionString } (a postgres:///postgresql:// URL) or an existing \`pg\` Pool instance \u2014 got ${input === null ? "null" : typeof input}.`
+    );
+  }
+  if ("connectionString" in input) {
+    const connectionString = assertPostgresConnectionString(
+      input.connectionString
+    );
+    return { kind: "connectionString", connectionString };
+  }
+  if (looksLikePgPool(input)) {
+    return { kind: "pool-instance", pool: input };
+  }
+  throw new PayweaveConfigError(
+    "payweave/db/postgres: postgresAdapter(...) expects { connectionString } (a postgres:///postgresql:// URL) or an existing `pg` Pool instance (has .query()/.connect()) \u2014 got an object matching neither shape."
+  );
+}
+var ENCODING = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+var ENCODING_LEN = ENCODING.length;
+var TIME_LEN = 10;
+var RANDOM_LEN = 16;
+function encodeTime(timeMs, len) {
+  if (!Number.isSafeInteger(timeMs) || timeMs < 0) {
+    throw new RangeError(`ulid: time must be a non-negative safe integer \u2014 got ${timeMs}`);
+  }
+  let remaining = timeMs;
+  let out = "";
+  for (let i = 0; i < len; i++) {
+    const mod = remaining % ENCODING_LEN;
+    out = ENCODING.charAt(mod) + out;
+    remaining = Math.floor(remaining / ENCODING_LEN);
+  }
+  return out;
+}
+function encodeRandom(len) {
+  let out = "";
+  for (let i = 0; i < len; i++) {
+    out += ENCODING.charAt(randomInt(0, ENCODING_LEN));
+  }
+  return out;
+}
+function ulid(timeMs = Date.now()) {
+  return encodeTime(timeMs, TIME_LEN) + encodeRandom(RANDOM_LEN);
+}
+function generatePwId(timeMs = Date.now()) {
+  return `pwv_${ulid(timeMs)}`;
+}
+
+// src/db/postgres/migrations-executor.ts
+var PostgresMigrationExecutor = class _PostgresMigrationExecutor {
+  #runner;
+  constructor(runner) {
+    this.#runner = runner;
+  }
+  async query(sql, params = []) {
+    const { rows } = await this.#runner.query(sql, params);
+    return { rows };
+  }
+  async transaction(fn) {
+    return this.#runner.transaction((tx) => fn(new _PostgresMigrationExecutor(tx)));
+  }
+};
+
+// src/db/postgres/rows.ts
+function requireColumn(row, column) {
+  if (!(column in row)) {
+    throw new Error(`postgres adapter: row is missing expected column "${column}"`);
+  }
+  return row[column];
+}
+function str(row, column) {
+  const value = requireColumn(row, column);
+  if (typeof value !== "string") {
+    throw new Error(`postgres adapter: expected column "${column}" to be a string, got ${typeof value}`);
+  }
+  return value;
+}
+function nullableStr(row, column) {
+  const value = requireColumn(row, column);
+  if (value === null || value === void 0) return null;
+  if (typeof value !== "string") {
+    throw new Error(
+      `postgres adapter: expected column "${column}" to be a string or null, got ${typeof value}`
+    );
+  }
+  return value;
+}
+function int(row, column) {
+  const value = requireColumn(row, column);
+  if (typeof value !== "number") {
+    throw new Error(`postgres adapter: expected column "${column}" to be a number, got ${typeof value}`);
+  }
+  return value;
+}
+function bigint(row, column) {
+  const value = requireColumn(row, column);
+  if (typeof value === "number") return value;
+  if (typeof value === "string") {
+    const n = Number(value);
+    if (!Number.isSafeInteger(n)) {
+      throw new Error(
+        `postgres adapter: column "${column}" (${value}) is outside Number.isSafeInteger range`
+      );
+    }
+    return n;
+  }
+  throw new Error(
+    `postgres adapter: expected column "${column}" to be a bigint string or number, got ${typeof value}`
+  );
+}
+function bool(row, column) {
+  const value = requireColumn(row, column);
+  if (typeof value !== "boolean") {
+    throw new Error(`postgres adapter: expected column "${column}" to be a boolean, got ${typeof value}`);
+  }
+  return value;
+}
+function dateOf(row, column) {
+  const value = requireColumn(row, column);
+  if (!(value instanceof Date)) {
+    throw new Error(`postgres adapter: expected column "${column}" to be a Date, got ${typeof value}`);
+  }
+  return value;
+}
+function json(row, column) {
+  return requireColumn(row, column);
+}
+function rowToCustomer(row) {
+  return {
+    id: str(row, "id"),
+    externalId: str(row, "external_id"),
+    providerIds: json(row, "provider_ids"),
+    email: nullableStr(row, "email"),
+    createdAt: dateOf(row, "created_at"),
+    updatedAt: dateOf(row, "updated_at")
+  };
+}
+function rowToPlanVersion(row) {
+  return {
+    id: str(row, "id"),
+    planId: str(row, "plan_id"),
+    version: int(row, "version"),
+    group: str(row, "group"),
+    isDefault: bool(row, "is_default"),
+    name: nullableStr(row, "name"),
+    priceMinor: (() => {
+      const v = requireColumn(row, "price_minor");
+      return v === null ? null : bigint(row, "price_minor");
+    })(),
+    priceCurrency: nullableStr(row, "price_currency"),
+    priceInterval: nullableStr(row, "price_interval"),
+    features: json(row, "features"),
+    providerRefs: json(row, "provider_refs"),
+    pushedAt: dateOf(row, "pushed_at")
+  };
+}
+function rowToSubscription(row) {
+  return {
+    id: str(row, "id"),
+    customerId: str(row, "customer_id"),
+    planId: str(row, "plan_id"),
+    planVersion: int(row, "plan_version"),
+    group: str(row, "group"),
+    status: str(row, "status"),
+    provider: nullableStr(row, "provider"),
+    providerSubscriptionRef: nullableStr(row, "provider_subscription_ref"),
+    currentPeriodStart: dateOf(row, "current_period_start"),
+    currentPeriodEnd: dateOf(row, "current_period_end"),
+    cancelAtPeriodEnd: bool(row, "cancel_at_period_end"),
+    createdAt: dateOf(row, "created_at"),
+    updatedAt: dateOf(row, "updated_at")
+  };
+}
+function rowToFeatureBalance(row) {
+  return {
+    id: str(row, "id"),
+    customerId: str(row, "customer_id"),
+    featureId: str(row, "feature_id"),
+    group: str(row, "group"),
+    used: bigint(row, "used"),
+    limit: bigint(row, "limit"),
+    resetInterval: str(row, "reset_interval"),
+    anchor: dateOf(row, "anchor"),
+    periodStart: dateOf(row, "period_start"),
+    periodEnd: dateOf(row, "period_end"),
+    planId: str(row, "plan_id"),
+    planVersion: int(row, "plan_version"),
+    updatedAt: dateOf(row, "updated_at")
+  };
+}
+
+// src/db/postgres/period-sql.ts
+var DAY_MS = "86400000";
+var WEEK_MS = "604800000";
+function daysInMonthExpr(yearExpr, monthExpr) {
+  return `(EXTRACT(DAY FROM (make_date((${yearExpr})::int, (${monthExpr})::int, 1) + INTERVAL '1 month - 1 day')))::int`;
+}
+function clampedMonthAddExpr(anchorUtc, totalMonthsExpr) {
+  const rawMonths = `((EXTRACT(MONTH FROM ${anchorUtc}))::int - 1 + (${totalMonthsExpr}))`;
+  const year = `((EXTRACT(YEAR FROM ${anchorUtc}))::int + FLOOR((${rawMonths})::numeric / 12))::int`;
+  const monthIndex = `(MOD(MOD((${rawMonths})::int, 12) + 12, 12))::int`;
+  const month = `(${monthIndex} + 1)`;
+  const day = `LEAST((EXTRACT(DAY FROM ${anchorUtc}))::int, ${daysInMonthExpr(year, month)})`;
+  return `make_timestamptz(${year}, ${month}, (${day})::int, (EXTRACT(HOUR FROM ${anchorUtc}))::int, (EXTRACT(MINUTE FROM ${anchorUtc}))::int, (EXTRACT(SECOND FROM ${anchorUtc}))::double precision, 'UTC')`;
+}
+function advanceExpr(anchorRaw, resetIntervalRaw, nExpr) {
+  const anchorUtc = `(${anchorRaw} AT TIME ZONE 'UTC')`;
+  return `(CASE ${resetIntervalRaw}
+    WHEN 'day' THEN ${anchorRaw} + ((${nExpr}) * ${DAY_MS}) * INTERVAL '1 millisecond'
+    WHEN 'week' THEN ${anchorRaw} + ((${nExpr}) * ${WEEK_MS}) * INTERVAL '1 millisecond'
+    WHEN 'month' THEN ${clampedMonthAddExpr(anchorUtc, `(${nExpr}) * 1`)}
+    WHEN 'year' THEN ${clampedMonthAddExpr(anchorUtc, `(${nExpr}) * 12`)}
+  END)`;
+}
+function estimateExpr(anchorRaw, resetIntervalRaw, nowRaw) {
+  const anchorUtc = `(${anchorRaw} AT TIME ZONE 'UTC')`;
+  const nowUtc = `(${nowRaw} AT TIME ZONE 'UTC')`;
+  const diffMs = `ROUND(EXTRACT(EPOCH FROM (${nowRaw} - ${anchorRaw})) * 1000)`;
+  const monthDiff = `(((EXTRACT(YEAR FROM ${nowUtc}))::int - (EXTRACT(YEAR FROM ${anchorUtc}))::int) * 12 + ((EXTRACT(MONTH FROM ${nowUtc}))::int - (EXTRACT(MONTH FROM ${anchorUtc}))::int))`;
+  return `((CASE ${resetIntervalRaw}
+    WHEN 'day' THEN FLOOR((${diffMs})::numeric / ${DAY_MS})
+    WHEN 'week' THEN FLOOR((${diffMs})::numeric / ${WEEK_MS})
+    WHEN 'month' THEN FLOOR((${monthDiff})::numeric / 1)
+    WHEN 'year' THEN FLOOR((${monthDiff})::numeric / 12)
+  END)::bigint)`;
+}
+function buildPeriodMathSql(anchorRaw, resetIntervalRaw, nowRaw) {
+  const estimate = estimateExpr(anchorRaw, resetIntervalRaw, nowRaw);
+  const index0 = `(GREATEST(0, (${estimate}) - 1))`;
+  const adv = (offset) => advanceExpr(anchorRaw, resetIntervalRaw, `(${index0}) + ${offset}`);
+  const adv0 = adv(0);
+  const adv1 = adv(1);
+  const adv2 = adv(2);
+  const adv3 = adv(3);
+  const increments = `(CASE WHEN ${nowRaw} < ${adv1} THEN 0 WHEN ${nowRaw} < ${adv2} THEN 1 ELSE 2 END)`;
+  return {
+    periodStart: `(CASE ${increments} WHEN 0 THEN ${adv0} WHEN 1 THEN ${adv1} ELSE ${adv2} END)`,
+    periodEnd: `(CASE ${increments} WHEN 0 THEN ${adv1} WHEN 1 THEN ${adv2} ELSE ${adv3} END)`
+  };
+}
+
+// src/db/postgres/sql.ts
+var FEATURE_BALANCES = PW_TABLES.featureBalances;
+var WEBHOOK_EVENTS = PW_TABLES.webhookEvents;
+function buildConsumeQuery(input, newId) {
+  const conditional = input.conditional === true;
+  const freshPeriod = currentPeriod(
+    input.init.anchor.getTime(),
+    input.init.resetInterval,
+    input.now.getTime()
+  );
+  const params = [
+    newId,
+    input.customerId,
+    input.featureId,
+    input.group,
+    input.now,
+    input.amount,
+    conditional,
+    input.init.limit,
+    input.init.resetInterval,
+    input.init.anchor,
+    input.init.planId,
+    input.init.planVersion,
+    new Date(freshPeriod.start),
+    new Date(freshPeriod.end)
+  ];
+  const resetDue = `($5::timestamptz >= e.period_end)`;
+  const baseUsed = `(CASE WHEN ${resetDue} THEN 0 ELSE e.used END)`;
+  const remaining = `(e."limit" - ${baseUsed})`;
+  const appliedExisting = `(($7::boolean) IS NOT TRUE OR ${remaining} >= $6::bigint)`;
+  const finalUsedExisting = `(CASE WHEN ${appliedExisting} THEN ${baseUsed} + $6::bigint ELSE ${baseUsed} END)`;
+  const updatedAtExisting = `(CASE WHEN (${appliedExisting} OR ${resetDue}) THEN $5::timestamptz ELSE e.updated_at END)`;
+  const existingPeriod = buildPeriodMathSql("e.anchor", "e.reset_interval", "$5::timestamptz");
+  const periodStartExisting = `(CASE WHEN ${resetDue} THEN ${existingPeriod.periodStart} ELSE e.period_start END)`;
+  const periodEndExisting = `(CASE WHEN ${resetDue} THEN ${existingPeriod.periodEnd} ELSE e.period_end END)`;
+  const freshDenied = `(($7::boolean) IS TRUE AND $8::bigint < $6::bigint)`;
+  const freshUsed = `(CASE WHEN ${freshDenied} THEN 0 ELSE $6::bigint END)`;
+  const freshApplied = `(CASE WHEN ${freshDenied} THEN FALSE ELSE TRUE END)`;
+  const text = `
+WITH existing AS (
+  SELECT * FROM ${FEATURE_BALANCES}
+  WHERE customer_id = $2 AND feature_id = $3 AND "group" = $4
+  FOR UPDATE
+),
+computed AS (
+  SELECT
+    CASE WHEN e.id IS NULL THEN ${freshUsed} ELSE ${finalUsedExisting} END AS used,
+    CASE WHEN e.id IS NULL THEN $13::timestamptz ELSE ${periodStartExisting} END AS period_start,
+    CASE WHEN e.id IS NULL THEN $14::timestamptz ELSE ${periodEndExisting} END AS period_end,
+    CASE WHEN e.id IS NULL THEN $5::timestamptz ELSE ${updatedAtExisting} END AS updated_at,
+    CASE WHEN e.id IS NULL THEN ${freshApplied} ELSE ${appliedExisting} END AS applied
+  FROM (SELECT 1 AS one) dummy
+  LEFT JOIN existing e ON true
+)
+INSERT INTO ${FEATURE_BALANCES}
+  (id, customer_id, feature_id, "group", used, "limit", reset_interval, anchor, period_start, period_end, plan_id, plan_version, updated_at)
+SELECT $1, $2, $3, $4, computed.used, $8::bigint, $9::text, $10::timestamptz, computed.period_start, computed.period_end, $11::text, $12::int, computed.updated_at
+FROM computed
+ON CONFLICT (customer_id, feature_id, "group") DO UPDATE SET
+  used = (SELECT used FROM computed),
+  period_start = (SELECT period_start FROM computed),
+  period_end = (SELECT period_end FROM computed),
+  updated_at = (SELECT updated_at FROM computed)
+RETURNING id, customer_id, feature_id, "group", used, "limit", reset_interval, anchor, period_start, period_end, plan_id, plan_version, updated_at,
+  (SELECT applied FROM computed) AS applied
+`.trim();
+  return { text, params };
+}
+function buildClaimQuery(dedupeKey, meta, defaultStaleClaimAfterMs) {
+  const staleClaimAfterMs = meta.staleClaimAfterMs ?? defaultStaleClaimAfterMs;
+  const staleThreshold = new Date(meta.now.getTime() - staleClaimAfterMs);
+  const text = `
+INSERT INTO ${WEBHOOK_EVENTS} (dedupe_key, provider, type, received_at, claimed_at, applied_at)
+VALUES ($1, $2, $3, $4::timestamptz, $5::timestamptz, NULL)
+ON CONFLICT (dedupe_key) DO UPDATE SET claimed_at = EXCLUDED.claimed_at
+WHERE ${WEBHOOK_EVENTS}.applied_at IS NULL AND ${WEBHOOK_EVENTS}.claimed_at <= $6::timestamptz
+RETURNING dedupe_key
+`.trim();
+  return {
+    text,
+    params: [dedupeKey, meta.provider, meta.type, meta.now, meta.now, staleThreshold]
+  };
+}
+
+// src/db/postgres/adapter.ts
+var ACTIVE_STATUS_PLACEHOLDERS = PW_ACTIVE_SUBSCRIPTION_STATUSES.map((_, i) => `$${i + 3}`).join(", ");
+function stableStringify(value) {
+  if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
+  if (value !== null && typeof value === "object") {
+    const entries = Object.entries(value).sort(
+      ([a], [b]) => a < b ? -1 : a > b ? 1 : 0
+    );
+    return `{${entries.map(([key, val]) => `${JSON.stringify(key)}:${stableStringify(val)}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+var planContent = (p) => ({
+  group: p.group,
+  isDefault: p.isDefault,
+  name: p.name,
+  priceMinor: p.priceMinor,
+  priceCurrency: p.priceCurrency,
+  priceInterval: p.priceInterval,
+  features: p.features,
+  providerRefs: p.providerRefs
+});
+function planContentEquals(active, input) {
+  return stableStringify(planContent(active)) === stableStringify(planContent(input));
+}
+var SUBSCRIPTION_PATCH_FIELDS = [
+  { key: "planId", column: "plan_id" },
+  { key: "planVersion", column: "plan_version" },
+  { key: "status", column: "status" },
+  { key: "provider", column: "provider" },
+  { key: "providerSubscriptionRef", column: "provider_subscription_ref" },
+  { key: "currentPeriodStart", column: "current_period_start" },
+  { key: "currentPeriodEnd", column: "current_period_end" },
+  { key: "cancelAtPeriodEnd", column: "cancel_at_period_end" }
+];
+function buildAdapter(runner) {
+  return {
+    dialect: "postgres",
+    customers: {
+      getByExternalId: (externalId) => customersGetByExternalId(runner, externalId),
+      upsert: (input) => customersUpsert(runner, input),
+      linkProviderRef: (externalId, provider, ref) => customersLinkProviderRef(runner, externalId, provider, ref)
+    },
+    plans: {
+      getActiveVersion: (planId) => plansGetActiveVersion(runner, planId),
+      listActive: () => plansListActive(runner),
+      pushVersion: (plan) => plansPushVersion(runner, plan)
+    },
+    subscriptions: {
+      getActive: (customerId, group) => subscriptionsGetActive(runner, customerId, group),
+      create: (input) => subscriptionsCreate(runner, input),
+      update: (id, patch) => subscriptionsUpdate(runner, id, patch)
+    },
+    balances: {
+      get: (customerId, featureId, group) => balancesGet(runner, customerId, featureId, group),
+      consume: (input) => balancesConsume(runner, input),
+      resetTo: (customerId, featureId, group, init) => balancesResetTo(runner, customerId, featureId, group, init)
+    },
+    webhookEvents: {
+      claim: (dedupeKey, meta) => webhookEventsClaim(runner, dedupeKey, meta),
+      markApplied: (dedupeKey) => webhookEventsMarkApplied(runner, dedupeKey)
+    },
+    migrations: {
+      status: () => planMigrations(new PostgresMigrationExecutor(runner), "postgres"),
+      apply: () => applyMigrations(new PostgresMigrationExecutor(runner), "postgres")
+    },
+    transaction: (fn) => runner.transaction((tx) => fn(buildAdapter(tx)))
+  };
+}
+async function customersGetByExternalId(runner, externalId) {
+  const { rows } = await runner.query(
+    `SELECT * FROM ${PW_TABLES.customers} WHERE external_id = $1`,
+    [externalId]
+  );
+  const row = rows[0];
+  return row ? rowToCustomer(row) : null;
+}
+async function customersUpsert(runner, input) {
+  const now = /* @__PURE__ */ new Date();
+  const id = generatePwId(now.getTime());
+  try {
+    const { rows } = await runner.query(
+      `INSERT INTO ${PW_TABLES.customers} (id, external_id, provider_ids, email, created_at, updated_at)
+       VALUES ($1, $2, $3::jsonb, $4, $5, $6)
+       ON CONFLICT (external_id) DO UPDATE SET
+         email = COALESCE(excluded.email, ${PW_TABLES.customers}.email),
+         updated_at = excluded.updated_at
+       RETURNING *`,
+      [id, input.externalId, JSON.stringify({}), input.email ?? null, now, now]
+    );
+    const row = rows[0];
+    if (!row) throw new Error("postgres adapter: customers.upsert returned no row");
+    return rowToCustomer(row);
+  } catch (error) {
+    throw wrapDriverError(
+      error,
+      `payweave/db/postgres: customers.upsert(${JSON.stringify(input.externalId)}) failed.`
+    );
+  }
+}
+async function customersLinkProviderRef(runner, externalId, provider, ref) {
+  await runner.transaction(async (tx) => {
+    const { rows } = await tx.query(
+      `SELECT * FROM ${PW_TABLES.customers} WHERE external_id = $1 FOR UPDATE`,
+      [externalId]
+    );
+    const row = rows[0];
+    if (!row) {
+      throw new PayweaveNotFoundError(
+        `payweave/db/postgres: customers.linkProviderRef: no customer with externalId ${JSON.stringify(externalId)}.`
+      );
+    }
+    const customer = rowToCustomer(row);
+    const providerIds = { ...customer.providerIds, [provider]: ref };
+    await tx.query(
+      `UPDATE ${PW_TABLES.customers} SET provider_ids = $1::jsonb, updated_at = $2 WHERE external_id = $3`,
+      [JSON.stringify(providerIds), /* @__PURE__ */ new Date(), externalId]
+    );
+  });
+}
+async function plansGetActiveVersion(runner, planId) {
+  const { rows } = await runner.query(
+    `SELECT * FROM ${PW_TABLES.plans} WHERE plan_id = $1 ORDER BY version DESC LIMIT 1`,
+    [planId]
+  );
+  const row = rows[0];
+  return row ? rowToPlanVersion(row) : null;
+}
+async function plansListActive(runner) {
+  const { rows } = await runner.query(
+    `SELECT p.* FROM ${PW_TABLES.plans} p
+     INNER JOIN (
+       SELECT plan_id, MAX(version) AS version FROM ${PW_TABLES.plans} GROUP BY plan_id
+     ) latest ON latest.plan_id = p.plan_id AND latest.version = p.version`
+  );
+  return rows.map(rowToPlanVersion);
+}
+async function plansPushVersion(runner, plan) {
+  return runner.transaction(async (tx) => {
+    const { rows } = await tx.query(
+      `SELECT * FROM ${PW_TABLES.plans} WHERE plan_id = $1 ORDER BY version DESC LIMIT 1 FOR UPDATE`,
+      [plan.planId]
+    );
+    const activeRow = rows[0];
+    const active = activeRow ? rowToPlanVersion(activeRow) : null;
+    if (active && planContentEquals(active, plan)) {
+      return active;
+    }
+    const now = /* @__PURE__ */ new Date();
+    const id = generatePwId(now.getTime());
+    const nextVersion = (active?.version ?? 0) + 1;
+    const { rows: inserted } = await tx.query(
+      `INSERT INTO ${PW_TABLES.plans}
+         (id, plan_id, version, "group", is_default, name, price_minor, price_currency, price_interval, features, provider_refs, pushed_at)
+       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10::jsonb, $11::jsonb, $12)
+       RETURNING *`,
+      [
+        id,
+        plan.planId,
+        nextVersion,
+        plan.group,
+        plan.isDefault,
+        plan.name,
+        plan.priceMinor,
+        plan.priceCurrency,
+        plan.priceInterval,
+        JSON.stringify(plan.features),
+        JSON.stringify(plan.providerRefs),
+        now
+      ]
+    );
+    const row = inserted[0];
+    if (!row) throw new Error("postgres adapter: plans.pushVersion returned no row");
+    return rowToPlanVersion(row);
+  });
+}
+async function subscriptionsGetActive(runner, customerId, group) {
+  const { rows } = await runner.query(
+    `SELECT * FROM ${PW_TABLES.subscriptions}
+     WHERE customer_id = $1 AND "group" = $2 AND status IN (${ACTIVE_STATUS_PLACEHOLDERS})`,
+    [customerId, group, ...PW_ACTIVE_SUBSCRIPTION_STATUSES]
+  );
+  const row = rows[0];
+  return row ? rowToSubscription(row) : null;
+}
+async function subscriptionsCreate(runner, input) {
+  const now = /* @__PURE__ */ new Date();
+  const id = generatePwId(now.getTime());
+  try {
+    const { rows } = await runner.query(
+      `INSERT INTO ${PW_TABLES.subscriptions}
+        (id, customer_id, plan_id, plan_version, "group", status, provider, provider_subscription_ref,
+         current_period_start, current_period_end, cancel_at_period_end, created_at, updated_at)
+       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13)
+       RETURNING *`,
+      [
+        id,
+        input.customerId,
+        input.planId,
+        input.planVersion,
+        input.group,
+        input.status,
+        input.provider,
+        input.providerSubscriptionRef,
+        input.currentPeriodStart,
+        input.currentPeriodEnd,
+        input.cancelAtPeriodEnd,
+        now,
+        now
+      ]
+    );
+    const row = rows[0];
+    if (!row) throw new Error("postgres adapter: subscriptions.create returned no row");
+    return rowToSubscription(row);
+  } catch (error) {
+    throw wrapDriverError(
+      error,
+      `payweave/db/postgres: subscriptions.create for customer ${JSON.stringify(input.customerId)} group ${JSON.stringify(input.group)} violated a uniqueness rule (an active-set subscription already exists for this customer/group, or another constraint failed).`
+    );
+  }
+}
+async function subscriptionsUpdate(runner, id, patch) {
+  const sets = [];
+  const params = [];
+  const patchRecord = patch;
+  for (const field of SUBSCRIPTION_PATCH_FIELDS) {
+    if (!(field.key in patch) || patchRecord[field.key] === void 0) continue;
+    params.push(patchRecord[field.key]);
+    sets.push(`${field.column} = $${params.length}`);
+  }
+  params.push(/* @__PURE__ */ new Date());
+  sets.push(`updated_at = $${params.length}`);
+  params.push(id);
+  const idParamIndex = params.length;
+  try {
+    const { rows } = await runner.query(
+      `UPDATE ${PW_TABLES.subscriptions} SET ${sets.join(", ")} WHERE id = $${idParamIndex} RETURNING *`,
+      params
+    );
+    const row = rows[0];
+    if (!row) {
+      throw new PayweaveNotFoundError(
+        `payweave/db/postgres: subscriptions.update: no subscription with id ${JSON.stringify(id)}.`
+      );
+    }
+    return rowToSubscription(row);
+  } catch (error) {
+    if (error instanceof PayweaveNotFoundError) throw error;
+    throw wrapDriverError(error, `payweave/db/postgres: subscriptions.update(${JSON.stringify(id)}) failed.`);
+  }
+}
+async function balancesGet(runner, customerId, featureId, group) {
+  const { rows } = await runner.query(
+    `SELECT * FROM ${PW_TABLES.featureBalances} WHERE customer_id = $1 AND feature_id = $2 AND "group" = $3`,
+    [customerId, featureId, group]
+  );
+  const row = rows[0];
+  return row ? rowToFeatureBalance(row) : null;
+}
+async function balancesConsume(runner, input) {
+  const id = generatePwId(input.now.getTime());
+  const { text, params } = buildConsumeQuery(input, id);
+  try {
+    const { rows } = await runner.query(text, params);
+    const row = rows[0];
+    if (!row) throw new Error("postgres adapter: balances.consume returned no row");
+    const applied = row.applied;
+    if (typeof applied !== "boolean") {
+      throw new Error(
+        `postgres adapter: balances.consume's RETURNING "applied" column was ${typeof applied}, expected boolean`
+      );
+    }
+    return { ...rowToFeatureBalance(row), applied };
+  } catch (error) {
+    throw wrapDriverError(
+      error,
+      `payweave/db/postgres: balances.consume for customer ${JSON.stringify(input.customerId)} feature ${JSON.stringify(input.featureId)} group ${JSON.stringify(input.group)} failed.`
+    );
+  }
+}
+async function balancesResetTo(runner, customerId, featureId, group, init) {
+  const now = /* @__PURE__ */ new Date();
+  const period = currentPeriod(init.anchor.getTime(), init.resetInterval, now.getTime());
+  const id = generatePwId(now.getTime());
+  await runner.query(
+    `INSERT INTO ${PW_TABLES.featureBalances}
+       (id, customer_id, feature_id, "group", used, "limit", reset_interval, anchor, period_start, period_end, plan_id, plan_version, updated_at)
+     VALUES ($1, $2, $3, $4, 0, $5, $6, $7, $8, $9, $10, $11, $12)
+     ON CONFLICT (customer_id, feature_id, "group") DO UPDATE SET
+       used = 0,
+       "limit" = excluded."limit",
+       reset_interval = excluded.reset_interval,
+       anchor = excluded.anchor,
+       period_start = excluded.period_start,
+       period_end = excluded.period_end,
+       plan_id = excluded.plan_id,
+       plan_version = excluded.plan_version,
+       updated_at = excluded.updated_at`,
+    [
+      id,
+      customerId,
+      featureId,
+      group,
+      init.limit,
+      init.resetInterval,
+      init.anchor,
+      new Date(period.start),
+      new Date(period.end),
+      init.planId,
+      init.planVersion,
+      now
+    ]
+  );
+}
+async function webhookEventsClaim(runner, dedupeKey, meta) {
+  const { text, params } = buildClaimQuery(dedupeKey, meta, DEFAULT_STALE_CLAIM_AFTER_MS);
+  const { rows } = await runner.query(text, params);
+  return rows.length > 0;
+}
+async function webhookEventsMarkApplied(runner, dedupeKey) {
+  await runner.query(
+    `UPDATE ${PW_TABLES.webhookEvents} SET applied_at = $1 WHERE dedupe_key = $2`,
+    [/* @__PURE__ */ new Date(), dedupeKey]
+  );
+}
+
+// src/db/postgres/index.ts
+async function openPool(connectionString) {
+  let mod;
+  try {
+    mod = await import('pg');
+  } catch (cause) {
+    throw installHintError(cause);
+  }
+  const Pool = (mod.default ?? mod).Pool;
+  return new Pool({ connectionString });
+}
+function connect(target) {
+  return target.kind === "pool-instance" ? Promise.resolve(target.pool) : openPool(target.connectionString);
+}
+function postgresAdapter(input) {
+  const target = resolvePostgresInput(input);
+  let poolPromise;
+  const getPool = () => {
+    poolPromise ??= connect(target);
+    return poolPromise;
+  };
+  const runner = {
+    query: async (text, params = []) => {
+      const pool = await getPool();
+      return pool.query(text, params);
+    },
+    transaction: async (fn) => {
+      const pool = await getPool();
+      return new PoolRunner(pool).transaction(fn);
+    }
+  };
+  return buildAdapter(runner);
+}
+
+export { postgresAdapter };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map