stripe-experiment-sync 1.0.19 → 1.0.20

package/dist/chunk-XKBCLBFT.js

@@ -1,4130 +0,0 @@
-import {
-  package_default
-} from "./chunk-CMGFQCD7.js";
-
-// src/stripeSync.ts
-import Stripe3 from "stripe";
-import { pg as sql2 } from "yesql";
-
-// src/database/postgres.ts
-import pg from "pg";
-import { pg as sql } from "yesql";
-
-// src/database/QueryUtils.ts
-var QueryUtils = class _QueryUtils {
-  constructor() {
-  }
-  static quoteIdent(name) {
-    return `"${name}"`;
-  }
-  static quotedList(names) {
-    return names.map(_QueryUtils.quoteIdent).join(", ");
-  }
-  static buildInsertParts(columns) {
-    const columnsSql = columns.map((c) => _QueryUtils.quoteIdent(c.column)).join(", ");
-    const valuesSql = columns.map((c, i) => {
-      const placeholder = `$${i + 1}`;
-      return `${placeholder}::${c.pgType}`;
-    }).join(", ");
-    const params = columns.map((c) => c.value);
-    return { columnsSql, valuesSql, params };
-  }
-  static buildRawJsonUpsertQuery(schema, table, columns, conflictTarget) {
-    const { columnsSql, valuesSql, params } = _QueryUtils.buildInsertParts(columns);
-    const conflictSql = _QueryUtils.quotedList(conflictTarget);
-    const tsParamIdx = columns.findIndex((c) => c.column === "_last_synced_at") + 1;
-    if (tsParamIdx <= 0) {
-      throw new Error("buildRawJsonUpsertQuery requires _last_synced_at column");
-    }
-    const sql3 = `
-    INSERT INTO ${_QueryUtils.quoteIdent(schema)}.${_QueryUtils.quoteIdent(table)} (${columnsSql})
-    VALUES (${valuesSql})
-    ON CONFLICT (${conflictSql})
-    DO UPDATE SET
-      "_raw_data" = EXCLUDED."_raw_data",
-      "_last_synced_at" = $${tsParamIdx},
-      "_account_id" = EXCLUDED."_account_id"
-    WHERE ${_QueryUtils.quoteIdent(table)}."_last_synced_at" IS NULL
-       OR ${_QueryUtils.quoteIdent(table)}."_last_synced_at" < $${tsParamIdx}
-    RETURNING *
-  `;
-    return { sql: sql3, params };
-  }
-};
-
-// src/database/postgres.ts
-var ORDERED_STRIPE_TABLES = [
-  "exchange_rates_from_usd",
-  "subscription_items",
-  "subscription_item_change_events_v2_beta",
-  "subscriptions",
-  "subscription_schedules",
-  "checkout_session_line_items",
-  "checkout_sessions",
-  "tax_ids",
-  "charges",
-  "refunds",
-  "credit_notes",
-  "disputes",
-  "early_fraud_warnings",
-  "invoices",
-  "payment_intents",
-  "payment_methods",
-  "setup_intents",
-  "prices",
-  "plans",
-  "products",
-  "features",
-  "active_entitlements",
-  "reviews",
-  "_managed_webhooks",
-  "customers",
-  "_sync_obj_runs",
-  // Must be deleted before _sync_runs (foreign key)
-  "_sync_runs"
-];
-var TABLES_WITH_ACCOUNT_ID = /* @__PURE__ */ new Set(["_managed_webhooks"]);
-var PostgresClient = class {
-  constructor(config) {
-    this.config = config;
-    this.pool = new pg.Pool(config.poolConfig);
-  }
-  pool;
-  async delete(table, id) {
-    const prepared = sql(`
-    delete from "${this.config.schema}"."${table}"
-    where id = :id
-    returning id;
-    `)({ id });
-    const { rows } = await this.query(prepared.text, prepared.values);
-    return rows.length > 0;
-  }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  async query(text, params) {
-    return this.pool.query(text, params);
-  }
-  async upsertMany(entries, table) {
-    if (!entries.length) return [];
-    const chunkSize = 5;
-    const results = [];
-    for (let i = 0; i < entries.length; i += chunkSize) {
-      const chunk = entries.slice(i, i + chunkSize);
-      const queries = [];
-      chunk.forEach((entry) => {
-        const rawData = JSON.stringify(entry);
-        const upsertSql = `
-          INSERT INTO "${this.config.schema}"."${table}" ("_raw_data")
-          VALUES ($1::jsonb)
-          ON CONFLICT (id)
-          DO UPDATE SET
-            "_raw_data" = EXCLUDED."_raw_data"
-          RETURNING *
-        `;
-        queries.push(this.pool.query(upsertSql, [rawData]));
-      });
-      results.push(...await Promise.all(queries));
-    }
-    return results.flatMap((it) => it.rows);
-  }
-  async upsertManyWithTimestampProtection(entries, table, accountId, syncTimestamp, upsertOptions) {
-    const timestamp = syncTimestamp || (/* @__PURE__ */ new Date()).toISOString();
-    if (!entries.length) return [];
-    const chunkSize = 5;
-    const results = [];
-    for (let i = 0; i < entries.length; i += chunkSize) {
-      const chunk = entries.slice(i, i + chunkSize);
-      const queries = [];
-      chunk.forEach((entry) => {
-        if (table.startsWith("_")) {
-          const columns = Object.keys(entry).filter(
-            (k) => k !== "last_synced_at" && k !== "account_id"
-          );
-          const upsertSql = `
-            INSERT INTO "${this.config.schema}"."${table}" (
-              ${columns.map((c) => `"${c}"`).join(", ")}, "last_synced_at", "account_id"
-            )
-            VALUES (
-              ${columns.map((c) => `:${c}`).join(", ")}, :last_synced_at, :account_id
-            )
-            ON CONFLICT ("id")
-            DO UPDATE SET
-              ${columns.map((c) => `"${c}" = EXCLUDED."${c}"`).join(", ")},
-              "last_synced_at" = :last_synced_at,
-              "account_id" = EXCLUDED."account_id"
-            WHERE "${table}"."last_synced_at" IS NULL
-               OR "${table}"."last_synced_at" < :last_synced_at
-            RETURNING *
-          `;
-          const cleansed = this.cleanseArrayField(entry);
-          cleansed.last_synced_at = timestamp;
-          cleansed.account_id = accountId;
-          const prepared = sql(upsertSql, { useNullForMissing: true })(cleansed);
-          queries.push(this.pool.query(prepared.text, prepared.values));
-        } else {
-          const conflictTarget = upsertOptions?.conflictTarget ?? ["id"];
-          const extraColumns = upsertOptions?.extraColumns ?? [];
-          if (!conflictTarget.length) {
-            throw new Error(`Invalid upsert config for ${table}: conflictTarget must be non-empty`);
-          }
-          const columns = [
-            { column: "_raw_data", pgType: "jsonb", value: JSON.stringify(entry) },
-            ...extraColumns.map((c) => ({
-              column: c.column,
-              pgType: c.pgType,
-              value: entry[c.entryKey]
-            })),
-            { column: "_last_synced_at", pgType: "timestamptz", value: timestamp },
-            { column: "_account_id", pgType: "text", value: accountId }
-          ];
-          for (const c of columns) {
-            if (c.value === void 0) {
-              throw new Error(`Missing required value for ${table}.${c.column}`);
-            }
-          }
-          const { sql: upsertSql, params } = QueryUtils.buildRawJsonUpsertQuery(
-            this.config.schema,
-            table,
-            columns,
-            conflictTarget
-          );
-          queries.push(this.pool.query(upsertSql, params));
-        }
-      });
-      results.push(...await Promise.all(queries));
-    }
-    return results.flatMap((it) => it.rows);
-  }
-  cleanseArrayField(obj) {
-    const cleansed = { ...obj };
-    Object.keys(cleansed).map((k) => {
-      const data = cleansed[k];
-      if (Array.isArray(data)) {
-        cleansed[k] = JSON.stringify(data);
-      }
-    });
-    return cleansed;
-  }
-  async findMissingEntries(table, ids) {
-    if (!ids.length) return [];
-    const prepared = sql(`
-    select id from "${this.config.schema}"."${table}"
-    where id=any(:ids::text[]);
-    `)({ ids });
-    const { rows } = await this.query(prepared.text, prepared.values);
-    const existingIds = rows.map((it) => it.id);
-    const missingIds = ids.filter((it) => !existingIds.includes(it));
-    return missingIds;
-  }
-  // Account management methods
-  async upsertAccount(accountData, apiKeyHash) {
-    const rawData = JSON.stringify(accountData.raw_data);
-    await this.query(
-      `INSERT INTO "${this.config.schema}"."accounts" ("_raw_data", "api_key_hashes", "first_synced_at", "_last_synced_at")
-       VALUES ($1::jsonb, ARRAY[$2], now(), now())
-       ON CONFLICT (id)
-       DO UPDATE SET
-         "_raw_data" = EXCLUDED."_raw_data",
-         "api_key_hashes" = (
-           SELECT ARRAY(
-             SELECT DISTINCT unnest(
-               COALESCE("${this.config.schema}"."accounts"."api_key_hashes", '{}') || ARRAY[$2]
-             )
-           )
-         ),
-         "_last_synced_at" = now(),
-         "_updated_at" = now()`,
-      [rawData, apiKeyHash]
-    );
-  }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  async getAllAccounts() {
-    const result = await this.query(
-      `SELECT _raw_data FROM "${this.config.schema}"."accounts"
-       ORDER BY _last_synced_at DESC`
-    );
-    return result.rows.map((row) => row._raw_data);
-  }
-  /**
-   * Looks up an account ID by API key hash
-   * Uses the GIN index on api_key_hashes for fast lookups
-   * @param apiKeyHash - SHA-256 hash of the Stripe API key
-   * @returns Account ID if found, null otherwise
-   */
-  async getAccountIdByApiKeyHash(apiKeyHash) {
-    const result = await this.query(
-      `SELECT id FROM "${this.config.schema}"."accounts"
-       WHERE $1 = ANY(api_key_hashes)
-       LIMIT 1`,
-      [apiKeyHash]
-    );
-    return result.rows.length > 0 ? result.rows[0].id : null;
-  }
-  /**
-   * Looks up full account data by API key hash
-   * @param apiKeyHash - SHA-256 hash of the Stripe API key
-   * @returns Account raw data if found, null otherwise
-   */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  async getAccountByApiKeyHash(apiKeyHash) {
-    const result = await this.query(
-      `SELECT _raw_data FROM "${this.config.schema}"."accounts"
-       WHERE $1 = ANY(api_key_hashes)
-       LIMIT 1`,
-      [apiKeyHash]
-    );
-    return result.rows.length > 0 ? result.rows[0]._raw_data : null;
-  }
-  getAccountIdColumn(table) {
-    return TABLES_WITH_ACCOUNT_ID.has(table) ? "account_id" : "_account_id";
-  }
-  async getAccountRecordCounts(accountId) {
-    const counts = {};
-    for (const table of ORDERED_STRIPE_TABLES) {
-      const accountIdColumn = this.getAccountIdColumn(table);
-      const result = await this.query(
-        `SELECT COUNT(*) as count FROM "${this.config.schema}"."${table}"
-         WHERE "${accountIdColumn}" = $1`,
-        [accountId]
-      );
-      counts[table] = parseInt(result.rows[0].count);
-    }
-    return counts;
-  }
-  async deleteAccountWithCascade(accountId, useTransaction) {
-    const deletionCounts = {};
-    try {
-      if (useTransaction) {
-        await this.query("BEGIN");
-      }
-      for (const table of ORDERED_STRIPE_TABLES) {
-        const accountIdColumn = this.getAccountIdColumn(table);
-        const result = await this.query(
-          `DELETE FROM "${this.config.schema}"."${table}"
-           WHERE "${accountIdColumn}" = $1`,
-          [accountId]
-        );
-        deletionCounts[table] = result.rowCount || 0;
-      }
-      const accountResult = await this.query(
-        `DELETE FROM "${this.config.schema}"."accounts"
-         WHERE "id" = $1`,
-        [accountId]
-      );
-      deletionCounts["accounts"] = accountResult.rowCount || 0;
-      if (useTransaction) {
-        await this.query("COMMIT");
-      }
-    } catch (error) {
-      if (useTransaction) {
-        await this.query("ROLLBACK");
-      }
-      throw error;
-    }
-    return deletionCounts;
-  }
-  /**
-   * Hash a string to a 32-bit integer for use with PostgreSQL advisory locks.
-   * Uses a simple hash algorithm that produces consistent results.
-   */
-  hashToInt32(key) {
-    let hash = 0;
-    for (let i = 0; i < key.length; i++) {
-      const char = key.charCodeAt(i);
-      hash = (hash << 5) - hash + char;
-      hash = hash & hash;
-    }
-    return hash;
-  }
-  /**
-   * Acquire a PostgreSQL advisory lock for the given key.
-   * This lock is automatically released when the connection is closed or explicitly released.
-   * Advisory locks are session-level and will block until the lock is available.
-   *
-   * @param key - A string key to lock on (will be hashed to an integer)
-   */
-  async acquireAdvisoryLock(key) {
-    const lockId = this.hashToInt32(key);
-    await this.query("SELECT pg_advisory_lock($1)", [lockId]);
-  }
-  /**
-   * Release a PostgreSQL advisory lock for the given key.
-   *
-   * @param key - The same string key used to acquire the lock
-   */
-  async releaseAdvisoryLock(key) {
-    const lockId = this.hashToInt32(key);
-    await this.query("SELECT pg_advisory_unlock($1)", [lockId]);
-  }
-  /**
-   * Execute a function while holding an advisory lock.
-   * The lock is automatically released after the function completes (success or error).
-   *
-   * IMPORTANT: This acquires a dedicated connection from the pool and holds it for the
-   * duration of the function execution. PostgreSQL advisory locks are session-level,
-   * so we must use the same connection for lock acquisition, operations, and release.
-   *
-   * @param key - A string key to lock on (will be hashed to an integer)
-   * @param fn - The function to execute while holding the lock
-   * @returns The result of the function
-   */
-  async withAdvisoryLock(key, fn) {
-    const lockId = this.hashToInt32(key);
-    const client = await this.pool.connect();
-    try {
-      await client.query("SELECT pg_advisory_lock($1)", [lockId]);
-      return await fn();
-    } finally {
-      try {
-        await client.query("SELECT pg_advisory_unlock($1)", [lockId]);
-      } finally {
-        client.release();
-      }
-    }
-  }
-  // =============================================================================
-  // Observable Sync System Methods
-  // =============================================================================
-  // These methods support long-running syncs with full observability.
-  // Uses two tables: _sync_runs (parent) and _sync_obj_runs (children)
-  // RunKey = (accountId, runStartedAt) - natural composite key
-  /**
-   * Cancel stale runs (running but no object updated in 5 minutes).
-   * Called before creating a new run to clean up crashed syncs.
-   * Only cancels runs that have objects AND none have recent activity.
-   * Runs without objects yet (just created) are not considered stale.
-   */
-  async cancelStaleRuns(accountId) {
-    await this.query(
-      `UPDATE "${this.config.schema}"."_sync_obj_runs" o
-       SET status = 'error',
-           error_message = 'Auto-cancelled: stale (no update in 5 min)',
-           completed_at = now(),
-           page_cursor = NULL
-       WHERE o."_account_id" = $1
-         AND o.status = 'running'
-         AND o.updated_at < now() - interval '5 minutes'`,
-      [accountId]
-    );
-    await this.query(
-      `UPDATE "${this.config.schema}"."_sync_runs" r
-       SET closed_at = now()
-       WHERE r."_account_id" = $1
-         AND r.closed_at IS NULL
-         AND EXISTS (
-           SELECT 1 FROM "${this.config.schema}"."_sync_obj_runs" o
-           WHERE o."_account_id" = r."_account_id"
-             AND o.run_started_at = r.started_at
-         )
-         AND NOT EXISTS (
-           SELECT 1 FROM "${this.config.schema}"."_sync_obj_runs" o
-           WHERE o."_account_id" = r."_account_id"
-             AND o.run_started_at = r.started_at
-             AND o.status IN ('pending', 'running')
-         )`,
-      [accountId]
-    );
-  }
-  /**
-   * Get or create a sync run for this account.
-   * Returns existing run if one is active, otherwise creates new one.
-   * Auto-cancels stale runs before checking.
-   *
-   * @returns RunKey with isNew flag, or null if constraint violation (race condition)
-   */
-  async getOrCreateSyncRun(accountId, triggeredBy) {
-    await this.cancelStaleRuns(accountId);
-    const existing = await this.query(
-      `SELECT "_account_id", started_at FROM "${this.config.schema}"."_sync_runs"
-       WHERE "_account_id" = $1 AND closed_at IS NULL`,
-      [accountId]
-    );
-    if (existing.rows.length > 0) {
-      const row = existing.rows[0];
-      return { accountId: row._account_id, runStartedAt: row.started_at, isNew: false };
-    }
-    try {
-      const result = await this.query(
-        `INSERT INTO "${this.config.schema}"."_sync_runs" ("_account_id", triggered_by, started_at)
-         VALUES ($1, $2, date_trunc('milliseconds', now()))
-         RETURNING "_account_id", started_at`,
-        [accountId, triggeredBy ?? null]
-      );
-      const row = result.rows[0];
-      return { accountId: row._account_id, runStartedAt: row.started_at, isNew: true };
-    } catch (error) {
-      if (error instanceof Error && "code" in error && error.code === "23P01") {
-        return null;
-      }
-      throw error;
-    }
-  }
-  /**
-   * Get the active sync run for an account (if any).
-   */
-  async getActiveSyncRun(accountId) {
-    const result = await this.query(
-      `SELECT "_account_id", started_at FROM "${this.config.schema}"."_sync_runs"
-       WHERE "_account_id" = $1 AND closed_at IS NULL`,
-      [accountId]
-    );
-    if (result.rows.length === 0) return null;
-    const row = result.rows[0];
-    return { accountId: row._account_id, runStartedAt: row.started_at };
-  }
-  /**
-   * Get sync run config (for concurrency control).
-   * Status is derived from sync_runs view.
-   */
-  async getSyncRun(accountId, runStartedAt) {
-    const result = await this.query(
-      `SELECT "_account_id", started_at, max_concurrent, closed_at
-       FROM "${this.config.schema}"."_sync_runs"
-       WHERE "_account_id" = $1 AND started_at = $2`,
-      [accountId, runStartedAt]
-    );
-    if (result.rows.length === 0) return null;
-    const row = result.rows[0];
-    return {
-      accountId: row._account_id,
-      runStartedAt: row.started_at,
-      maxConcurrent: row.max_concurrent,
-      closedAt: row.closed_at
-    };
-  }
-  /**
-   * Close a sync run (mark as done).
-   * Status (complete/error) is derived from object run states.
-   */
-  async closeSyncRun(accountId, runStartedAt) {
-    await this.query(
-      `UPDATE "${this.config.schema}"."_sync_runs"
-       SET closed_at = now()
-       WHERE "_account_id" = $1 AND started_at = $2 AND closed_at IS NULL`,
-      [accountId, runStartedAt]
-    );
-  }
-  /**
-   * Create object run entries for a sync run.
-   * All objects start as 'pending'.
-   *
-   * @param resourceNames - Database resource names (e.g. 'products', 'customers', NOT 'product', 'customer')
-   */
-  async createObjectRuns(accountId, runStartedAt, resourceNames) {
-    if (resourceNames.length === 0) return;
-    const values = resourceNames.map((_, i) => `($1, $2, $${i + 3})`).join(", ");
-    await this.query(
-      `INSERT INTO "${this.config.schema}"."_sync_obj_runs" ("_account_id", run_started_at, object)
-       VALUES ${values}
-       ON CONFLICT ("_account_id", run_started_at, object) DO NOTHING`,
-      [accountId, runStartedAt, ...resourceNames]
-    );
-  }
-  /**
-   * Try to start an object sync (respects max_concurrent).
-   * Returns true if claimed, false if already running or at concurrency limit.
-   *
-   * Note: There's a small race window where concurrent calls could result in
-   * max_concurrent + 1 objects running. This is acceptable behavior.
-   */
-  async tryStartObjectSync(accountId, runStartedAt, object) {
-    const run = await this.getSyncRun(accountId, runStartedAt);
-    if (!run) return false;
-    const runningCount = await this.countRunningObjects(accountId, runStartedAt);
-    if (runningCount >= run.maxConcurrent) return false;
-    const result = await this.query(
-      `UPDATE "${this.config.schema}"."_sync_obj_runs"
-       SET status = 'running', started_at = now(), updated_at = now()
-       WHERE "_account_id" = $1 AND run_started_at = $2 AND object = $3 AND status = 'pending'
-       RETURNING *`,
-      [accountId, runStartedAt, object]
-    );
-    return (result.rowCount ?? 0) > 0;
-  }
-  /**
-   * Get object run details.
-   */
-  async getObjectRun(accountId, runStartedAt, object) {
-    const result = await this.query(
-      `SELECT object, status, processed_count, cursor, page_cursor
-       FROM "${this.config.schema}"."_sync_obj_runs"
-       WHERE "_account_id" = $1 AND run_started_at = $2 AND object = $3`,
-      [accountId, runStartedAt, object]
-    );
-    if (result.rows.length === 0) return null;
-    const row = result.rows[0];
-    return {
-      object: row.object,
-      status: row.status,
-      processedCount: row.processed_count,
-      cursor: row.cursor,
-      pageCursor: row.page_cursor
-    };
-  }
-  /**
-   * Update progress for an object sync.
-   * Also touches updated_at for stale detection.
-   */
-  async incrementObjectProgress(accountId, runStartedAt, object, count) {
-    await this.query(
-      `UPDATE "${this.config.schema}"."_sync_obj_runs"
-       SET processed_count = processed_count + $4, updated_at = now()
-       WHERE "_account_id" = $1 AND run_started_at = $2 AND object = $3`,
-      [accountId, runStartedAt, object, count]
-    );
-  }
-  /**
-   * Update the pagination page_cursor used for backfills using Stripe list calls.
-   */
-  async updateObjectPageCursor(accountId, runStartedAt, object, pageCursor) {
-    await this.query(
-      `UPDATE "${this.config.schema}"."_sync_obj_runs"
-       SET page_cursor = $4, updated_at = now()
-       WHERE "_account_id" = $1 AND run_started_at = $2 AND object = $3`,
-      [accountId, runStartedAt, object, pageCursor]
-    );
-  }
-  /**
-   * Clear the pagination page_cursor for an object sync.
-   */
-  async clearObjectPageCursor(accountId, runStartedAt, object) {
-    await this.updateObjectPageCursor(accountId, runStartedAt, object, null);
-  }
-  /**
-   * Update the cursor for an object sync.
-   * Only updates if the new cursor is higher than the existing one (cursors should never decrease).
-   * For numeric cursors (timestamps), uses GREATEST to ensure monotonic increase.
-   * For non-numeric cursors, just sets the value directly.
-   */
-  async updateObjectCursor(accountId, runStartedAt, object, cursor) {
-    const isNumeric = cursor !== null && /^\d+$/.test(cursor);
-    if (isNumeric) {
-      await this.query(
-        `UPDATE "${this.config.schema}"."_sync_obj_runs"
-         SET cursor = GREATEST(COALESCE(cursor::bigint, 0), $4::bigint)::text,
-             updated_at = now()
-         WHERE "_account_id" = $1 AND run_started_at = $2 AND object = $3`,
-        [accountId, runStartedAt, object, cursor]
-      );
-    } else {
-      await this.query(
-        `UPDATE "${this.config.schema}"."_sync_obj_runs"
-         SET cursor = CASE
-           WHEN cursor IS NULL THEN $4
-           WHEN (cursor COLLATE "C") < ($4::text COLLATE "C") THEN $4
-           ELSE cursor
-         END,
-         updated_at = now()
-         WHERE "_account_id" = $1 AND run_started_at = $2 AND object = $3`,
-        [accountId, runStartedAt, object, cursor]
-      );
-    }
-  }
-  /**
-   * Get the highest cursor from previous syncs for an object type.
-   * Uses only completed object runs.
-   * - During the initial backfill we page through history, but we also update the cursor as we go.
-   *   If we crash mid-backfill and reuse that cursor, we can accidentally switch into incremental mode
-   *   too early and only ever fetch the newest page (breaking the historical backfill).
-   *
-   * Handles two cursor formats:
-   * - Numeric: compared as bigint for correct ordering
-   * - Composite cursors: compared as strings with COLLATE "C"
-   */
-  async getLastCompletedCursor(accountId, object) {
-    const result = await this.query(
-      `SELECT CASE
-         WHEN BOOL_OR(o.cursor !~ '^\\d+$') THEN MAX(o.cursor COLLATE "C")
-         ELSE MAX(CASE WHEN o.cursor ~ '^\\d+$' THEN o.cursor::bigint END)::text
-       END as cursor
-       FROM "${this.config.schema}"."_sync_obj_runs" o
-       WHERE o."_account_id" = $1
-         AND o.object = $2
-         AND o.cursor IS NOT NULL
-         AND o.status = 'complete'`,
-      [accountId, object]
-    );
-    return result.rows[0]?.cursor ?? null;
-  }
-  /**
-   * Get the highest cursor from previous syncs for an object type, excluding the current run.
-   */
-  async getLastCursorBeforeRun(accountId, object, runStartedAt) {
-    const result = await this.query(
-      `SELECT CASE
-         WHEN BOOL_OR(o.cursor !~ '^\\d+$') THEN MAX(o.cursor COLLATE "C")
-         ELSE MAX(CASE WHEN o.cursor ~ '^\\d+$' THEN o.cursor::bigint END)::text
-       END as cursor
-       FROM "${this.config.schema}"."_sync_obj_runs" o
-       WHERE o."_account_id" = $1
-         AND o.object = $2
-         AND o.cursor IS NOT NULL
-         AND o.status = 'complete'
-         AND o.run_started_at < $3`,
-      [accountId, object, runStartedAt]
-    );
-    return result.rows[0]?.cursor ?? null;
-  }
-  /**
-   * Delete all sync runs and object runs for an account.
-   * Useful for testing or resetting sync state.
-   */
-  async deleteSyncRuns(accountId) {
-    await this.query(
-      `DELETE FROM "${this.config.schema}"."_sync_obj_runs" WHERE "_account_id" = $1`,
-      [accountId]
-    );
-    await this.query(`DELETE FROM "${this.config.schema}"."_sync_runs" WHERE "_account_id" = $1`, [
-      accountId
-    ]);
-  }
-  /**
-   * Mark an object sync as complete.
-   * Auto-closes the run when all objects are done.
-   */
-  async completeObjectSync(accountId, runStartedAt, object) {
-    await this.query(
-      `UPDATE "${this.config.schema}"."_sync_obj_runs"
-       SET status = 'complete', completed_at = now(), page_cursor = NULL
-       WHERE "_account_id" = $1 AND run_started_at = $2 AND object = $3`,
-      [accountId, runStartedAt, object]
-    );
-    const allDone = await this.areAllObjectsComplete(accountId, runStartedAt);
-    if (allDone) {
-      await this.closeSyncRun(accountId, runStartedAt);
-    }
-  }
-  /**
-   * Mark an object sync as failed.
-   * Auto-closes the run when all objects are done.
-   */
-  async failObjectSync(accountId, runStartedAt, object, errorMessage) {
-    await this.query(
-      `UPDATE "${this.config.schema}"."_sync_obj_runs"
-       SET status = 'error', error_message = $4, completed_at = now(), page_cursor = NULL
-       WHERE "_account_id" = $1 AND run_started_at = $2 AND object = $3`,
-      [accountId, runStartedAt, object, errorMessage]
-    );
-    const allDone = await this.areAllObjectsComplete(accountId, runStartedAt);
-    if (allDone) {
-      await this.closeSyncRun(accountId, runStartedAt);
-    }
-  }
-  /**
-   * Check if any object in a run has errored.
-   */
-  async hasAnyObjectErrors(accountId, runStartedAt) {
-    const result = await this.query(
-      `SELECT COUNT(*) as count FROM "${this.config.schema}"."_sync_obj_runs"
-       WHERE "_account_id" = $1 AND run_started_at = $2 AND status = 'error'`,
-      [accountId, runStartedAt]
-    );
-    return parseInt(result.rows[0].count) > 0;
-  }
-  /**
-   * Count running objects in a run.
-   */
-  async countRunningObjects(accountId, runStartedAt) {
-    const result = await this.query(
-      `SELECT COUNT(*) as count FROM "${this.config.schema}"."_sync_obj_runs"
-       WHERE "_account_id" = $1 AND run_started_at = $2 AND status = 'running'`,
-      [accountId, runStartedAt]
-    );
-    return parseInt(result.rows[0].count);
-  }
-  /**
-   * Get the next pending object to process.
-   * Returns null if no pending objects or at concurrency limit.
-   */
-  async getNextPendingObject(accountId, runStartedAt) {
-    const run = await this.getSyncRun(accountId, runStartedAt);
-    if (!run) return null;
-    const runningCount = await this.countRunningObjects(accountId, runStartedAt);
-    if (runningCount >= run.maxConcurrent) return null;
-    const result = await this.query(
-      `SELECT object FROM "${this.config.schema}"."_sync_obj_runs"
-       WHERE "_account_id" = $1 AND run_started_at = $2 AND status = 'pending'
-       ORDER BY object
-       LIMIT 1`,
-      [accountId, runStartedAt]
-    );
-    return result.rows.length > 0 ? result.rows[0].object : null;
-  }
-  /**
-   * Check if all objects in a run are complete (or error).
-   */
-  async areAllObjectsComplete(accountId, runStartedAt) {
-    const result = await this.query(
-      `SELECT COUNT(*) as count FROM "${this.config.schema}"."_sync_obj_runs"
-       WHERE "_account_id" = $1 AND run_started_at = $2 AND status IN ('pending', 'running')`,
-      [accountId, runStartedAt]
-    );
-    return parseInt(result.rows[0].count) === 0;
-  }
-  /**
-   * Closes the database connection pool and cleans up resources.
-   * Call this when you're done using the PostgresClient instance.
-   */
-  async close() {
-    await this.pool.end();
-  }
-};
-
-// src/schemas/managed_webhook.ts
-var managedWebhookSchema = {
-  properties: [
-    "id",
-    "object",
-    "url",
-    "enabled_events",
-    "description",
-    "enabled",
-    "livemode",
-    "metadata",
-    "secret",
-    "status",
-    "api_version",
-    "created",
-    "account_id"
-  ]
-};
-
-// src/utils/retry.ts
-import Stripe from "stripe";
-var DEFAULT_RETRY_CONFIG = {
-  maxRetries: 5,
-  initialDelayMs: 1e3,
-  // 1 second
-  maxDelayMs: 6e4,
-  // 60 seconds
-  jitterMs: 500
-  // randomization to prevent thundering herd
-};
-function isRetryableError(error) {
-  if (error instanceof Stripe.errors.StripeRateLimitError) {
-    return true;
-  }
-  if (error instanceof Stripe.errors.StripeAPIError) {
-    const statusCode = error.statusCode;
-    if (statusCode && [500, 502, 503, 504, 424].includes(statusCode)) {
-      return true;
-    }
-  }
-  if (error instanceof Stripe.errors.StripeConnectionError) {
-    return true;
-  }
-  return false;
-}
-function getRetryAfterMs(error) {
-  if (!(error instanceof Stripe.errors.StripeRateLimitError)) {
-    return null;
-  }
-  const retryAfterHeader = error.headers?.["retry-after"];
-  if (!retryAfterHeader) {
-    return null;
-  }
-  const retryAfterSeconds = Number(retryAfterHeader);
-  if (isNaN(retryAfterSeconds) || retryAfterSeconds <= 0) {
-    return null;
-  }
-  return retryAfterSeconds * 1e3;
-}
-function calculateDelay(attempt, config, retryAfterMs) {
-  if (retryAfterMs !== null && retryAfterMs !== void 0) {
-    const jitter2 = Math.random() * config.jitterMs;
-    return retryAfterMs + jitter2;
-  }
-  const exponentialDelay = Math.min(config.initialDelayMs * Math.pow(2, attempt), config.maxDelayMs);
-  const jitter = Math.random() * config.jitterMs;
-  return exponentialDelay + jitter;
-}
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function getErrorType(error) {
-  if (error instanceof Stripe.errors.StripeRateLimitError) {
-    return "rate_limit";
-  }
-  if (error instanceof Stripe.errors.StripeAPIError) {
-    return `api_error_${error.statusCode}`;
-  }
-  if (error instanceof Stripe.errors.StripeConnectionError) {
-    return "connection_error";
-  }
-  return "unknown";
-}
-async function withRetry(fn, config = {}, logger) {
-  const retryConfig = { ...DEFAULT_RETRY_CONFIG, ...config };
-  let lastError;
-  for (let attempt = 0; attempt <= retryConfig.maxRetries; attempt++) {
-    try {
-      return await fn();
-    } catch (error) {
-      lastError = error;
-      if (!isRetryableError(error)) {
-        throw error;
-      }
-      if (attempt >= retryConfig.maxRetries) {
-        logger?.error(
-          {
-            error: error instanceof Error ? error.message : String(error),
-            errorType: getErrorType(error),
-            attempt: attempt + 1,
-            maxRetries: retryConfig.maxRetries
-          },
-          "Max retries exhausted for Stripe error"
-        );
-        throw error;
-      }
-      const retryAfterMs = getRetryAfterMs(error);
-      const delay = calculateDelay(attempt, retryConfig, retryAfterMs);
-      logger?.warn(
-        {
-          error: error instanceof Error ? error.message : String(error),
-          errorType: getErrorType(error),
-          attempt: attempt + 1,
-          maxRetries: retryConfig.maxRetries,
-          delayMs: Math.round(delay),
-          retryAfterMs: retryAfterMs ?? void 0,
-          nextAttempt: attempt + 2
-        },
-        "Transient Stripe error, retrying after delay"
-      );
-      await sleep(delay);
-    }
-  }
-  throw lastError;
-}
-
-// src/utils/stripeClientWrapper.ts
-function createRetryableStripeClient(stripe, retryConfig = {}, logger) {
-  return new Proxy(stripe, {
-    get(target, prop, receiver) {
-      const original = Reflect.get(target, prop, receiver);
-      if (original && typeof original === "object" && !isPromise(original)) {
-        return wrapResource(original, retryConfig, logger);
-      }
-      return original;
-    }
-  });
-}
-function wrapResource(resource, retryConfig, logger) {
-  return new Proxy(resource, {
-    get(target, prop, receiver) {
-      const original = Reflect.get(target, prop, receiver);
-      if (typeof original === "function") {
-        return function(...args) {
-          const result = original.apply(target, args);
-          if (result && typeof result === "object" && Symbol.asyncIterator in result) {
-            return result;
-          }
-          if (isPromise(result)) {
-            return withRetry(() => Promise.resolve(result), retryConfig, logger);
-          }
-          return result;
-        };
-      }
-      if (original && typeof original === "object" && !isPromise(original)) {
-        return wrapResource(original, retryConfig, logger);
-      }
-      return original;
-    }
-  });
-}
-function isPromise(value) {
-  return value !== null && typeof value === "object" && typeof value.then === "function";
-}
-
-// src/utils/hashApiKey.ts
-import { createHash } from "crypto";
-function hashApiKey(apiKey) {
-  return createHash("sha256").update(apiKey).digest("hex");
-}
-
-// src/sigma/sigmaApi.ts
-import Papa from "papaparse";
-import Stripe2 from "stripe";
-var STRIPE_FILES_BASE = "https://files.stripe.com/v1";
-function sleep2(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function parseCsvObjects(csv) {
-  const input = csv.replace(/^\uFEFF/, "");
-  const parsed = Papa.parse(input, {
-    header: true,
-    skipEmptyLines: "greedy"
-  });
-  if (parsed.errors.length > 0) {
-    throw new Error(`Failed to parse Sigma CSV: ${parsed.errors[0]?.message ?? "unknown error"}`);
-  }
-  return parsed.data.filter((row) => row && Object.keys(row).length > 0).map(
-    (row) => Object.fromEntries(
-      Object.entries(row).map(([k, v]) => [k, v == null || v === "" ? null : String(v)])
-    )
-  );
-}
-function normalizeSigmaTimestampToIso(value) {
-  const v = value.trim();
-  if (!v) return null;
-  const hasExplicitTz = /z$|[+-]\d{2}:?\d{2}$/i.test(v);
-  const isoish = v.includes("T") ? v : v.replace(" ", "T");
-  const candidate = hasExplicitTz ? isoish : `${isoish}Z`;
-  const d = new Date(candidate);
-  if (Number.isNaN(d.getTime())) return null;
-  return d.toISOString();
-}
-async function fetchStripeText(url, apiKey, options) {
-  const res = await fetch(url, {
-    ...options,
-    headers: {
-      ...options.headers ?? {},
-      Authorization: `Bearer ${apiKey}`
-    }
-  });
-  const text = await res.text();
-  if (!res.ok) {
-    throw new Error(`Sigma file download error (${res.status}) for ${url}: ${text}`);
-  }
-  return text;
-}
-async function runSigmaQueryAndDownloadCsv(params) {
-  const pollTimeoutMs = params.pollTimeoutMs ?? 5 * 60 * 1e3;
-  const pollIntervalMs = params.pollIntervalMs ?? 2e3;
-  const stripe = new Stripe2(params.apiKey, {
-    appInfo: {
-      name: "Stripe Sync Engine",
-      version: package_default.version,
-      url: package_default.homepage
-    }
-  });
-  const created = await stripe.rawRequest("POST", "/v1/sigma/query_runs", {
-    sql: params.sql
-  });
-  const queryRunId = created.id;
-  const start = Date.now();
-  let current = created;
-  while (current.status === "running") {
-    if (Date.now() - start > pollTimeoutMs) {
-      throw new Error(`Sigma query run timed out after ${pollTimeoutMs}ms: ${queryRunId}`);
-    }
-    await sleep2(pollIntervalMs);
-    current = await stripe.rawRequest(
-      "GET",
-      `/v1/sigma/query_runs/${queryRunId}`,
-      {}
-    );
-  }
-  if (current.status !== "succeeded") {
-    throw new Error(
-      `Sigma query run did not succeed (status=${current.status}) id=${queryRunId} error=${JSON.stringify(
-        current.error
-      )}`
-    );
-  }
-  const fileId = current.result?.file;
-  if (!fileId) {
-    throw new Error(`Sigma query run succeeded but result.file is missing (id=${queryRunId})`);
-  }
-  const csv = await fetchStripeText(
-    `${STRIPE_FILES_BASE}/files/${fileId}/contents`,
-    params.apiKey,
-    { method: "GET" }
-  );
-  return { queryRunId, fileId, csv };
-}
-
-// src/sigma/sigmaIngestionConfigs.ts
-var SIGMA_INGESTION_CONFIGS = {
-  subscription_item_change_events_v2_beta: {
-    sigmaTable: "subscription_item_change_events_v2_beta",
-    destinationTable: "subscription_item_change_events_v2_beta",
-    pageSize: 1e4,
-    cursor: {
-      version: 1,
-      columns: [
-        { column: "event_timestamp", type: "timestamp" },
-        { column: "event_type", type: "string" },
-        { column: "subscription_item_id", type: "string" }
-      ]
-    },
-    upsert: {
-      conflictTarget: ["_account_id", "event_timestamp", "event_type", "subscription_item_id"],
-      extraColumns: [
-        { column: "event_timestamp", pgType: "timestamptz", entryKey: "event_timestamp" },
-        { column: "event_type", pgType: "text", entryKey: "event_type" },
-        { column: "subscription_item_id", pgType: "text", entryKey: "subscription_item_id" }
-      ]
-    }
-  },
-  exchange_rates_from_usd: {
-    sigmaTable: "exchange_rates_from_usd",
-    destinationTable: "exchange_rates_from_usd",
-    pageSize: 1e4,
-    cursor: {
-      version: 1,
-      columns: [
-        { column: "date", type: "string" },
-        { column: "sell_currency", type: "string" }
-      ]
-    },
-    upsert: {
-      conflictTarget: ["_account_id", "date", "sell_currency"],
-      extraColumns: [
-        { column: "date", pgType: "date", entryKey: "date" },
-        { column: "sell_currency", pgType: "text", entryKey: "sell_currency" }
-      ]
-    }
-  }
-};
-
-// src/sigma/sigmaIngestion.ts
-var SIGMA_CURSOR_DELIM = "";
-function escapeSigmaSqlStringLiteral(value) {
-  return value.replace(/'/g, "''");
-}
-function formatSigmaTimestampForSqlLiteral(date) {
-  return date.toISOString().replace("T", " ").replace("Z", "");
-}
-function decodeSigmaCursorValues(spec, cursor) {
-  const prefix = `v${spec.version}${SIGMA_CURSOR_DELIM}`;
-  if (!cursor.startsWith(prefix)) {
-    throw new Error(
-      `Unrecognized Sigma cursor format (expected prefix ${JSON.stringify(prefix)}): ${cursor}`
-    );
-  }
-  const parts = cursor.split(SIGMA_CURSOR_DELIM);
-  const expected = 1 + spec.columns.length;
-  if (parts.length !== expected) {
-    throw new Error(`Malformed Sigma cursor: expected ${expected} parts, got ${parts.length}`);
-  }
-  return parts.slice(1);
-}
-function encodeSigmaCursor(spec, values) {
-  if (values.length !== spec.columns.length) {
-    throw new Error(
-      `Cannot encode Sigma cursor: expected ${spec.columns.length} values, got ${values.length}`
-    );
-  }
-  for (const v of values) {
-    if (v.includes(SIGMA_CURSOR_DELIM)) {
-      throw new Error("Cannot encode Sigma cursor: value contains delimiter character");
-    }
-  }
-  return [`v${spec.version}`, ...values].join(SIGMA_CURSOR_DELIM);
-}
-function sigmaSqlLiteralForCursorValue(spec, rawValue) {
-  switch (spec.type) {
-    case "timestamp": {
-      const d = new Date(rawValue);
-      if (Number.isNaN(d.getTime())) {
-        throw new Error(`Invalid timestamp cursor value for ${spec.column}: ${rawValue}`);
-      }
-      return `timestamp '${formatSigmaTimestampForSqlLiteral(d)}'`;
-    }
-    case "number": {
-      if (!/^-?\d+(\.\d+)?$/.test(rawValue)) {
-        throw new Error(`Invalid numeric cursor value for ${spec.column}: ${rawValue}`);
-      }
-      return rawValue;
-    }
-    case "string":
-      return `'${escapeSigmaSqlStringLiteral(rawValue)}'`;
-  }
-}
-function buildSigmaCursorWhereClause(spec, cursorValues) {
-  if (cursorValues.length !== spec.columns.length) {
-    throw new Error(
-      `Cannot build Sigma cursor predicate: expected ${spec.columns.length} values, got ${cursorValues.length}`
-    );
-  }
-  const cols = spec.columns.map((c) => c.column);
-  const lits = spec.columns.map((c, i) => sigmaSqlLiteralForCursorValue(c, cursorValues[i] ?? ""));
-  const ors = [];
-  for (let i = 0; i < cols.length; i++) {
-    const ands = [];
-    for (let j = 0; j < i; j++) {
-      ands.push(`${cols[j]} = ${lits[j]}`);
-    }
-    ands.push(`${cols[i]} > ${lits[i]}`);
-    ors.push(`(${ands.join(" AND ")})`);
-  }
-  return ors.join(" OR ");
-}
-function buildSigmaQuery(config, cursor) {
-  const select = config.select === void 0 || config.select === "*" ? "*" : config.select.join(", ");
-  const whereParts = [];
-  if (config.additionalWhere) {
-    whereParts.push(`(${config.additionalWhere})`);
-  }
-  if (cursor) {
-    const values = decodeSigmaCursorValues(config.cursor, cursor);
-    const predicate = buildSigmaCursorWhereClause(config.cursor, values);
-    whereParts.push(`(${predicate})`);
-  }
-  const whereClause = whereParts.length > 0 ? `WHERE ${whereParts.join(" AND ")}` : "";
-  const orderBy = config.cursor.columns.map((c) => c.column).join(", ");
-  return [
-    `SELECT ${select} FROM ${config.sigmaTable}`,
-    whereClause,
-    `ORDER BY ${orderBy} ASC`,
-    `LIMIT ${config.pageSize}`
-  ].filter(Boolean).join(" ");
-}
-function defaultSigmaRowToEntry(config, row) {
-  const out = { ...row };
-  for (const col of config.cursor.columns) {
-    const raw = row[col.column];
-    if (raw == null) {
-      throw new Error(`Sigma row missing required cursor column: ${col.column}`);
-    }
-    if (col.type === "timestamp") {
-      const normalized = normalizeSigmaTimestampToIso(raw);
-      if (!normalized) {
-        throw new Error(`Sigma row has invalid timestamp for ${col.column}: ${raw}`);
-      }
-      out[col.column] = normalized;
-    } else if (col.type === "string") {
-      const v = raw.trim();
-      if (!v) {
-        throw new Error(`Sigma row has empty string for required cursor column: ${col.column}`);
-      }
-      out[col.column] = v;
-    } else {
-      const v = raw.trim();
-      if (!v) {
-        throw new Error(`Sigma row has empty value for required cursor column: ${col.column}`);
-      }
-      out[col.column] = v;
-    }
-  }
-  return out;
-}
-function sigmaCursorFromEntry(config, entry) {
-  const values = config.cursor.columns.map((c) => {
-    const raw = entry[c.column];
-    if (raw == null) {
-      throw new Error(`Cannot build cursor: entry missing ${c.column}`);
-    }
-    return String(raw);
-  });
-  return encodeSigmaCursor(config.cursor, values);
-}
-
-// src/stripeSync.ts
-function getUniqueIds(entries, key) {
-  const set = new Set(
-    entries.map((subscription) => subscription?.[key]?.toString()).filter((it) => Boolean(it))
-  );
-  return Array.from(set);
-}
-var StripeSync = class {
-  constructor(config) {
-    this.config = config;
-    const baseStripe = new Stripe3(config.stripeSecretKey, {
-      // https://github.com/stripe/stripe-node#configuration
-      // @ts-ignore
-      apiVersion: config.stripeApiVersion,
-      appInfo: {
-        name: "Stripe Sync Engine",
-        version: package_default.version,
-        url: package_default.homepage
-      }
-    });
-    this.stripe = createRetryableStripeClient(baseStripe, {}, config.logger);
-    this.config.logger = config.logger ?? console;
-    this.config.logger?.info(
-      { autoExpandLists: config.autoExpandLists, stripeApiVersion: config.stripeApiVersion },
-      "StripeSync initialized"
-    );
-    const poolConfig = config.poolConfig ?? {};
-    if (config.databaseUrl) {
-      poolConfig.connectionString = config.databaseUrl;
-    }
-    if (config.maxPostgresConnections) {
-      poolConfig.max = config.maxPostgresConnections;
-    }
-    if (poolConfig.max === void 0) {
-      poolConfig.max = 10;
-    }
-    if (poolConfig.keepAlive === void 0) {
-      poolConfig.keepAlive = true;
-    }
-    this.postgresClient = new PostgresClient({
-      schema: "stripe",
-      poolConfig
-    });
-  }
-  stripe;
-  postgresClient;
-  /**
-   * Get the Stripe account ID. Delegates to getCurrentAccount() for the actual lookup.
-   */
-  async getAccountId(objectAccountId) {
-    const account = await this.getCurrentAccount(objectAccountId);
-    if (!account) {
-      throw new Error("Failed to retrieve Stripe account. Please ensure API key is valid.");
-    }
-    return account.id;
-  }
-  /**
-   * Upsert Stripe account information to the database
-   * @param account - Stripe account object
-   * @param apiKeyHash - SHA-256 hash of API key to store for fast lookups
-   */
-  async upsertAccount(account, apiKeyHash) {
-    try {
-      await this.postgresClient.upsertAccount(
-        {
-          id: account.id,
-          raw_data: account
-        },
-        apiKeyHash
-      );
-    } catch (error) {
-      this.config.logger?.error(error, "Failed to upsert account to database");
-      const errorMessage = error instanceof Error ? error.message : "Unknown error";
-      throw new Error(`Failed to upsert account to database: ${errorMessage}`);
-    }
-  }
-  /**
-   * Get the current account being synced. Uses database lookup by API key hash,
-   * with fallback to Stripe API if not found (first-time setup or new API key).
-   * @param objectAccountId - Optional account ID from event data (Connect scenarios)
-   */
-  async getCurrentAccount(objectAccountId) {
-    const apiKeyHash = hashApiKey(this.config.stripeSecretKey);
-    try {
-      const account = await this.postgresClient.getAccountByApiKeyHash(apiKeyHash);
-      if (account) {
-        return account;
-      }
-    } catch (error) {
-      this.config.logger?.warn(
-        error,
-        "Failed to lookup account by API key hash, falling back to API"
-      );
-    }
-    try {
-      const accountIdParam = objectAccountId || this.config.stripeAccountId;
-      const account = accountIdParam ? await this.stripe.accounts.retrieve(accountIdParam) : await this.stripe.accounts.retrieve();
-      await this.upsertAccount(account, apiKeyHash);
-      return account;
-    } catch (error) {
-      this.config.logger?.error(error, "Failed to retrieve account from Stripe API");
-      return null;
-    }
-  }
-  /**
-   * Get all accounts that have been synced to the database
-   */
-  async getAllSyncedAccounts() {
-    try {
-      const accountsData = await this.postgresClient.getAllAccounts();
-      return accountsData;
-    } catch (error) {
-      this.config.logger?.error(error, "Failed to retrieve accounts from database");
-      throw new Error("Failed to retrieve synced accounts from database");
-    }
-  }
-  /**
-   * DANGEROUS: Delete an account and all associated data from the database
-   * This operation cannot be undone!
-   *
-   * @param accountId - The Stripe account ID to delete
-   * @param options - Options for deletion behavior
-   * @param options.dryRun - If true, only count records without deleting (default: false)
-   * @param options.useTransaction - If true, use transaction for atomic deletion (default: true)
-   * @returns Deletion summary with counts and warnings
-   */
-  async dangerouslyDeleteSyncedAccountData(accountId, options) {
-    const dryRun = options?.dryRun ?? false;
-    const useTransaction = options?.useTransaction ?? true;
-    this.config.logger?.info(
-      `${dryRun ? "Preview" : "Deleting"} account ${accountId} (transaction: ${useTransaction})`
-    );
-    try {
-      const counts = await this.postgresClient.getAccountRecordCounts(accountId);
-      const warnings = [];
-      let totalRecords = 0;
-      for (const [table, count] of Object.entries(counts)) {
-        if (count > 0) {
-          totalRecords += count;
-          warnings.push(`Will delete ${count} ${table} record${count !== 1 ? "s" : ""}`);
-        }
-      }
-      if (totalRecords > 1e5) {
-        warnings.push(
-          `Large dataset detected (${totalRecords} total records). Consider using useTransaction: false for better performance.`
-        );
-      }
-      if (dryRun) {
-        this.config.logger?.info(`Dry-run complete: ${totalRecords} total records would be deleted`);
-        return {
-          deletedAccountId: accountId,
-          deletedRecordCounts: counts,
-          warnings
-        };
-      }
-      const deletionCounts = await this.postgresClient.deleteAccountWithCascade(
-        accountId,
-        useTransaction
-      );
-      this.config.logger?.info(
-        `Successfully deleted account ${accountId} with ${totalRecords} total records`
-      );
-      return {
-        deletedAccountId: accountId,
-        deletedRecordCounts: deletionCounts,
-        warnings
-      };
-    } catch (error) {
-      this.config.logger?.error(error, `Failed to delete account ${accountId}`);
-      const errorMessage = error instanceof Error ? error.message : "Unknown error";
-      throw new Error(`Failed to delete account ${accountId}: ${errorMessage}`);
-    }
-  }
-  async processWebhook(payload, signature) {
-    let webhookSecret = this.config.stripeWebhookSecret;
-    if (!webhookSecret) {
-      const accountId = await this.getAccountId();
-      const result = await this.postgresClient.query(
-        `SELECT secret FROM "stripe"."_managed_webhooks" WHERE account_id = $1 LIMIT 1`,
-        [accountId]
-      );
-      if (result.rows.length > 0) {
-        webhookSecret = result.rows[0].secret;
-      }
-    }
-    if (!webhookSecret) {
-      throw new Error(
-        "No webhook secret provided. Either create a managed webhook or configure stripeWebhookSecret."
-      );
-    }
-    const event = await this.stripe.webhooks.constructEventAsync(payload, signature, webhookSecret);
-    return this.processEvent(event);
-  }
-  // Event handler registry - maps event types to handler functions
-  // Note: Uses 'any' for event parameter to allow handlers with specific Stripe event types
-  // (e.g., CustomerDeletedEvent, ProductDeletedEvent) which TypeScript won't accept
-  // as contravariant parameters when using the base Stripe.Event type
-  eventHandlers = {
-    "charge.captured": this.handleChargeEvent.bind(this),
-    "charge.expired": this.handleChargeEvent.bind(this),
-    "charge.failed": this.handleChargeEvent.bind(this),
-    "charge.pending": this.handleChargeEvent.bind(this),
-    "charge.refunded": this.handleChargeEvent.bind(this),
-    "charge.succeeded": this.handleChargeEvent.bind(this),
-    "charge.updated": this.handleChargeEvent.bind(this),
-    "customer.deleted": this.handleCustomerDeletedEvent.bind(this),
-    "customer.created": this.handleCustomerEvent.bind(this),
-    "customer.updated": this.handleCustomerEvent.bind(this),
-    "checkout.session.async_payment_failed": this.handleCheckoutSessionEvent.bind(this),
-    "checkout.session.async_payment_succeeded": this.handleCheckoutSessionEvent.bind(this),
-    "checkout.session.completed": this.handleCheckoutSessionEvent.bind(this),
-    "checkout.session.expired": this.handleCheckoutSessionEvent.bind(this),
-    "customer.subscription.created": this.handleSubscriptionEvent.bind(this),
-    "customer.subscription.deleted": this.handleSubscriptionEvent.bind(this),
-    "customer.subscription.paused": this.handleSubscriptionEvent.bind(this),
-    "customer.subscription.pending_update_applied": this.handleSubscriptionEvent.bind(this),
-    "customer.subscription.pending_update_expired": this.handleSubscriptionEvent.bind(this),
-    "customer.subscription.trial_will_end": this.handleSubscriptionEvent.bind(this),
-    "customer.subscription.resumed": this.handleSubscriptionEvent.bind(this),
-    "customer.subscription.updated": this.handleSubscriptionEvent.bind(this),
-    "customer.tax_id.updated": this.handleTaxIdEvent.bind(this),
-    "customer.tax_id.created": this.handleTaxIdEvent.bind(this),
-    "customer.tax_id.deleted": this.handleTaxIdDeletedEvent.bind(this),
-    "invoice.created": this.handleInvoiceEvent.bind(this),
-    "invoice.deleted": this.handleInvoiceEvent.bind(this),
-    "invoice.finalized": this.handleInvoiceEvent.bind(this),
-    "invoice.finalization_failed": this.handleInvoiceEvent.bind(this),
-    "invoice.paid": this.handleInvoiceEvent.bind(this),
-    "invoice.payment_action_required": this.handleInvoiceEvent.bind(this),
-    "invoice.payment_failed": this.handleInvoiceEvent.bind(this),
-    "invoice.payment_succeeded": this.handleInvoiceEvent.bind(this),
-    "invoice.upcoming": this.handleInvoiceEvent.bind(this),
-    "invoice.sent": this.handleInvoiceEvent.bind(this),
-    "invoice.voided": this.handleInvoiceEvent.bind(this),
-    "invoice.marked_uncollectible": this.handleInvoiceEvent.bind(this),
-    "invoice.updated": this.handleInvoiceEvent.bind(this),
-    "product.created": this.handleProductEvent.bind(this),
-    "product.updated": this.handleProductEvent.bind(this),
-    "product.deleted": this.handleProductDeletedEvent.bind(this),
-    "price.created": this.handlePriceEvent.bind(this),
-    "price.updated": this.handlePriceEvent.bind(this),
-    "price.deleted": this.handlePriceDeletedEvent.bind(this),
-    "plan.created": this.handlePlanEvent.bind(this),
-    "plan.updated": this.handlePlanEvent.bind(this),
-    "plan.deleted": this.handlePlanDeletedEvent.bind(this),
-    "setup_intent.canceled": this.handleSetupIntentEvent.bind(this),
-    "setup_intent.created": this.handleSetupIntentEvent.bind(this),
-    "setup_intent.requires_action": this.handleSetupIntentEvent.bind(this),
-    "setup_intent.setup_failed": this.handleSetupIntentEvent.bind(this),
-    "setup_intent.succeeded": this.handleSetupIntentEvent.bind(this),
-    "subscription_schedule.aborted": this.handleSubscriptionScheduleEvent.bind(this),
-    "subscription_schedule.canceled": this.handleSubscriptionScheduleEvent.bind(this),
-    "subscription_schedule.completed": this.handleSubscriptionScheduleEvent.bind(this),
-    "subscription_schedule.created": this.handleSubscriptionScheduleEvent.bind(this),
-    "subscription_schedule.expiring": this.handleSubscriptionScheduleEvent.bind(this),
-    "subscription_schedule.released": this.handleSubscriptionScheduleEvent.bind(this),
-    "subscription_schedule.updated": this.handleSubscriptionScheduleEvent.bind(this),
-    "payment_method.attached": this.handlePaymentMethodEvent.bind(this),
-    "payment_method.automatically_updated": this.handlePaymentMethodEvent.bind(this),
-    "payment_method.detached": this.handlePaymentMethodEvent.bind(this),
-    "payment_method.updated": this.handlePaymentMethodEvent.bind(this),
-    "charge.dispute.created": this.handleDisputeEvent.bind(this),
-    "charge.dispute.funds_reinstated": this.handleDisputeEvent.bind(this),
-    "charge.dispute.funds_withdrawn": this.handleDisputeEvent.bind(this),
-    "charge.dispute.updated": this.handleDisputeEvent.bind(this),
-    "charge.dispute.closed": this.handleDisputeEvent.bind(this),
-    "payment_intent.amount_capturable_updated": this.handlePaymentIntentEvent.bind(this),
-    "payment_intent.canceled": this.handlePaymentIntentEvent.bind(this),
-    "payment_intent.created": this.handlePaymentIntentEvent.bind(this),
-    "payment_intent.partially_funded": this.handlePaymentIntentEvent.bind(this),
-    "payment_intent.payment_failed": this.handlePaymentIntentEvent.bind(this),
-    "payment_intent.processing": this.handlePaymentIntentEvent.bind(this),
-    "payment_intent.requires_action": this.handlePaymentIntentEvent.bind(this),
-    "payment_intent.succeeded": this.handlePaymentIntentEvent.bind(this),
-    "credit_note.created": this.handleCreditNoteEvent.bind(this),
-    "credit_note.updated": this.handleCreditNoteEvent.bind(this),
-    "credit_note.voided": this.handleCreditNoteEvent.bind(this),
-    "radar.early_fraud_warning.created": this.handleEarlyFraudWarningEvent.bind(this),
-    "radar.early_fraud_warning.updated": this.handleEarlyFraudWarningEvent.bind(this),
-    "refund.created": this.handleRefundEvent.bind(this),
-    "refund.failed": this.handleRefundEvent.bind(this),
-    "refund.updated": this.handleRefundEvent.bind(this),
-    "charge.refund.updated": this.handleRefundEvent.bind(this),
-    "review.closed": this.handleReviewEvent.bind(this),
-    "review.opened": this.handleReviewEvent.bind(this),
-    "entitlements.active_entitlement_summary.updated": this.handleEntitlementSummaryEvent.bind(this)
-  };
-  // Resource registry - maps SyncObject → list/upsert operations for processNext()
-  // Complements eventHandlers which maps event types → handlers for webhooks
-  // Both registries share the same underlying upsert methods
-  // Order field determines backfill sequence - parents before children for FK dependencies
-  resourceRegistry = {
-    product: {
-      order: 1,
-      // No dependencies
-      listFn: (p) => this.stripe.products.list(p),
-      upsertFn: (items, id) => this.upsertProducts(items, id),
-      supportsCreatedFilter: true
-    },
-    price: {
-      order: 2,
-      // Depends on product
-      listFn: (p) => this.stripe.prices.list(p),
-      upsertFn: (items, id, bf) => this.upsertPrices(items, id, bf),
-      supportsCreatedFilter: true
-    },
-    plan: {
-      order: 3,
-      // Depends on product
-      listFn: (p) => this.stripe.plans.list(p),
-      upsertFn: (items, id, bf) => this.upsertPlans(items, id, bf),
-      supportsCreatedFilter: true
-    },
-    customer: {
-      order: 4,
-      // No dependencies
-      listFn: (p) => this.stripe.customers.list(p),
-      upsertFn: (items, id) => this.upsertCustomers(items, id),
-      supportsCreatedFilter: true
-    },
-    subscription: {
-      order: 5,
-      // Depends on customer, price
-      listFn: (p) => this.stripe.subscriptions.list(p),
-      upsertFn: (items, id, bf) => this.upsertSubscriptions(items, id, bf),
-      supportsCreatedFilter: true
-    },
-    subscription_schedules: {
-      order: 6,
-      // Depends on customer
-      listFn: (p) => this.stripe.subscriptionSchedules.list(p),
-      upsertFn: (items, id, bf) => this.upsertSubscriptionSchedules(items, id, bf),
-      supportsCreatedFilter: true
-    },
-    invoice: {
-      order: 7,
-      // Depends on customer, subscription
-      listFn: (p) => this.stripe.invoices.list(p),
-      upsertFn: (items, id, bf) => this.upsertInvoices(items, id, bf),
-      supportsCreatedFilter: true
-    },
-    charge: {
-      order: 8,
-      // Depends on customer, invoice
-      listFn: (p) => this.stripe.charges.list(p),
-      upsertFn: (items, id, bf) => this.upsertCharges(items, id, bf),
-      supportsCreatedFilter: true
-    },
-    setup_intent: {
-      order: 9,
-      // Depends on customer
-      listFn: (p) => this.stripe.setupIntents.list(p),
-      upsertFn: (items, id, bf) => this.upsertSetupIntents(items, id, bf),
-      supportsCreatedFilter: true
-    },
-    payment_method: {
-      order: 10,
-      // Depends on customer (special: iterates customers)
-      listFn: (p) => this.stripe.paymentMethods.list(p),
-      upsertFn: (items, id, bf) => this.upsertPaymentMethods(items, id, bf),
-      supportsCreatedFilter: false
-      // Requires customer param, can't filter by created
-    },
-    payment_intent: {
-      order: 11,
-      // Depends on customer
-      listFn: (p) => this.stripe.paymentIntents.list(p),
-      upsertFn: (items, id, bf) => this.upsertPaymentIntents(items, id, bf),
-      supportsCreatedFilter: true
-    },
-    tax_id: {
-      order: 12,
-      // Depends on customer
-      listFn: (p) => this.stripe.taxIds.list(p),
-      upsertFn: (items, id, bf) => this.upsertTaxIds(items, id, bf),
-      supportsCreatedFilter: false
-      // taxIds don't support created filter
-    },
-    credit_note: {
-      order: 13,
-      // Depends on invoice
-      listFn: (p) => this.stripe.creditNotes.list(p),
-      upsertFn: (items, id, bf) => this.upsertCreditNotes(items, id, bf),
-      supportsCreatedFilter: true
-      // credit_notes support created filter
-    },
-    dispute: {
-      order: 14,
-      // Depends on charge
-      listFn: (p) => this.stripe.disputes.list(p),
-      upsertFn: (items, id, bf) => this.upsertDisputes(items, id, bf),
-      supportsCreatedFilter: true
-    },
-    early_fraud_warning: {
-      order: 15,
-      // Depends on charge
-      listFn: (p) => this.stripe.radar.earlyFraudWarnings.list(p),
-      upsertFn: (items, id) => this.upsertEarlyFraudWarning(items, id),
-      supportsCreatedFilter: true
-    },
-    refund: {
-      order: 16,
-      // Depends on charge
-      listFn: (p) => this.stripe.refunds.list(p),
-      upsertFn: (items, id, bf) => this.upsertRefunds(items, id, bf),
-      supportsCreatedFilter: true
-    },
-    checkout_sessions: {
-      order: 17,
-      // Depends on customer (optional)
-      listFn: (p) => this.stripe.checkout.sessions.list(p),
-      upsertFn: (items, id) => this.upsertCheckoutSessions(items, id),
-      supportsCreatedFilter: true
-    },
-    // Sigma-backed resources
-    subscription_item_change_events_v2_beta: {
-      order: 18,
-      supportsCreatedFilter: false,
-      sigma: SIGMA_INGESTION_CONFIGS.subscription_item_change_events_v2_beta
-    },
-    exchange_rates_from_usd: {
-      order: 19,
-      supportsCreatedFilter: false,
-      sigma: SIGMA_INGESTION_CONFIGS.exchange_rates_from_usd
-    }
-  };
-  async processEvent(event) {
-    const objectAccountId = event.data?.object && typeof event.data.object === "object" && "account" in event.data.object ? event.data.object.account : void 0;
-    const accountId = await this.getAccountId(objectAccountId);
-    await this.getCurrentAccount();
-    const handler = this.eventHandlers[event.type];
-    if (handler) {
-      const entityId = event.data?.object && typeof event.data.object === "object" && "id" in event.data.object ? event.data.object.id : "unknown";
-      this.config.logger?.info(`Received webhook ${event.id}: ${event.type} for ${entityId}`);
-      await handler(event, accountId);
-    } else {
-      this.config.logger?.warn(
-        `Received unhandled webhook event: ${event.type} (${event.id}). Ignoring.`
-      );
-    }
-  }
-  /**
-   * Returns an array of all webhook event types that this sync engine can handle.
-   * Useful for configuring webhook endpoints with specific event subscriptions.
-   */
-  getSupportedEventTypes() {
-    return Object.keys(
-      this.eventHandlers
-    ).sort();
-  }
-  /**
-   * Returns an array of all object types that can be synced via processNext/processUntilDone.
-   * Ordered for backfill: parents before children (products before prices, customers before subscriptions).
-   * Order is determined by the `order` field in resourceRegistry.
-   */
-  getSupportedSyncObjects() {
-    const all = Object.entries(this.resourceRegistry).sort(([, a], [, b]) => a.order - b.order).map(([key]) => key);
-    if (!this.config.enableSigma) {
-      return all.filter(
-        (o) => o !== "subscription_item_change_events_v2_beta" && o !== "exchange_rates_from_usd"
-      );
-    }
-    return all;
-  }
-  // Event handler methods
-  async handleChargeEvent(event, accountId) {
-    const { entity: charge, refetched } = await this.fetchOrUseWebhookData(
-      event.data.object,
-      (id) => this.stripe.charges.retrieve(id),
-      (charge2) => charge2.status === "failed" || charge2.status === "succeeded"
-    );
-    await this.upsertCharges([charge], accountId, false, this.getSyncTimestamp(event, refetched));
-  }
-  async handleCustomerDeletedEvent(event, accountId) {
-    const customer = {
-      id: event.data.object.id,
-      object: "customer",
-      deleted: true
-    };
-    await this.upsertCustomers([customer], accountId, this.getSyncTimestamp(event, false));
-  }
-  async handleCustomerEvent(event, accountId) {
-    const { entity: customer, refetched } = await this.fetchOrUseWebhookData(
-      event.data.object,
-      (id) => this.stripe.customers.retrieve(id),
-      (customer2) => customer2.deleted === true
-    );
-    await this.upsertCustomers([customer], accountId, this.getSyncTimestamp(event, refetched));
-  }
-  async handleCheckoutSessionEvent(event, accountId) {
-    const { entity: checkoutSession, refetched } = await this.fetchOrUseWebhookData(
-      event.data.object,
-      (id) => this.stripe.checkout.sessions.retrieve(id)
-    );
-    await this.upsertCheckoutSessions(
-      [checkoutSession],
-      accountId,
-      false,
-      this.getSyncTimestamp(event, refetched)
-    );
-  }
-  async handleSubscriptionEvent(event, accountId) {
-    const { entity: subscription, refetched } = await this.fetchOrUseWebhookData(
-      event.data.object,
-      (id) => this.stripe.subscriptions.retrieve(id),
-      (subscription2) => subscription2.status === "canceled" || subscription2.status === "incomplete_expired"
-    );
-    await this.upsertSubscriptions(
-      [subscription],
-      accountId,
-      false,
-      this.getSyncTimestamp(event, refetched)
-    );
-  }
-  async handleTaxIdEvent(event, accountId) {
-    const { entity: taxId, refetched } = await this.fetchOrUseWebhookData(
-      event.data.object,
-      (id) => this.stripe.taxIds.retrieve(id)
-    );
-    await this.upsertTaxIds([taxId], accountId, false, this.getSyncTimestamp(event, refetched));
-  }
-  async handleTaxIdDeletedEvent(event, _accountId) {
-    const taxId = event.data.object;
-    await this.deleteTaxId(taxId.id);
-  }
-  async handleInvoiceEvent(event, accountId) {
-    const { entity: invoice, refetched } = await this.fetchOrUseWebhookData(
-      event.data.object,
-      (id) => this.stripe.invoices.retrieve(id),
-      (invoice2) => invoice2.status === "void"
-    );
-    await this.upsertInvoices([invoice], accountId, false, this.getSyncTimestamp(event, refetched));
-  }
-  async handleProductEvent(event, accountId) {
-    try {
-      const { entity: product, refetched } = await this.fetchOrUseWebhookData(
-        event.data.object,
-        (id) => this.stripe.products.retrieve(id)
-      );
-      await this.upsertProducts([product], accountId, this.getSyncTimestamp(event, refetched));
-    } catch (err) {
-      if (err instanceof Stripe3.errors.StripeAPIError && err.code === "resource_missing") {
-        const product = event.data.object;
-        await this.deleteProduct(product.id);
-      } else {
-        throw err;
-      }
-    }
-  }
-  async handleProductDeletedEvent(event, _accountId) {
-    const product = event.data.object;
-    await this.deleteProduct(product.id);
-  }
-  async handlePriceEvent(event, accountId) {
-    try {
-      const { entity: price, refetched } = await this.fetchOrUseWebhookData(
-        event.data.object,
-        (id) => this.stripe.prices.retrieve(id)
-      );
-      await this.upsertPrices([price], accountId, false, this.getSyncTimestamp(event, refetched));
-    } catch (err) {
-      if (err instanceof Stripe3.errors.StripeAPIError && err.code === "resource_missing") {
-        const price = event.data.object;
-        await this.deletePrice(price.id);
-      } else {
-        throw err;
-      }
-    }
-  }
-  async handlePriceDeletedEvent(event, _accountId) {
-    const price = event.data.object;
-    await this.deletePrice(price.id);
-  }
-  async handlePlanEvent(event, accountId) {
-    try {
-      const { entity: plan, refetched } = await this.fetchOrUseWebhookData(
-        event.data.object,
-        (id) => this.stripe.plans.retrieve(id)
-      );
-      await this.upsertPlans([plan], accountId, false, this.getSyncTimestamp(event, refetched));
-    } catch (err) {
-      if (err instanceof Stripe3.errors.StripeAPIError && err.code === "resource_missing") {
-        const plan = event.data.object;
-        await this.deletePlan(plan.id);
-      } else {
-        throw err;
-      }
-    }
-  }
-  async handlePlanDeletedEvent(event, _accountId) {
-    const plan = event.data.object;
-    await this.deletePlan(plan.id);
-  }
-  async handleSetupIntentEvent(event, accountId) {
-    const { entity: setupIntent, refetched } = await this.fetchOrUseWebhookData(
-      event.data.object,
-      (id) => this.stripe.setupIntents.retrieve(id),
-      (setupIntent2) => setupIntent2.status === "canceled" || setupIntent2.status === "succeeded"
-    );
-    await this.upsertSetupIntents(
-      [setupIntent],
-      accountId,
-      false,
-      this.getSyncTimestamp(event, refetched)
-    );
-  }
-  async handleSubscriptionScheduleEvent(event, accountId) {
-    const { entity: subscriptionSchedule, refetched } = await this.fetchOrUseWebhookData(
-      event.data.object,
-      (id) => this.stripe.subscriptionSchedules.retrieve(id),
-      (schedule) => schedule.status === "canceled" || schedule.status === "completed"
-    );
-    await this.upsertSubscriptionSchedules(
-      [subscriptionSchedule],
-      accountId,
-      false,
-      this.getSyncTimestamp(event, refetched)
-    );
-  }
-  async handlePaymentMethodEvent(event, accountId) {
-    const { entity: paymentMethod, refetched } = await this.fetchOrUseWebhookData(
-      event.data.object,
-      (id) => this.stripe.paymentMethods.retrieve(id)
-    );
-    await this.upsertPaymentMethods(
-      [paymentMethod],
-      accountId,
-      false,
-      this.getSyncTimestamp(event, refetched)
-    );
-  }
-  async handleDisputeEvent(event, accountId) {
-    const { entity: dispute, refetched } = await this.fetchOrUseWebhookData(
-      event.data.object,
-      (id) => this.stripe.disputes.retrieve(id),
-      (dispute2) => dispute2.status === "won" || dispute2.status === "lost"
-    );
-    await this.upsertDisputes([dispute], accountId, false, this.getSyncTimestamp(event, refetched));
-  }
-  async handlePaymentIntentEvent(event, accountId) {
-    const { entity: paymentIntent, refetched } = await this.fetchOrUseWebhookData(
-      event.data.object,
-      (id) => this.stripe.paymentIntents.retrieve(id),
-      // Final states - do not re-fetch from API
-      (entity) => entity.status === "canceled" || entity.status === "succeeded"
-    );
-    await this.upsertPaymentIntents(
-      [paymentIntent],
-      accountId,
-      false,
-      this.getSyncTimestamp(event, refetched)
-    );
-  }
-  async handleCreditNoteEvent(event, accountId) {
-    const { entity: creditNote, refetched } = await this.fetchOrUseWebhookData(
-      event.data.object,
-      (id) => this.stripe.creditNotes.retrieve(id),
-      (creditNote2) => creditNote2.status === "void"
-    );
-    await this.upsertCreditNotes(
-      [creditNote],
-      accountId,
-      false,
-      this.getSyncTimestamp(event, refetched)
-    );
-  }
-  async handleEarlyFraudWarningEvent(event, accountId) {
-    const { entity: earlyFraudWarning, refetched } = await this.fetchOrUseWebhookData(
-      event.data.object,
-      (id) => this.stripe.radar.earlyFraudWarnings.retrieve(id)
-    );
-    await this.upsertEarlyFraudWarning(
-      [earlyFraudWarning],
-      accountId,
-      false,
-      this.getSyncTimestamp(event, refetched)
-    );
-  }
-  async handleRefundEvent(event, accountId) {
-    const { entity: refund, refetched } = await this.fetchOrUseWebhookData(
-      event.data.object,
-      (id) => this.stripe.refunds.retrieve(id)
-    );
-    await this.upsertRefunds([refund], accountId, false, this.getSyncTimestamp(event, refetched));
-  }
-  async handleReviewEvent(event, accountId) {
-    const { entity: review, refetched } = await this.fetchOrUseWebhookData(
-      event.data.object,
-      (id) => this.stripe.reviews.retrieve(id)
-    );
-    await this.upsertReviews([review], accountId, false, this.getSyncTimestamp(event, refetched));
-  }
-  async handleEntitlementSummaryEvent(event, accountId) {
-    const activeEntitlementSummary = event.data.object;
-    let entitlements = activeEntitlementSummary.entitlements;
-    let refetched = false;
-    if (this.config.revalidateObjectsViaStripeApi?.includes("entitlements")) {
-      const { lastResponse, ...rest } = await this.stripe.entitlements.activeEntitlements.list({
-        customer: activeEntitlementSummary.customer
-      });
-      entitlements = rest;
-      refetched = true;
-    }
-    await this.deleteRemovedActiveEntitlements(
-      activeEntitlementSummary.customer,
-      entitlements.data.map((entitlement) => entitlement.id)
-    );
-    await this.upsertActiveEntitlements(
-      activeEntitlementSummary.customer,
-      entitlements.data,
-      accountId,
-      false,
-      this.getSyncTimestamp(event, refetched)
-    );
-  }
-  getSyncTimestamp(event, refetched) {
-    return refetched ? (/* @__PURE__ */ new Date()).toISOString() : new Date(event.created * 1e3).toISOString();
-  }
-  shouldRefetchEntity(entity) {
-    return this.config.revalidateObjectsViaStripeApi?.includes(entity.object);
-  }
-  async fetchOrUseWebhookData(entity, fetchFn, entityInFinalState) {
-    if (!entity.id) return { entity, refetched: false };
-    if (entityInFinalState && entityInFinalState(entity)) return { entity, refetched: false };
-    if (this.shouldRefetchEntity(entity)) {
-      const fetchedEntity = await fetchFn(entity.id);
-      return { entity: fetchedEntity, refetched: true };
-    }
-    return { entity, refetched: false };
-  }
-  async syncSingleEntity(stripeId) {
-    const accountId = await this.getAccountId();
-    if (stripeId.startsWith("cus_")) {
-      return this.stripe.customers.retrieve(stripeId).then((it) => {
-        if (!it || it.deleted) return;
-        return this.upsertCustomers([it], accountId);
-      });
-    } else if (stripeId.startsWith("in_")) {
-      return this.stripe.invoices.retrieve(stripeId).then((it) => this.upsertInvoices([it], accountId));
-    } else if (stripeId.startsWith("price_")) {
-      return this.stripe.prices.retrieve(stripeId).then((it) => this.upsertPrices([it], accountId));
-    } else if (stripeId.startsWith("prod_")) {
-      return this.stripe.products.retrieve(stripeId).then((it) => this.upsertProducts([it], accountId));
-    } else if (stripeId.startsWith("sub_")) {
-      return this.stripe.subscriptions.retrieve(stripeId).then((it) => this.upsertSubscriptions([it], accountId));
-    } else if (stripeId.startsWith("seti_")) {
-      return this.stripe.setupIntents.retrieve(stripeId).then((it) => this.upsertSetupIntents([it], accountId));
-    } else if (stripeId.startsWith("pm_")) {
-      return this.stripe.paymentMethods.retrieve(stripeId).then((it) => this.upsertPaymentMethods([it], accountId));
-    } else if (stripeId.startsWith("dp_") || stripeId.startsWith("du_")) {
-      return this.stripe.disputes.retrieve(stripeId).then((it) => this.upsertDisputes([it], accountId));
-    } else if (stripeId.startsWith("ch_")) {
-      return this.stripe.charges.retrieve(stripeId).then((it) => this.upsertCharges([it], accountId, true));
-    } else if (stripeId.startsWith("pi_")) {
-      return this.stripe.paymentIntents.retrieve(stripeId).then((it) => this.upsertPaymentIntents([it], accountId));
-    } else if (stripeId.startsWith("txi_")) {
-      return this.stripe.taxIds.retrieve(stripeId).then((it) => this.upsertTaxIds([it], accountId));
-    } else if (stripeId.startsWith("cn_")) {
-      return this.stripe.creditNotes.retrieve(stripeId).then((it) => this.upsertCreditNotes([it], accountId));
-    } else if (stripeId.startsWith("issfr_")) {
-      return this.stripe.radar.earlyFraudWarnings.retrieve(stripeId).then((it) => this.upsertEarlyFraudWarning([it], accountId));
-    } else if (stripeId.startsWith("prv_")) {
-      return this.stripe.reviews.retrieve(stripeId).then((it) => this.upsertReviews([it], accountId));
-    } else if (stripeId.startsWith("re_")) {
-      return this.stripe.refunds.retrieve(stripeId).then((it) => this.upsertRefunds([it], accountId));
-    } else if (stripeId.startsWith("feat_")) {
-      return this.stripe.entitlements.features.retrieve(stripeId).then((it) => this.upsertFeatures([it], accountId));
-    } else if (stripeId.startsWith("cs_")) {
-      return this.stripe.checkout.sessions.retrieve(stripeId).then((it) => this.upsertCheckoutSessions([it], accountId));
-    }
-  }
-  /**
-   * Process one page of items for the specified object type.
-   * Returns the number of items processed and whether there are more pages.
-   *
-   * This method is designed for queue-based consumption where each page
-   * is processed as a separate job. Uses the observable sync system for tracking.
-   *
-   * @param object - The Stripe object type to sync (e.g., 'customer', 'product')
-   * @param params - Optional parameters for filtering and run context
-   * @returns ProcessNextResult with processed count, hasMore flag, and runStartedAt
-   *
-   * @example
-   * ```typescript
-   * // Queue worker
-   * const { hasMore, runStartedAt } = await stripeSync.processNext('customer')
-   * if (hasMore) {
-   *   await queue.send({ object: 'customer', runStartedAt })
-   * }
-   * ```
-   */
-  async processNext(object, params) {
-    try {
-      await this.getCurrentAccount();
-      const accountId = await this.getAccountId();
-      const resourceName = this.getResourceName(object);
-      let runStartedAt;
-      if (params?.runStartedAt) {
-        runStartedAt = params.runStartedAt;
-      } else {
-        const { runKey } = await this.joinOrCreateSyncRun(params?.triggeredBy ?? "processNext");
-        runStartedAt = runKey.runStartedAt;
-      }
-      await this.postgresClient.createObjectRuns(accountId, runStartedAt, [resourceName]);
-      const objRun = await this.postgresClient.getObjectRun(accountId, runStartedAt, resourceName);
-      if (objRun?.status === "complete" || objRun?.status === "error") {
-        return {
-          processed: 0,
-          hasMore: false,
-          runStartedAt
-        };
-      }
-      if (objRun?.status === "pending") {
-        const started = await this.postgresClient.tryStartObjectSync(
-          accountId,
-          runStartedAt,
-          resourceName
-        );
-        if (!started) {
-          return {
-            processed: 0,
-            hasMore: true,
-            runStartedAt
-          };
-        }
-      }
-      let cursor = null;
-      if (!params?.created) {
-        const lastCursor = await this.postgresClient.getLastCursorBeforeRun(
-          accountId,
-          resourceName,
-          runStartedAt
-        );
-        cursor = lastCursor ?? null;
-      }
-      const result = await this.fetchOnePage(
-        object,
-        accountId,
-        resourceName,
-        runStartedAt,
-        cursor,
-        objRun?.pageCursor ?? null,
-        params
-      );
-      return result;
-    } catch (error) {
-      throw this.appendMigrationHint(error);
-    }
-  }
-  appendMigrationHint(error) {
-    const hint = "Error occurred. Make sure you are up to date with DB migrations which can sometimes help with this. Details:";
-    const withHint = (message) => message.includes(hint) ? message : `${hint}
-${message}`;
-    if (error instanceof Error) {
-      const { stack } = error;
-      error.message = withHint(error.message);
-      if (stack) error.stack = stack;
-      return error;
-    }
-    return new Error(withHint(String(error)));
-  }
-  /**
-   * Get the database resource name for a SyncObject type
-   */
-  getResourceName(object) {
-    const mapping = {
-      customer: "customers",
-      invoice: "invoices",
-      price: "prices",
-      product: "products",
-      subscription: "subscriptions",
-      subscription_schedules: "subscription_schedules",
-      setup_intent: "setup_intents",
-      payment_method: "payment_methods",
-      dispute: "disputes",
-      charge: "charges",
-      payment_intent: "payment_intents",
-      plan: "plans",
-      tax_id: "tax_ids",
-      credit_note: "credit_notes",
-      early_fraud_warning: "early_fraud_warnings",
-      refund: "refunds",
-      checkout_sessions: "checkout_sessions"
-    };
-    return mapping[object] || object;
-  }
-  /**
-   * Fetch one page of items from Stripe and upsert to database.
-   * Uses resourceRegistry for DRY list/upsert operations.
-   * Uses the observable sync system for tracking progress.
-   */
-  async fetchOnePage(object, accountId, resourceName, runStartedAt, cursor, pageCursor, params) {
-    const limit = 100;
-    if (object === "payment_method" || object === "tax_id") {
-      this.config.logger?.warn(`processNext for ${object} requires customer context`);
-      await this.postgresClient.completeObjectSync(accountId, runStartedAt, resourceName);
-      return { processed: 0, hasMore: false, runStartedAt };
-    }
-    const config = this.resourceRegistry[object];
-    if (!config) {
-      throw new Error(`Unsupported object type for processNext: ${object}`);
-    }
-    try {
-      if (config.sigma) {
-        return await this.fetchOneSigmaPage(
-          accountId,
-          resourceName,
-          runStartedAt,
-          cursor,
-          config.sigma
-        );
-      }
-      const listParams = { limit };
-      if (config.supportsCreatedFilter) {
-        const created = params?.created ?? (cursor && /^\d+$/.test(cursor) ? { gte: Number.parseInt(cursor, 10) } : void 0);
-        if (created) {
-          listParams.created = created;
-        }
-      }
-      if (pageCursor) {
-        listParams.starting_after = pageCursor;
-      }
-      const response = await config.listFn(listParams);
-      if (response.data.length === 0 && response.has_more) {
-        const message = `Stripe returned has_more=true with empty page for ${resourceName}. Aborting to avoid infinite loop.`;
-        this.config.logger?.warn(message);
-        await this.postgresClient.failObjectSync(accountId, runStartedAt, resourceName, message);
-        return { processed: 0, hasMore: false, runStartedAt };
-      }
-      if (response.data.length > 0) {
-        this.config.logger?.info(`processNext: upserting ${response.data.length} ${resourceName}`);
-        await config.upsertFn(response.data, accountId, params?.backfillRelatedEntities);
-        await this.postgresClient.incrementObjectProgress(
-          accountId,
-          runStartedAt,
-          resourceName,
-          response.data.length
-        );
-        const maxCreated = Math.max(
-          ...response.data.map((i) => i.created || 0)
-        );
-        if (maxCreated > 0) {
-          await this.postgresClient.updateObjectCursor(
-            accountId,
-            runStartedAt,
-            resourceName,
-            String(maxCreated)
-          );
-        }
-        const lastId = response.data[response.data.length - 1].id;
-        if (response.has_more) {
-          await this.postgresClient.updateObjectPageCursor(
-            accountId,
-            runStartedAt,
-            resourceName,
-            lastId
-          );
-        }
-      }
-      if (!response.has_more) {
-        await this.postgresClient.completeObjectSync(accountId, runStartedAt, resourceName);
-      }
-      return {
-        processed: response.data.length,
-        hasMore: response.has_more,
-        runStartedAt
-      };
-    } catch (error) {
-      await this.postgresClient.failObjectSync(
-        accountId,
-        runStartedAt,
-        resourceName,
-        error instanceof Error ? error.message : "Unknown error"
-      );
-      throw error;
-    }
-  }
-  async getSigmaFallbackCursorFromDestination(accountId, sigmaConfig) {
-    const cursorCols = sigmaConfig.cursor.columns;
-    const selectCols = cursorCols.map((c) => `"${c.column}"`).join(", ");
-    const orderBy = cursorCols.map((c) => `"${c.column}" DESC`).join(", ");
-    const result = await this.postgresClient.query(
-      `SELECT ${selectCols}
-       FROM "stripe"."${sigmaConfig.destinationTable}"
-       WHERE "_account_id" = $1
-       ORDER BY ${orderBy}
-       LIMIT 1`,
-      [accountId]
-    );
-    if (result.rows.length === 0) return null;
-    const row = result.rows[0];
-    const entryForCursor = {};
-    for (const c of cursorCols) {
-      const v = row[c.column];
-      if (v == null) {
-        throw new Error(
-          `Sigma fallback cursor query returned null for ${sigmaConfig.destinationTable}.${c.column}`
-        );
-      }
-      if (c.type === "timestamp") {
-        const d = v instanceof Date ? v : new Date(String(v));
-        if (Number.isNaN(d.getTime())) {
-          throw new Error(
-            `Sigma fallback cursor query returned invalid timestamp for ${sigmaConfig.destinationTable}.${c.column}: ${String(
-              v
-            )}`
-          );
-        }
-        entryForCursor[c.column] = d.toISOString();
-      } else {
-        entryForCursor[c.column] = String(v);
-      }
-    }
-    return sigmaCursorFromEntry(sigmaConfig, entryForCursor);
-  }
-  async fetchOneSigmaPage(accountId, resourceName, runStartedAt, cursor, sigmaConfig) {
-    if (!this.config.stripeSecretKey) {
-      throw new Error("Sigma sync requested but stripeSecretKey is not configured.");
-    }
-    if (resourceName !== sigmaConfig.destinationTable) {
-      throw new Error(
-        `Sigma sync config mismatch: resourceName=${resourceName} destinationTable=${sigmaConfig.destinationTable}`
-      );
-    }
-    const effectiveCursor = cursor ?? await this.getSigmaFallbackCursorFromDestination(accountId, sigmaConfig);
-    const sigmaSql = buildSigmaQuery(sigmaConfig, effectiveCursor);
-    this.config.logger?.info(
-      { object: resourceName, pageSize: sigmaConfig.pageSize, hasCursor: Boolean(effectiveCursor) },
-      "Sigma sync: running query"
-    );
-    const { queryRunId, fileId, csv } = await runSigmaQueryAndDownloadCsv({
-      apiKey: this.config.stripeSecretKey,
-      sql: sigmaSql,
-      logger: this.config.logger
-    });
-    const rows = parseCsvObjects(csv);
-    if (rows.length === 0) {
-      await this.postgresClient.completeObjectSync(accountId, runStartedAt, resourceName);
-      return { processed: 0, hasMore: false, runStartedAt };
-    }
-    const entries = rows.map(
-      (row) => defaultSigmaRowToEntry(sigmaConfig, row)
-    );
-    this.config.logger?.info(
-      { object: resourceName, rows: entries.length, queryRunId, fileId },
-      "Sigma sync: upserting rows"
-    );
-    await this.postgresClient.upsertManyWithTimestampProtection(
-      entries,
-      resourceName,
-      accountId,
-      void 0,
-      sigmaConfig.upsert
-    );
-    await this.postgresClient.incrementObjectProgress(
-      accountId,
-      runStartedAt,
-      resourceName,
-      entries.length
-    );
-    const newCursor = sigmaCursorFromEntry(sigmaConfig, entries[entries.length - 1]);
-    await this.postgresClient.updateObjectCursor(accountId, runStartedAt, resourceName, newCursor);
-    const hasMore = rows.length === sigmaConfig.pageSize;
-    if (!hasMore) {
-      await this.postgresClient.completeObjectSync(accountId, runStartedAt, resourceName);
-    }
-    return { processed: entries.length, hasMore, runStartedAt };
-  }
-  /**
-   * Process all pages for all (or specified) object types until complete.
-   *
-   * @param params - Optional parameters for filtering and specifying object types
-   * @returns SyncBackfill with counts for each synced resource type
-   */
-  /**
-   * Process all pages for a single object type until complete.
-   * Loops processNext() internally until hasMore is false.
-   *
-   * @param object - The object type to sync
-   * @param runStartedAt - The sync run to use (for sharing across objects)
-   * @param params - Optional sync parameters
-   * @returns Sync result with count of synced items
-   */
-  async processObjectUntilDone(object, runStartedAt, params) {
-    let totalSynced = 0;
-    while (true) {
-      const result = await this.processNext(object, {
-        ...params,
-        runStartedAt,
-        triggeredBy: "processUntilDone"
-      });
-      totalSynced += result.processed;
-      if (!result.hasMore) {
-        break;
-      }
-    }
-    return { synced: totalSynced };
-  }
-  /**
-   * Join existing sync run or create a new one.
-   * Returns sync run key and list of supported objects to sync.
-   *
-   * Cooperative behavior: If a sync run already exists, joins it instead of failing.
-   * This is used by workers and background processes that should cooperate.
-   *
-   * @param triggeredBy - What triggered this sync (for observability)
-   * @param objectFilter - Optional specific object to sync (e.g. 'payment_intent'). If 'all' or undefined, syncs all objects.
-   * @returns Run key and list of objects to sync
-   */
-  async joinOrCreateSyncRun(triggeredBy = "worker", objectFilter) {
-    await this.getCurrentAccount();
-    const accountId = await this.getAccountId();
-    const result = await this.postgresClient.getOrCreateSyncRun(accountId, triggeredBy);
-    const objects = objectFilter === "all" || objectFilter === void 0 ? this.getSupportedSyncObjects() : [objectFilter];
-    if (!result) {
-      const activeRun = await this.postgresClient.getActiveSyncRun(accountId);
-      if (!activeRun) {
-        throw new Error("Failed to get or create sync run");
-      }
-      await this.postgresClient.createObjectRuns(
-        activeRun.accountId,
-        activeRun.runStartedAt,
-        objects.map((obj) => this.getResourceName(obj))
-      );
-      return {
-        runKey: { accountId: activeRun.accountId, runStartedAt: activeRun.runStartedAt },
-        objects
-      };
-    }
-    const { accountId: runAccountId, runStartedAt } = result;
-    await this.postgresClient.createObjectRuns(
-      runAccountId,
-      runStartedAt,
-      objects.map((obj) => this.getResourceName(obj))
-    );
-    return {
-      runKey: { accountId: runAccountId, runStartedAt },
-      objects
-    };
-  }
-  async processUntilDone(params) {
-    const { object } = params ?? { object: "all" };
-    const { runKey } = await this.joinOrCreateSyncRun("processUntilDone", object);
-    return this.processUntilDoneWithRun(runKey.runStartedAt, object, params);
-  }
-  /**
-   * Internal implementation of processUntilDone with an existing run.
-   */
-  async processUntilDoneWithRun(runStartedAt, object, params) {
-    const accountId = await this.getAccountId();
-    const results = {};
-    try {
-      const objectsToSync = object === "all" || object === void 0 ? this.getSupportedSyncObjects() : [object];
-      for (const obj of objectsToSync) {
-        this.config.logger?.info(`Syncing ${obj}`);
-        if (obj === "payment_method") {
-          results.paymentMethods = await this.syncPaymentMethodsWithRun(runStartedAt, params);
-        } else {
-          const result = await this.processObjectUntilDone(obj, runStartedAt, params);
-          switch (obj) {
-            case "product":
-              results.products = result;
-              break;
-            case "price":
-              results.prices = result;
-              break;
-            case "plan":
-              results.plans = result;
-              break;
-            case "customer":
-              results.customers = result;
-              break;
-            case "subscription":
-              results.subscriptions = result;
-              break;
-            case "subscription_schedules":
-              results.subscriptionSchedules = result;
-              break;
-            case "invoice":
-              results.invoices = result;
-              break;
-            case "charge":
-              results.charges = result;
-              break;
-            case "setup_intent":
-              results.setupIntents = result;
-              break;
-            case "payment_intent":
-              results.paymentIntents = result;
-              break;
-            case "tax_id":
-              results.taxIds = result;
-              break;
-            case "credit_note":
-              results.creditNotes = result;
-              break;
-            case "dispute":
-              results.disputes = result;
-              break;
-            case "early_fraud_warning":
-              results.earlyFraudWarnings = result;
-              break;
-            case "refund":
-              results.refunds = result;
-              break;
-            case "checkout_sessions":
-              results.checkoutSessions = result;
-              break;
-            case "subscription_item_change_events_v2_beta":
-              results.subscriptionItemChangeEventsV2Beta = result;
-              break;
-            case "exchange_rates_from_usd":
-              results.exchangeRatesFromUsd = result;
-              break;
-          }
-        }
-      }
-      await this.postgresClient.closeSyncRun(accountId, runStartedAt);
-      return results;
-    } catch (error) {
-      await this.postgresClient.closeSyncRun(accountId, runStartedAt);
-      throw error;
-    }
-  }
-  /**
-   * Sync payment methods with an existing run (special case - iterates customers)
-   */
-  async syncPaymentMethodsWithRun(runStartedAt, syncParams) {
-    const accountId = await this.getAccountId();
-    const resourceName = "payment_methods";
-    await this.postgresClient.createObjectRuns(accountId, runStartedAt, [resourceName]);
-    await this.postgresClient.tryStartObjectSync(accountId, runStartedAt, resourceName);
-    try {
-      const prepared = sql2(
-        `select id from "stripe"."customers" WHERE COALESCE(deleted, false) <> true;`
-      )([]);
-      const customerIds = await this.postgresClient.query(prepared.text, prepared.values).then(({ rows }) => rows.map((it) => it.id));
-      this.config.logger?.info(`Getting payment methods for ${customerIds.length} customers`);
-      let synced = 0;
-      const chunkSize = this.config.maxConcurrentCustomers ?? 10;
-      for (const customerIdChunk of chunkArray(customerIds, chunkSize)) {
-        await Promise.all(
-          customerIdChunk.map(async (customerId) => {
-            const CHECKPOINT_SIZE = 100;
-            let currentBatch = [];
-            let hasMore = true;
-            let startingAfter = void 0;
-            while (hasMore) {
-              const response = await this.stripe.paymentMethods.list({
-                limit: 100,
-                customer: customerId,
-                ...startingAfter ? { starting_after: startingAfter } : {}
-              });
-              for (const item of response.data) {
-                currentBatch.push(item);
-                if (currentBatch.length >= CHECKPOINT_SIZE) {
-                  await this.upsertPaymentMethods(
-                    currentBatch,
-                    accountId,
-                    syncParams?.backfillRelatedEntities
-                  );
-                  synced += currentBatch.length;
-                  await this.postgresClient.incrementObjectProgress(
-                    accountId,
-                    runStartedAt,
-                    resourceName,
-                    currentBatch.length
-                  );
-                  currentBatch = [];
-                }
-              }
-              hasMore = response.has_more;
-              if (response.data.length > 0) {
-                startingAfter = response.data[response.data.length - 1].id;
-              }
-            }
-            if (currentBatch.length > 0) {
-              await this.upsertPaymentMethods(
-                currentBatch,
-                accountId,
-                syncParams?.backfillRelatedEntities
-              );
-              synced += currentBatch.length;
-              await this.postgresClient.incrementObjectProgress(
-                accountId,
-                runStartedAt,
-                resourceName,
-                currentBatch.length
-              );
-            }
-          })
-        );
-      }
-      await this.postgresClient.completeObjectSync(accountId, runStartedAt, resourceName);
-      return { synced };
-    } catch (error) {
-      await this.postgresClient.failObjectSync(
-        accountId,
-        runStartedAt,
-        resourceName,
-        error instanceof Error ? error.message : "Unknown error"
-      );
-      throw error;
-    }
-  }
-  async syncProducts(syncParams) {
-    this.config.logger?.info("Syncing products");
-    return this.withSyncRun("products", "syncProducts", async (cursor, runStartedAt) => {
-      const accountId = await this.getAccountId();
-      const params = { limit: 100 };
-      if (syncParams?.created) {
-        params.created = syncParams.created;
-      } else if (cursor) {
-        params.created = { gte: cursor };
-        this.config.logger?.info(`Incremental sync from cursor: ${cursor}`);
-      }
-      return this.fetchAndUpsert(
-        (pagination) => this.stripe.products.list({ ...params, ...pagination }),
-        (products) => this.upsertProducts(products, accountId),
-        accountId,
-        "products",
-        runStartedAt
-      );
-    });
-  }
-  async syncPrices(syncParams) {
-    this.config.logger?.info("Syncing prices");
-    return this.withSyncRun("prices", "syncPrices", async (cursor, runStartedAt) => {
-      const accountId = await this.getAccountId();
-      const params = { limit: 100 };
-      if (syncParams?.created) {
-        params.created = syncParams.created;
-      } else if (cursor) {
-        params.created = { gte: cursor };
-        this.config.logger?.info(`Incremental sync from cursor: ${cursor}`);
-      }
-      return this.fetchAndUpsert(
-        (pagination) => this.stripe.prices.list({ ...params, ...pagination }),
-        (prices) => this.upsertPrices(prices, accountId, syncParams?.backfillRelatedEntities),
-        accountId,
-        "prices",
-        runStartedAt
-      );
-    });
-  }
-  async syncPlans(syncParams) {
-    this.config.logger?.info("Syncing plans");
-    return this.withSyncRun("plans", "syncPlans", async (cursor, runStartedAt) => {
-      const accountId = await this.getAccountId();
-      const params = { limit: 100 };
-      if (syncParams?.created) {
-        params.created = syncParams.created;
-      } else if (cursor) {
-        params.created = { gte: cursor };
-        this.config.logger?.info(`Incremental sync from cursor: ${cursor}`);
-      }
-      return this.fetchAndUpsert(
-        (pagination) => this.stripe.plans.list({ ...params, ...pagination }),
-        (plans) => this.upsertPlans(plans, accountId, syncParams?.backfillRelatedEntities),
-        accountId,
-        "plans",
-        runStartedAt
-      );
-    });
-  }
-  async syncCustomers(syncParams) {
-    this.config.logger?.info("Syncing customers");
-    return this.withSyncRun("customers", "syncCustomers", async (cursor, runStartedAt) => {
-      const accountId = await this.getAccountId();
-      const params = { limit: 100 };
-      if (syncParams?.created) {
-        params.created = syncParams.created;
-      } else if (cursor) {
-        params.created = { gte: cursor };
-        this.config.logger?.info(`Incremental sync from cursor: ${cursor}`);
-      }
-      return this.fetchAndUpsert(
-        (pagination) => this.stripe.customers.list({ ...params, ...pagination }),
-        // @ts-expect-error
-        (items) => this.upsertCustomers(items, accountId),
-        accountId,
-        "customers",
-        runStartedAt
-      );
-    });
-  }
-  async syncSubscriptions(syncParams) {
-    this.config.logger?.info("Syncing subscriptions");
-    return this.withSyncRun("subscriptions", "syncSubscriptions", async (cursor, runStartedAt) => {
-      const accountId = await this.getAccountId();
-      const params = { status: "all", limit: 100 };
-      if (syncParams?.created) {
-        params.created = syncParams.created;
-      } else if (cursor) {
-        params.created = { gte: cursor };
-        this.config.logger?.info(`Incremental sync from cursor: ${cursor}`);
-      }
-      return this.fetchAndUpsert(
-        (pagination) => this.stripe.subscriptions.list({ ...params, ...pagination }),
-        (items) => this.upsertSubscriptions(items, accountId, syncParams?.backfillRelatedEntities),
-        accountId,
-        "subscriptions",
-        runStartedAt
-      );
-    });
-  }
-  async syncSubscriptionSchedules(syncParams) {
-    this.config.logger?.info("Syncing subscription schedules");
-    return this.withSyncRun(
-      "subscription_schedules",
-      "syncSubscriptionSchedules",
-      async (cursor, runStartedAt) => {
-        const accountId = await this.getAccountId();
-        const params = { limit: 100 };
-        if (syncParams?.created) {
-          params.created = syncParams.created;
-        } else if (cursor) {
-          params.created = { gte: cursor };
-          this.config.logger?.info(`Incremental sync from cursor: ${cursor}`);
-        }
-        return this.fetchAndUpsert(
-          (pagination) => this.stripe.subscriptionSchedules.list({ ...params, ...pagination }),
-          (items) => this.upsertSubscriptionSchedules(items, accountId, syncParams?.backfillRelatedEntities),
-          accountId,
-          "subscription_schedules",
-          runStartedAt
-        );
-      }
-    );
-  }
-  async syncInvoices(syncParams) {
-    this.config.logger?.info("Syncing invoices");
-    return this.withSyncRun("invoices", "syncInvoices", async (cursor, runStartedAt) => {
-      const accountId = await this.getAccountId();
-      const params = { limit: 100 };
-      if (syncParams?.created) {
-        params.created = syncParams.created;
-      } else if (cursor) {
-        params.created = { gte: cursor };
-        this.config.logger?.info(`Incremental sync from cursor: ${cursor}`);
-      }
-      return this.fetchAndUpsert(
-        (pagination) => this.stripe.invoices.list({ ...params, ...pagination }),
-        (items) => this.upsertInvoices(items, accountId, syncParams?.backfillRelatedEntities),
-        accountId,
-        "invoices",
-        runStartedAt
-      );
-    });
-  }
-  async syncCharges(syncParams) {
-    this.config.logger?.info("Syncing charges");
-    return this.withSyncRun("charges", "syncCharges", async (cursor, runStartedAt) => {
-      const accountId = await this.getAccountId();
-      const params = { limit: 100 };
-      if (syncParams?.created) {
-        params.created = syncParams.created;
-      } else if (cursor) {
-        params.created = { gte: cursor };
-        this.config.logger?.info(`Incremental sync from cursor: ${cursor}`);
-      }
-      return this.fetchAndUpsert(
-        (pagination) => this.stripe.charges.list({ ...params, ...pagination }),
-        (items) => this.upsertCharges(items, accountId, syncParams?.backfillRelatedEntities),
-        accountId,
-        "charges",
-        runStartedAt
-      );
-    });
-  }
-  async syncSetupIntents(syncParams) {
-    this.config.logger?.info("Syncing setup_intents");
-    return this.withSyncRun("setup_intents", "syncSetupIntents", async (cursor, runStartedAt) => {
-      const accountId = await this.getAccountId();
-      const params = { limit: 100 };
-      if (syncParams?.created) {
-        params.created = syncParams.created;
-      } else if (cursor) {
-        params.created = { gte: cursor };
-        this.config.logger?.info(`Incremental sync from cursor: ${cursor}`);
-      }
-      return this.fetchAndUpsert(
-        (pagination) => this.stripe.setupIntents.list({ ...params, ...pagination }),
-        (items) => this.upsertSetupIntents(items, accountId, syncParams?.backfillRelatedEntities),
-        accountId,
-        "setup_intents",
-        runStartedAt
-      );
-    });
-  }
-  async syncPaymentIntents(syncParams) {
-    this.config.logger?.info("Syncing payment_intents");
-    return this.withSyncRun(
-      "payment_intents",
-      "syncPaymentIntents",
-      async (cursor, runStartedAt) => {
-        const accountId = await this.getAccountId();
-        const params = { limit: 100 };
-        if (syncParams?.created) {
-          params.created = syncParams.created;
-        } else if (cursor) {
-          params.created = { gte: cursor };
-          this.config.logger?.info(`Incremental sync from cursor: ${cursor}`);
-        }
-        return this.fetchAndUpsert(
-          (pagination) => this.stripe.paymentIntents.list({ ...params, ...pagination }),
-          (items) => this.upsertPaymentIntents(items, accountId, syncParams?.backfillRelatedEntities),
-          accountId,
-          "payment_intents",
-          runStartedAt
-        );
-      }
-    );
-  }
-  async syncTaxIds(syncParams) {
-    this.config.logger?.info("Syncing tax_ids");
-    return this.withSyncRun("tax_ids", "syncTaxIds", async (_cursor, runStartedAt) => {
-      const accountId = await this.getAccountId();
-      const params = { limit: 100 };
-      return this.fetchAndUpsert(
-        (pagination) => this.stripe.taxIds.list({ ...params, ...pagination }),
-        (items) => this.upsertTaxIds(items, accountId, syncParams?.backfillRelatedEntities),
-        accountId,
-        "tax_ids",
-        runStartedAt
-      );
-    });
-  }
-  async syncPaymentMethods(syncParams) {
-    this.config.logger?.info("Syncing payment method");
-    return this.withSyncRun(
-      "payment_methods",
-      "syncPaymentMethods",
-      async (_cursor, runStartedAt) => {
-        const accountId = await this.getAccountId();
-        const prepared = sql2(
-          `select id from "stripe"."customers" WHERE COALESCE(deleted, false) <> true;`
-        )([]);
-        const customerIds = await this.postgresClient.query(prepared.text, prepared.values).then(({ rows }) => rows.map((it) => it.id));
-        this.config.logger?.info(`Getting payment methods for ${customerIds.length} customers`);
-        let synced = 0;
-        const chunkSize = this.config.maxConcurrentCustomers ?? 3;
-        for (const customerIdChunk of chunkArray(customerIds, chunkSize)) {
-          await Promise.all(
-            customerIdChunk.map(async (customerId) => {
-              const CHECKPOINT_SIZE = 100;
-              let currentBatch = [];
-              let hasMore = true;
-              let startingAfter = void 0;
-              while (hasMore) {
-                const response = await this.stripe.paymentMethods.list({
-                  limit: 100,
-                  customer: customerId,
-                  ...startingAfter ? { starting_after: startingAfter } : {}
-                });
-                for (const item of response.data) {
-                  currentBatch.push(item);
-                  if (currentBatch.length >= CHECKPOINT_SIZE) {
-                    await this.upsertPaymentMethods(
-                      currentBatch,
-                      accountId,
-                      syncParams?.backfillRelatedEntities
-                    );
-                    synced += currentBatch.length;
-                    await this.postgresClient.incrementObjectProgress(
-                      accountId,
-                      runStartedAt,
-                      "payment_methods",
-                      currentBatch.length
-                    );
-                    currentBatch = [];
-                  }
-                }
-                hasMore = response.has_more;
-                if (response.data.length > 0) {
-                  startingAfter = response.data[response.data.length - 1].id;
-                }
-              }
-              if (currentBatch.length > 0) {
-                await this.upsertPaymentMethods(
-                  currentBatch,
-                  accountId,
-                  syncParams?.backfillRelatedEntities
-                );
-                synced += currentBatch.length;
-                await this.postgresClient.incrementObjectProgress(
-                  accountId,
-                  runStartedAt,
-                  "payment_methods",
-                  currentBatch.length
-                );
-              }
-            })
-          );
-        }
-        await this.postgresClient.completeObjectSync(accountId, runStartedAt, "payment_methods");
-        return { synced };
-      }
-    );
-  }
-  async syncDisputes(syncParams) {
-    this.config.logger?.info("Syncing disputes");
-    return this.withSyncRun("disputes", "syncDisputes", async (cursor, runStartedAt) => {
-      const accountId = await this.getAccountId();
-      const params = { limit: 100 };
-      if (syncParams?.created) {
-        params.created = syncParams.created;
-      } else if (cursor) {
-        params.created = { gte: cursor };
-        this.config.logger?.info(`Incremental sync from cursor: ${cursor}`);
-      }
-      return this.fetchAndUpsert(
-        (pagination) => this.stripe.disputes.list({ ...params, ...pagination }),
-        (items) => this.upsertDisputes(items, accountId, syncParams?.backfillRelatedEntities),
-        accountId,
-        "disputes",
-        runStartedAt
-      );
-    });
-  }
-  async syncEarlyFraudWarnings(syncParams) {
-    this.config.logger?.info("Syncing early fraud warnings");
-    return this.withSyncRun(
-      "early_fraud_warnings",
-      "syncEarlyFraudWarnings",
-      async (cursor, runStartedAt) => {
-        const accountId = await this.getAccountId();
-        const params = { limit: 100 };
-        if (syncParams?.created) {
-          params.created = syncParams.created;
-        } else if (cursor) {
-          params.created = { gte: cursor };
-          this.config.logger?.info(`Incremental sync from cursor: ${cursor}`);
-        }
-        return this.fetchAndUpsert(
-          (pagination) => this.stripe.radar.earlyFraudWarnings.list({ ...params, ...pagination }),
-          (items) => this.upsertEarlyFraudWarning(items, accountId, syncParams?.backfillRelatedEntities),
-          accountId,
-          "early_fraud_warnings",
-          runStartedAt
-        );
-      }
-    );
-  }
-  async syncRefunds(syncParams) {
-    this.config.logger?.info("Syncing refunds");
-    return this.withSyncRun("refunds", "syncRefunds", async (cursor, runStartedAt) => {
-      const accountId = await this.getAccountId();
-      const params = { limit: 100 };
-      if (syncParams?.created) {
-        params.created = syncParams.created;
-      } else if (cursor) {
-        params.created = { gte: cursor };
-        this.config.logger?.info(`Incremental sync from cursor: ${cursor}`);
-      }
-      return this.fetchAndUpsert(
-        (pagination) => this.stripe.refunds.list({ ...params, ...pagination }),
-        (items) => this.upsertRefunds(items, accountId, syncParams?.backfillRelatedEntities),
-        accountId,
-        "refunds",
-        runStartedAt
-      );
-    });
-  }
-  async syncCreditNotes(syncParams) {
-    this.config.logger?.info("Syncing credit notes");
-    return this.withSyncRun("credit_notes", "syncCreditNotes", async (cursor, runStartedAt) => {
-      const accountId = await this.getAccountId();
-      const params = { limit: 100 };
-      if (syncParams?.created) {
-        params.created = syncParams.created;
-      } else if (cursor) {
-        params.created = { gte: cursor };
-        this.config.logger?.info(`Incremental sync from cursor: ${cursor}`);
-      }
-      return this.fetchAndUpsert(
-        (pagination) => this.stripe.creditNotes.list({ ...params, ...pagination }),
-        (creditNotes) => this.upsertCreditNotes(creditNotes, accountId),
-        accountId,
-        "credit_notes",
-        runStartedAt
-      );
-    });
-  }
-  async syncFeatures(syncParams) {
-    this.config.logger?.info("Syncing features");
-    return this.withSyncRun("features", "syncFeatures", async (cursor, runStartedAt) => {
-      const accountId = await this.getAccountId();
-      const params = {
-        limit: 100,
-        ...syncParams?.pagination
-      };
-      return this.fetchAndUpsert(
-        () => this.stripe.entitlements.features.list(params),
-        (features) => this.upsertFeatures(features, accountId),
-        accountId,
-        "features",
-        runStartedAt
-      );
-    });
-  }
-  async syncEntitlements(customerId, syncParams) {
-    this.config.logger?.info("Syncing entitlements");
-    return this.withSyncRun(
-      "active_entitlements",
-      "syncEntitlements",
-      async (cursor, runStartedAt) => {
-        const accountId = await this.getAccountId();
-        const params = {
-          customer: customerId,
-          limit: 100,
-          ...syncParams?.pagination
-        };
-        return this.fetchAndUpsert(
-          () => this.stripe.entitlements.activeEntitlements.list(params),
-          (entitlements) => this.upsertActiveEntitlements(customerId, entitlements, accountId),
-          accountId,
-          "active_entitlements",
-          runStartedAt
-        );
-      }
-    );
-  }
-  async syncCheckoutSessions(syncParams) {
-    this.config.logger?.info("Syncing checkout sessions");
-    return this.withSyncRun(
-      "checkout_sessions",
-      "syncCheckoutSessions",
-      async (cursor, runStartedAt) => {
-        const accountId = await this.getAccountId();
-        const params = { limit: 100 };
-        if (syncParams?.created) {
-          params.created = syncParams.created;
-        } else if (cursor) {
-          params.created = { gte: cursor };
-          this.config.logger?.info(`Incremental sync from cursor: ${cursor}`);
-        }
-        return this.fetchAndUpsert(
-          (pagination) => this.stripe.checkout.sessions.list({ ...params, ...pagination }),
-          (items) => this.upsertCheckoutSessions(items, accountId, syncParams?.backfillRelatedEntities),
-          accountId,
-          "checkout_sessions",
-          runStartedAt
-        );
-      }
-    );
-  }
-  /**
-   * Helper to wrap a sync operation in the observable sync system.
-   * Creates/gets a sync run, sets up the object run, gets cursor, and handles completion.
-   *
-   * @param resourceName - The resource being synced (e.g., 'products', 'customers')
-   * @param triggeredBy - What triggered this sync (for observability)
-   * @param fn - The sync function to execute, receives cursor and runStartedAt
-   * @returns The result of the sync function
-   */
-  async withSyncRun(resourceName, triggeredBy, fn) {
-    const accountId = await this.getAccountId();
-    const lastCursor = await this.postgresClient.getLastCompletedCursor(accountId, resourceName);
-    const cursor = lastCursor ? parseInt(lastCursor) : null;
-    const runKey = await this.postgresClient.getOrCreateSyncRun(accountId, triggeredBy);
-    if (!runKey) {
-      const activeRun = await this.postgresClient.getActiveSyncRun(accountId);
-      if (!activeRun) {
-        throw new Error("Failed to get or create sync run");
-      }
-      throw new Error("Another sync is already running for this account");
-    }
-    const { runStartedAt } = runKey;
-    await this.postgresClient.createObjectRuns(accountId, runStartedAt, [resourceName]);
-    await this.postgresClient.tryStartObjectSync(accountId, runStartedAt, resourceName);
-    try {
-      const result = await fn(cursor, runStartedAt);
-      await this.postgresClient.completeObjectSync(accountId, runStartedAt, resourceName);
-      return result;
-    } catch (error) {
-      await this.postgresClient.failObjectSync(
-        accountId,
-        runStartedAt,
-        resourceName,
-        error instanceof Error ? error.message : "Unknown error"
-      );
-      throw error;
-    }
-  }
-  async fetchAndUpsert(fetch2, upsert, accountId, resourceName, runStartedAt) {
-    const CHECKPOINT_SIZE = 100;
-    let totalSynced = 0;
-    let currentBatch = [];
-    try {
-      this.config.logger?.info("Fetching items to sync from Stripe");
-      try {
-        let hasMore = true;
-        let startingAfter = void 0;
-        while (hasMore) {
-          const response = await fetch2(
-            startingAfter ? { starting_after: startingAfter } : void 0
-          );
-          for (const item of response.data) {
-            currentBatch.push(item);
-            if (currentBatch.length >= CHECKPOINT_SIZE) {
-              this.config.logger?.info(`Upserting batch of ${currentBatch.length} items`);
-              await upsert(currentBatch, accountId);
-              totalSynced += currentBatch.length;
-              await this.postgresClient.incrementObjectProgress(
-                accountId,
-                runStartedAt,
-                resourceName,
-                currentBatch.length
-              );
-              const maxCreated = Math.max(
-                ...currentBatch.map((i) => i.created || 0)
-              );
-              if (maxCreated > 0) {
-                await this.postgresClient.updateObjectCursor(
-                  accountId,
-                  runStartedAt,
-                  resourceName,
-                  String(maxCreated)
-                );
-                this.config.logger?.info(`Checkpoint: cursor updated to ${maxCreated}`);
-              }
-              currentBatch = [];
-            }
-          }
-          hasMore = response.has_more;
-          if (response.data.length > 0) {
-            startingAfter = response.data[response.data.length - 1].id;
-          }
-        }
-        if (currentBatch.length > 0) {
-          this.config.logger?.info(`Upserting final batch of ${currentBatch.length} items`);
-          await upsert(currentBatch, accountId);
-          totalSynced += currentBatch.length;
-          await this.postgresClient.incrementObjectProgress(
-            accountId,
-            runStartedAt,
-            resourceName,
-            currentBatch.length
-          );
-          const maxCreated = Math.max(
-            ...currentBatch.map((i) => i.created || 0)
-          );
-          if (maxCreated > 0) {
-            await this.postgresClient.updateObjectCursor(
-              accountId,
-              runStartedAt,
-              resourceName,
-              String(maxCreated)
-            );
-          }
-        }
-      } catch (error) {
-        if (currentBatch.length > 0) {
-          this.config.logger?.info(
-            `Error occurred, saving partial progress: ${currentBatch.length} items`
-          );
-          await upsert(currentBatch, accountId);
-          totalSynced += currentBatch.length;
-          await this.postgresClient.incrementObjectProgress(
-            accountId,
-            runStartedAt,
-            resourceName,
-            currentBatch.length
-          );
-          const maxCreated = Math.max(
-            ...currentBatch.map((i) => i.created || 0)
-          );
-          if (maxCreated > 0) {
-            await this.postgresClient.updateObjectCursor(
-              accountId,
-              runStartedAt,
-              resourceName,
-              String(maxCreated)
-            );
-          }
-        }
-        throw error;
-      }
-      await this.postgresClient.completeObjectSync(accountId, runStartedAt, resourceName);
-      this.config.logger?.info(`Sync complete: ${totalSynced} items synced`);
-      return { synced: totalSynced };
-    } catch (error) {
-      await this.postgresClient.failObjectSync(
-        accountId,
-        runStartedAt,
-        resourceName,
-        error instanceof Error ? error.message : "Unknown error"
-      );
-      throw error;
-    }
-  }
-  async upsertCharges(charges, accountId, backfillRelatedEntities, syncTimestamp) {
-    if (backfillRelatedEntities ?? this.config.backfillRelatedEntities) {
-      await Promise.all([
-        this.backfillCustomers(getUniqueIds(charges, "customer"), accountId),
-        this.backfillInvoices(getUniqueIds(charges, "invoice"), accountId)
-      ]);
-    }
-    await this.expandEntity(
-      charges,
-      "refunds",
-      (id) => this.stripe.refunds.list({ charge: id, limit: 100 })
-    );
-    return this.postgresClient.upsertManyWithTimestampProtection(
-      charges,
-      "charges",
-      accountId,
-      syncTimestamp
-    );
-  }
-  async backfillCharges(chargeIds, accountId) {
-    const missingChargeIds = await this.postgresClient.findMissingEntries("charges", chargeIds);
-    await this.fetchMissingEntities(
-      missingChargeIds,
-      (id) => this.stripe.charges.retrieve(id)
-    ).then((charges) => this.upsertCharges(charges, accountId));
-  }
-  async backfillPaymentIntents(paymentIntentIds, accountId) {
-    const missingIds = await this.postgresClient.findMissingEntries(
-      "payment_intents",
-      paymentIntentIds
-    );
-    await this.fetchMissingEntities(
-      missingIds,
-      (id) => this.stripe.paymentIntents.retrieve(id)
-    ).then((paymentIntents) => this.upsertPaymentIntents(paymentIntents, accountId));
-  }
-  async upsertCreditNotes(creditNotes, accountId, backfillRelatedEntities, syncTimestamp) {
-    if (backfillRelatedEntities ?? this.config.backfillRelatedEntities) {
-      await Promise.all([
-        this.backfillCustomers(getUniqueIds(creditNotes, "customer"), accountId),
-        this.backfillInvoices(getUniqueIds(creditNotes, "invoice"), accountId)
-      ]);
-    }
-    await this.expandEntity(
-      creditNotes,
-      "lines",
-      (id) => this.stripe.creditNotes.listLineItems(id, { limit: 100 })
-    );
-    return this.postgresClient.upsertManyWithTimestampProtection(
-      creditNotes,
-      "credit_notes",
-      accountId,
-      syncTimestamp
-    );
-  }
-  async upsertCheckoutSessions(checkoutSessions, accountId, backfillRelatedEntities, syncTimestamp) {
-    if (backfillRelatedEntities ?? this.config.backfillRelatedEntities) {
-      await Promise.all([
-        this.backfillCustomers(getUniqueIds(checkoutSessions, "customer"), accountId),
-        this.backfillSubscriptions(getUniqueIds(checkoutSessions, "subscription"), accountId),
-        this.backfillPaymentIntents(getUniqueIds(checkoutSessions, "payment_intent"), accountId),
-        this.backfillInvoices(getUniqueIds(checkoutSessions, "invoice"), accountId)
-      ]);
-    }
-    const rows = await this.postgresClient.upsertManyWithTimestampProtection(
-      checkoutSessions,
-      "checkout_sessions",
-      accountId,
-      syncTimestamp
-    );
-    await this.fillCheckoutSessionsLineItems(
-      checkoutSessions.map((cs) => cs.id),
-      accountId,
-      syncTimestamp
-    );
-    return rows;
-  }
-  async upsertEarlyFraudWarning(earlyFraudWarnings, accountId, backfillRelatedEntities, syncTimestamp) {
-    if (backfillRelatedEntities ?? this.config.backfillRelatedEntities) {
-      await Promise.all([
-        this.backfillPaymentIntents(getUniqueIds(earlyFraudWarnings, "payment_intent"), accountId),
-        this.backfillCharges(getUniqueIds(earlyFraudWarnings, "charge"), accountId)
-      ]);
-    }
-    return this.postgresClient.upsertManyWithTimestampProtection(
-      earlyFraudWarnings,
-      "early_fraud_warnings",
-      accountId,
-      syncTimestamp
-    );
-  }
-  async upsertRefunds(refunds, accountId, backfillRelatedEntities, syncTimestamp) {
-    if (backfillRelatedEntities ?? this.config.backfillRelatedEntities) {
-      await Promise.all([
-        this.backfillPaymentIntents(getUniqueIds(refunds, "payment_intent"), accountId),
-        this.backfillCharges(getUniqueIds(refunds, "charge"), accountId)
-      ]);
-    }
-    return this.postgresClient.upsertManyWithTimestampProtection(
-      refunds,
-      "refunds",
-      accountId,
-      syncTimestamp
-    );
-  }
-  async upsertReviews(reviews, accountId, backfillRelatedEntities, syncTimestamp) {
-    if (backfillRelatedEntities ?? this.config.backfillRelatedEntities) {
-      await Promise.all([
-        this.backfillPaymentIntents(getUniqueIds(reviews, "payment_intent"), accountId),
-        this.backfillCharges(getUniqueIds(reviews, "charge"), accountId)
-      ]);
-    }
-    return this.postgresClient.upsertManyWithTimestampProtection(
-      reviews,
-      "reviews",
-      accountId,
-      syncTimestamp
-    );
-  }
-  async upsertCustomers(customers, accountId, syncTimestamp) {
-    const deletedCustomers = customers.filter((customer) => customer.deleted);
-    const nonDeletedCustomers = customers.filter((customer) => !customer.deleted);
-    await this.postgresClient.upsertManyWithTimestampProtection(
-      nonDeletedCustomers,
-      "customers",
-      accountId,
-      syncTimestamp
-    );
-    await this.postgresClient.upsertManyWithTimestampProtection(
-      deletedCustomers,
-      "customers",
-      accountId,
-      syncTimestamp
-    );
-    return customers;
-  }
-  async backfillCustomers(customerIds, accountId) {
-    const missingIds = await this.postgresClient.findMissingEntries("customers", customerIds);
-    await this.fetchMissingEntities(missingIds, (id) => this.stripe.customers.retrieve(id)).then((entries) => this.upsertCustomers(entries, accountId)).catch((err) => {
-      this.config.logger?.error(err, "Failed to backfill");
-      throw err;
-    });
-  }
-  async upsertDisputes(disputes, accountId, backfillRelatedEntities, syncTimestamp) {
-    if (backfillRelatedEntities ?? this.config.backfillRelatedEntities) {
-      await this.backfillCharges(getUniqueIds(disputes, "charge"), accountId);
-    }
-    return this.postgresClient.upsertManyWithTimestampProtection(
-      disputes,
-      "disputes",
-      accountId,
-      syncTimestamp
-    );
-  }
-  async upsertInvoices(invoices, accountId, backfillRelatedEntities, syncTimestamp) {
-    if (backfillRelatedEntities ?? this.config.backfillRelatedEntities) {
-      await Promise.all([
-        this.backfillCustomers(getUniqueIds(invoices, "customer"), accountId),
-        this.backfillSubscriptions(getUniqueIds(invoices, "subscription"), accountId)
-      ]);
-    }
-    await this.expandEntity(
-      invoices,
-      "lines",
-      (id) => this.stripe.invoices.listLineItems(id, { limit: 100 })
-    );
-    return this.postgresClient.upsertManyWithTimestampProtection(
-      invoices,
-      "invoices",
-      accountId,
-      syncTimestamp
-    );
-  }
-  backfillInvoices = async (invoiceIds, accountId) => {
-    const missingIds = await this.postgresClient.findMissingEntries("invoices", invoiceIds);
-    await this.fetchMissingEntities(missingIds, (id) => this.stripe.invoices.retrieve(id)).then(
-      (entries) => this.upsertInvoices(entries, accountId)
-    );
-  };
-  backfillPrices = async (priceIds, accountId) => {
-    const missingIds = await this.postgresClient.findMissingEntries("prices", priceIds);
-    await this.fetchMissingEntities(missingIds, (id) => this.stripe.prices.retrieve(id)).then(
-      (entries) => this.upsertPrices(entries, accountId)
-    );
-  };
-  async upsertPlans(plans, accountId, backfillRelatedEntities, syncTimestamp) {
-    if (backfillRelatedEntities ?? this.config.backfillRelatedEntities) {
-      await this.backfillProducts(getUniqueIds(plans, "product"), accountId);
-    }
-    return this.postgresClient.upsertManyWithTimestampProtection(
-      plans,
-      "plans",
-      accountId,
-      syncTimestamp
-    );
-  }
-  async deletePlan(id) {
-    return this.postgresClient.delete("plans", id);
-  }
-  async upsertPrices(prices, accountId, backfillRelatedEntities, syncTimestamp) {
-    if (backfillRelatedEntities ?? this.config.backfillRelatedEntities) {
-      await this.backfillProducts(getUniqueIds(prices, "product"), accountId);
-    }
-    return this.postgresClient.upsertManyWithTimestampProtection(
-      prices,
-      "prices",
-      accountId,
-      syncTimestamp
-    );
-  }
-  async deletePrice(id) {
-    return this.postgresClient.delete("prices", id);
-  }
-  async upsertProducts(products, accountId, syncTimestamp) {
-    return this.postgresClient.upsertManyWithTimestampProtection(
-      products,
-      "products",
-      accountId,
-      syncTimestamp
-    );
-  }
-  async deleteProduct(id) {
-    return this.postgresClient.delete("products", id);
-  }
-  async backfillProducts(productIds, accountId) {
-    const missingProductIds = await this.postgresClient.findMissingEntries("products", productIds);
-    await this.fetchMissingEntities(
-      missingProductIds,
-      (id) => this.stripe.products.retrieve(id)
-    ).then((products) => this.upsertProducts(products, accountId));
-  }
-  async upsertPaymentIntents(paymentIntents, accountId, backfillRelatedEntities, syncTimestamp) {
-    if (backfillRelatedEntities ?? this.config.backfillRelatedEntities) {
-      await Promise.all([
-        this.backfillCustomers(getUniqueIds(paymentIntents, "customer"), accountId),
-        this.backfillInvoices(getUniqueIds(paymentIntents, "invoice"), accountId)
-      ]);
-    }
-    return this.postgresClient.upsertManyWithTimestampProtection(
-      paymentIntents,
-      "payment_intents",
-      accountId,
-      syncTimestamp
-    );
-  }
-  async upsertPaymentMethods(paymentMethods, accountId, backfillRelatedEntities = false, syncTimestamp) {
-    if (backfillRelatedEntities ?? this.config.backfillRelatedEntities) {
-      await this.backfillCustomers(getUniqueIds(paymentMethods, "customer"), accountId);
-    }
-    return this.postgresClient.upsertManyWithTimestampProtection(
-      paymentMethods,
-      "payment_methods",
-      accountId,
-      syncTimestamp
-    );
-  }
-  async upsertSetupIntents(setupIntents, accountId, backfillRelatedEntities, syncTimestamp) {
-    if (backfillRelatedEntities ?? this.config.backfillRelatedEntities) {
-      await this.backfillCustomers(getUniqueIds(setupIntents, "customer"), accountId);
-    }
-    return this.postgresClient.upsertManyWithTimestampProtection(
-      setupIntents,
-      "setup_intents",
-      accountId,
-      syncTimestamp
-    );
-  }
-  async upsertTaxIds(taxIds, accountId, backfillRelatedEntities, syncTimestamp) {
-    if (backfillRelatedEntities ?? this.config.backfillRelatedEntities) {
-      await this.backfillCustomers(getUniqueIds(taxIds, "customer"), accountId);
-    }
-    return this.postgresClient.upsertManyWithTimestampProtection(
-      taxIds,
-      "tax_ids",
-      accountId,
-      syncTimestamp
-    );
-  }
-  async deleteTaxId(id) {
-    return this.postgresClient.delete("tax_ids", id);
-  }
-  async upsertSubscriptionItems(subscriptionItems, accountId, syncTimestamp) {
-    const modifiedSubscriptionItems = subscriptionItems.map((subscriptionItem) => {
-      const priceId = subscriptionItem.price.id.toString();
-      const deleted = subscriptionItem.deleted;
-      const quantity = subscriptionItem.quantity;
-      return {
-        ...subscriptionItem,
-        price: priceId,
-        deleted: deleted ?? false,
-        quantity: quantity ?? null
-      };
-    });
-    await this.postgresClient.upsertManyWithTimestampProtection(
-      modifiedSubscriptionItems,
-      "subscription_items",
-      accountId,
-      syncTimestamp
-    );
-  }
-  async fillCheckoutSessionsLineItems(checkoutSessionIds, accountId, syncTimestamp) {
-    for (const checkoutSessionId of checkoutSessionIds) {
-      const lineItemResponses = [];
-      let hasMore = true;
-      let startingAfter = void 0;
-      while (hasMore) {
-        const response = await this.stripe.checkout.sessions.listLineItems(checkoutSessionId, {
-          limit: 100,
-          ...startingAfter ? { starting_after: startingAfter } : {}
-        });
-        lineItemResponses.push(...response.data);
-        hasMore = response.has_more;
-        if (response.data.length > 0) {
-          startingAfter = response.data[response.data.length - 1].id;
-        }
-      }
-      await this.upsertCheckoutSessionLineItems(
-        lineItemResponses,
-        checkoutSessionId,
-        accountId,
-        syncTimestamp
-      );
-    }
-  }
-  async upsertCheckoutSessionLineItems(lineItems, checkoutSessionId, accountId, syncTimestamp) {
-    await this.backfillPrices(
-      lineItems.map((lineItem) => lineItem.price?.id?.toString() ?? void 0).filter((id) => id !== void 0),
-      accountId
-    );
-    const modifiedLineItems = lineItems.map((lineItem) => {
-      const priceId = typeof lineItem.price === "object" && lineItem.price?.id ? lineItem.price.id.toString() : lineItem.price?.toString() || null;
-      return {
-        ...lineItem,
-        price: priceId,
-        checkout_session: checkoutSessionId
-      };
-    });
-    await this.postgresClient.upsertManyWithTimestampProtection(
-      modifiedLineItems,
-      "checkout_session_line_items",
-      accountId,
-      syncTimestamp
-    );
-  }
-  async markDeletedSubscriptionItems(subscriptionId, currentSubItemIds) {
-    let prepared = sql2(`
-    select id from "stripe"."subscription_items"
-    where subscription = :subscriptionId and COALESCE(deleted, false) = false;
-    `)({ subscriptionId });
-    const { rows } = await this.postgresClient.query(prepared.text, prepared.values);
-    const deletedIds = rows.filter(
-      ({ id }) => currentSubItemIds.includes(id) === false
-    );
-    if (deletedIds.length > 0) {
-      const ids = deletedIds.map(({ id }) => id);
-      prepared = sql2(`
-      update "stripe"."subscription_items"
-      set _raw_data = jsonb_set(_raw_data, '{deleted}', 'true'::jsonb)
-      where id=any(:ids::text[]);
-      `)({ ids });
-      const { rowCount } = await this.postgresClient.query(prepared.text, prepared.values);
-      return { rowCount: rowCount || 0 };
-    } else {
-      return { rowCount: 0 };
-    }
-  }
-  async upsertSubscriptionSchedules(subscriptionSchedules, accountId, backfillRelatedEntities, syncTimestamp) {
-    if (backfillRelatedEntities ?? this.config.backfillRelatedEntities) {
-      const customerIds = getUniqueIds(subscriptionSchedules, "customer");
-      await this.backfillCustomers(customerIds, accountId);
-    }
-    const rows = await this.postgresClient.upsertManyWithTimestampProtection(
-      subscriptionSchedules,
-      "subscription_schedules",
-      accountId,
-      syncTimestamp
-    );
-    return rows;
-  }
-  async upsertSubscriptions(subscriptions, accountId, backfillRelatedEntities, syncTimestamp) {
-    if (backfillRelatedEntities ?? this.config.backfillRelatedEntities) {
-      const customerIds = getUniqueIds(subscriptions, "customer");
-      await this.backfillCustomers(customerIds, accountId);
-    }
-    await this.expandEntity(
-      subscriptions,
-      "items",
-      (id) => this.stripe.subscriptionItems.list({ subscription: id, limit: 100 })
-    );
-    const rows = await this.postgresClient.upsertManyWithTimestampProtection(
-      subscriptions,
-      "subscriptions",
-      accountId,
-      syncTimestamp
-    );
-    const allSubscriptionItems = subscriptions.flatMap((subscription) => subscription.items.data);
-    await this.upsertSubscriptionItems(allSubscriptionItems, accountId, syncTimestamp);
-    const markSubscriptionItemsDeleted = [];
-    for (const subscription of subscriptions) {
-      const subscriptionItems = subscription.items.data;
-      const subItemIds = subscriptionItems.map((x) => x.id);
-      markSubscriptionItemsDeleted.push(
-        this.markDeletedSubscriptionItems(subscription.id, subItemIds)
-      );
-    }
-    await Promise.all(markSubscriptionItemsDeleted);
-    return rows;
-  }
-  async deleteRemovedActiveEntitlements(customerId, currentActiveEntitlementIds) {
-    const prepared = sql2(`
-      delete from "stripe"."active_entitlements"
-      where customer = :customerId and id <> ALL(:currentActiveEntitlementIds::text[]);
-      `)({ customerId, currentActiveEntitlementIds });
-    const { rowCount } = await this.postgresClient.query(prepared.text, prepared.values);
-    return { rowCount: rowCount || 0 };
-  }
-  async upsertFeatures(features, accountId, syncTimestamp) {
-    return this.postgresClient.upsertManyWithTimestampProtection(
-      features,
-      "features",
-      accountId,
-      syncTimestamp
-    );
-  }
-  async backfillFeatures(featureIds, accountId) {
-    const missingFeatureIds = await this.postgresClient.findMissingEntries("features", featureIds);
-    await this.fetchMissingEntities(
-      missingFeatureIds,
-      (id) => this.stripe.entitlements.features.retrieve(id)
-    ).then((features) => this.upsertFeatures(features, accountId)).catch((err) => {
-      this.config.logger?.error(err, "Failed to backfill features");
-      throw err;
-    });
-  }
-  async upsertActiveEntitlements(customerId, activeEntitlements, accountId, backfillRelatedEntities, syncTimestamp) {
-    if (backfillRelatedEntities ?? this.config.backfillRelatedEntities) {
-      await Promise.all([
-        this.backfillCustomers(getUniqueIds(activeEntitlements, "customer"), accountId),
-        this.backfillFeatures(getUniqueIds(activeEntitlements, "feature"), accountId)
-      ]);
-    }
-    const entitlements = activeEntitlements.map((entitlement) => ({
-      id: entitlement.id,
-      object: entitlement.object,
-      feature: typeof entitlement.feature === "string" ? entitlement.feature : entitlement.feature.id,
-      customer: customerId,
-      livemode: entitlement.livemode,
-      lookup_key: entitlement.lookup_key
-    }));
-    return this.postgresClient.upsertManyWithTimestampProtection(
-      entitlements,
-      "active_entitlements",
-      accountId,
-      syncTimestamp
-    );
-  }
-  async findOrCreateManagedWebhook(url, params) {
-    const webhookParams = {
-      enabled_events: this.getSupportedEventTypes(),
-      ...params
-    };
-    const accountId = await this.getAccountId();
-    const lockKey = `webhook:${accountId}:${url}`;
-    return this.postgresClient.withAdvisoryLock(lockKey, async () => {
-      const existingWebhook = await this.getManagedWebhookByUrl(url);
-      if (existingWebhook) {
-        try {
-          const stripeWebhook = await this.stripe.webhookEndpoints.retrieve(existingWebhook.id);
-          if (stripeWebhook.status === "enabled") {
-            return stripeWebhook;
-          }
-          this.config.logger?.info(
-            { webhookId: existingWebhook.id },
-            "Webhook is disabled, deleting and will recreate"
-          );
-          await this.stripe.webhookEndpoints.del(existingWebhook.id);
-          await this.postgresClient.delete("_managed_webhooks", existingWebhook.id);
-        } catch (error) {
-          const stripeError = error;
-          if (stripeError?.statusCode === 404 || stripeError?.code === "resource_missing") {
-            this.config.logger?.warn(
-              { error, webhookId: existingWebhook.id },
-              "Webhook not found in Stripe (404), removing from database"
-            );
-            await this.postgresClient.delete("_managed_webhooks", existingWebhook.id);
-          } else {
-            this.config.logger?.error(
-              { error, webhookId: existingWebhook.id },
-              "Error retrieving webhook from Stripe, keeping in database"
-            );
-            throw error;
-          }
-        }
-      }
-      const allDbWebhooks = await this.listManagedWebhooks();
-      for (const dbWebhook of allDbWebhooks) {
-        if (dbWebhook.url !== url) {
-          this.config.logger?.info(
-            { webhookId: dbWebhook.id, oldUrl: dbWebhook.url, newUrl: url },
-            "Webhook URL mismatch, deleting"
-          );
-          try {
-            await this.stripe.webhookEndpoints.del(dbWebhook.id);
-          } catch (error) {
-            this.config.logger?.warn(
-              { error, webhookId: dbWebhook.id },
-              "Failed to delete old webhook from Stripe"
-            );
-          }
-          await this.postgresClient.delete("_managed_webhooks", dbWebhook.id);
-        }
-      }
-      try {
-        const stripeWebhooks = await this.stripe.webhookEndpoints.list({ limit: 100 });
-        for (const stripeWebhook of stripeWebhooks.data) {
-          const isManagedByMetadata = stripeWebhook.metadata?.managed_by?.toLowerCase().replace(/[\s\-]+/g, "") === "stripesync";
-          const normalizedDescription = stripeWebhook.description?.toLowerCase().replace(/[\s\-]+/g, "") || "";
-          const isManagedByDescription = normalizedDescription.includes("stripesync");
-          if (isManagedByMetadata || isManagedByDescription) {
-            const existsInDb = allDbWebhooks.some((dbWebhook) => dbWebhook.id === stripeWebhook.id);
-            if (!existsInDb) {
-              this.config.logger?.warn(
-                { webhookId: stripeWebhook.id, url: stripeWebhook.url },
-                "Found orphaned managed webhook in Stripe, deleting"
-              );
-              await this.stripe.webhookEndpoints.del(stripeWebhook.id);
-            }
-          }
-        }
-      } catch (error) {
-        this.config.logger?.warn({ error }, "Failed to check for orphaned webhooks");
-      }
-      const webhook = await this.stripe.webhookEndpoints.create({
-        ...webhookParams,
-        url,
-        // Always set metadata to identify managed webhooks
-        metadata: {
-          ...webhookParams.metadata,
-          managed_by: "stripe-sync",
-          version: package_default.version
-        }
-      });
-      const accountId2 = await this.getAccountId();
-      await this.upsertManagedWebhooks([webhook], accountId2);
-      return webhook;
-    });
-  }
-  async getManagedWebhook(id) {
-    const accountId = await this.getAccountId();
-    const result = await this.postgresClient.query(
-      `SELECT * FROM "stripe"."_managed_webhooks" WHERE id = $1 AND "account_id" = $2`,
-      [id, accountId]
-    );
-    return result.rows.length > 0 ? result.rows[0] : null;
-  }
-  /**
-   * Get a managed webhook by URL and account ID.
-   * Used for race condition recovery: when createManagedWebhook hits a unique constraint
-   * violation (another instance created the webhook), we need to fetch the existing webhook
-   * by URL since we only know the URL, not the ID of the webhook that won the race.
-   */
-  async getManagedWebhookByUrl(url) {
-    const accountId = await this.getAccountId();
-    const result = await this.postgresClient.query(
-      `SELECT * FROM "stripe"."_managed_webhooks" WHERE url = $1 AND "account_id" = $2`,
-      [url, accountId]
-    );
-    return result.rows.length > 0 ? result.rows[0] : null;
-  }
-  async listManagedWebhooks() {
-    const accountId = await this.getAccountId();
-    const result = await this.postgresClient.query(
-      `SELECT * FROM "stripe"."_managed_webhooks" WHERE "account_id" = $1 ORDER BY created DESC`,
-      [accountId]
-    );
-    return result.rows;
-  }
-  async updateManagedWebhook(id, params) {
-    const webhook = await this.stripe.webhookEndpoints.update(id, params);
-    const accountId = await this.getAccountId();
-    await this.upsertManagedWebhooks([webhook], accountId);
-    return webhook;
-  }
-  async deleteManagedWebhook(id) {
-    await this.stripe.webhookEndpoints.del(id);
-    return this.postgresClient.delete("_managed_webhooks", id);
-  }
-  async upsertManagedWebhooks(webhooks, accountId, syncTimestamp) {
-    const filteredWebhooks = webhooks.map((webhook) => {
-      const filtered = {};
-      for (const prop of managedWebhookSchema.properties) {
-        if (prop in webhook) {
-          filtered[prop] = webhook[prop];
-        }
-      }
-      return filtered;
-    });
-    return this.postgresClient.upsertManyWithTimestampProtection(
-      filteredWebhooks,
-      "_managed_webhooks",
-      accountId,
-      syncTimestamp
-    );
-  }
-  async backfillSubscriptions(subscriptionIds, accountId) {
-    const missingSubscriptionIds = await this.postgresClient.findMissingEntries(
-      "subscriptions",
-      subscriptionIds
-    );
-    await this.fetchMissingEntities(
-      missingSubscriptionIds,
-      (id) => this.stripe.subscriptions.retrieve(id)
-    ).then((subscriptions) => this.upsertSubscriptions(subscriptions, accountId));
-  }
-  backfillSubscriptionSchedules = async (subscriptionIds, accountId) => {
-    const missingSubscriptionIds = await this.postgresClient.findMissingEntries(
-      "subscription_schedules",
-      subscriptionIds
-    );
-    await this.fetchMissingEntities(
-      missingSubscriptionIds,
-      (id) => this.stripe.subscriptionSchedules.retrieve(id)
-    ).then(
-      (subscriptionSchedules) => this.upsertSubscriptionSchedules(subscriptionSchedules, accountId)
-    );
-  };
-  /**
-   * Stripe only sends the first 10 entries by default, the option will actively fetch all entries.
-   * Uses manual pagination - each fetch() gets automatic retry protection.
-   */
-  async expandEntity(entities, property, listFn) {
-    if (!this.config.autoExpandLists) return;
-    for (const entity of entities) {
-      if (entity[property]?.has_more) {
-        const allData = [];
-        let hasMore = true;
-        let startingAfter = void 0;
-        while (hasMore) {
-          const response = await listFn(
-            entity.id,
-            startingAfter ? { starting_after: startingAfter } : void 0
-          );
-          allData.push(...response.data);
-          hasMore = response.has_more;
-          if (response.data.length > 0) {
-            startingAfter = response.data[response.data.length - 1].id;
-          }
-        }
-        entity[property] = {
-          ...entity[property],
-          data: allData,
-          has_more: false
-        };
-      }
-    }
-  }
-  async fetchMissingEntities(ids, fetch2) {
-    if (!ids.length) return [];
-    const entities = [];
-    for (const id of ids) {
-      const entity = await fetch2(id);
-      entities.push(entity);
-    }
-    return entities;
-  }
-  /**
-   * Closes the database connection pool and cleans up resources.
-   * Call this when you're done using the StripeSync instance.
-   */
-  async close() {
-    await this.postgresClient.pool.end();
-  }
-};
-function chunkArray(array, chunkSize) {
-  const result = [];
-  for (let i = 0; i < array.length; i += chunkSize) {
-    result.push(array.slice(i, i + chunkSize));
-  }
-  return result;
-}
-
-// src/database/migrate.ts
-import { Client } from "pg";
-import { migrate } from "pg-node-migrations";
-import fs from "fs";
-import path from "path";
-import { fileURLToPath } from "url";
-var __filename2 = fileURLToPath(import.meta.url);
-var __dirname2 = path.dirname(__filename2);
-async function doesTableExist(client, schema, tableName) {
-  const result = await client.query(
-    `SELECT EXISTS (
-      SELECT 1
-      FROM information_schema.tables
-      WHERE table_schema = $1
-      AND table_name = $2
-    )`,
-    [schema, tableName]
-  );
-  return result.rows[0]?.exists || false;
-}
-async function renameMigrationsTableIfNeeded(client, schema = "stripe", logger) {
-  const oldTableExists = await doesTableExist(client, schema, "migrations");
-  const newTableExists = await doesTableExist(client, schema, "_migrations");
-  if (oldTableExists && !newTableExists) {
-    logger?.info("Renaming migrations table to _migrations");
-    await client.query(`ALTER TABLE "${schema}"."migrations" RENAME TO "_migrations"`);
-    logger?.info("Successfully renamed migrations table");
-  }
-}
-async function cleanupSchema(client, schema, logger) {
-  logger?.warn(`Migrations table is empty - dropping and recreating schema "${schema}"`);
-  await client.query(`DROP SCHEMA IF EXISTS "${schema}" CASCADE`);
-  await client.query(`CREATE SCHEMA "${schema}"`);
-  logger?.info(`Schema "${schema}" has been reset`);
-}
-async function connectAndMigrate(client, migrationsDirectory, config, logOnError = false) {
-  if (!fs.existsSync(migrationsDirectory)) {
-    config.logger?.info(`Migrations directory ${migrationsDirectory} not found, skipping`);
-    return;
-  }
-  const optionalConfig = {
-    schemaName: "stripe",
-    tableName: "_migrations"
-  };
-  try {
-    await migrate({ client }, migrationsDirectory, optionalConfig);
-  } catch (error) {
-    if (logOnError && error instanceof Error) {
-      config.logger?.error(error, "Migration error:");
-    } else {
-      throw error;
-    }
-  }
-}
-async function runMigrations(config) {
-  const client = new Client({
-    connectionString: config.databaseUrl,
-    ssl: config.ssl,
-    connectionTimeoutMillis: 1e4
-  });
-  const schema = "stripe";
-  try {
-    await client.connect();
-    await client.query(`CREATE SCHEMA IF NOT EXISTS ${schema};`);
-    await renameMigrationsTableIfNeeded(client, schema, config.logger);
-    const tableExists = await doesTableExist(client, schema, "_migrations");
-    if (tableExists) {
-      const migrationCount = await client.query(
-        `SELECT COUNT(*) as count FROM "${schema}"."_migrations"`
-      );
-      const isEmpty = migrationCount.rows[0]?.count === "0";
-      if (isEmpty) {
-        await cleanupSchema(client, schema, config.logger);
-      }
-    }
-    config.logger?.info("Running migrations");
-    await connectAndMigrate(client, path.resolve(__dirname2, "./migrations"), config);
-  } catch (err) {
-    config.logger?.error(err, "Error running migrations");
-    throw err;
-  } finally {
-    await client.end();
-    config.logger?.info("Finished migrations");
-  }
-}
-
-// src/websocket-client.ts
-import WebSocket from "ws";
-var CLI_VERSION = "1.33.0";
-var PONG_WAIT = 10 * 1e3;
-var PING_PERIOD = PONG_WAIT * 9 / 10;
-var CONNECT_ATTEMPT_WAIT = 10 * 1e3;
-var DEFAULT_RECONNECT_INTERVAL = 60 * 1e3;
-function getClientUserAgent() {
-  return JSON.stringify({
-    name: "stripe-cli",
-    version: CLI_VERSION,
-    publisher: "stripe",
-    os: process.platform
-  });
-}
-async function createCliSession(stripeApiKey) {
-  const params = new URLSearchParams();
-  params.append("device_name", "stripe-sync-engine");
-  params.append("websocket_features[]", "webhooks");
-  const response = await fetch("https://api.stripe.com/v1/stripecli/sessions", {
-    method: "POST",
-    headers: {
-      Authorization: `Bearer ${stripeApiKey}`,
-      "Content-Type": "application/x-www-form-urlencoded",
-      "User-Agent": `Stripe/v1 stripe-cli/${CLI_VERSION}`,
-      "X-Stripe-Client-User-Agent": getClientUserAgent()
-    },
-    body: params.toString()
-  });
-  if (!response.ok) {
-    const error = await response.text();
-    throw new Error(`Failed to create CLI session: ${error}`);
-  }
-  return await response.json();
-}
-function sleep3(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-async function createStripeWebSocketClient(options) {
-  const { stripeApiKey, onEvent, onReady, onError, onClose } = options;
-  const session = await createCliSession(stripeApiKey);
-  const reconnectInterval = session.reconnect_delay ? session.reconnect_delay * 1e3 : DEFAULT_RECONNECT_INTERVAL;
-  let ws = null;
-  let pingInterval = null;
-  let reconnectTimer = null;
-  let connected = false;
-  let shouldRun = true;
-  let lastPongReceived = Date.now();
-  let notifyCloseResolve = null;
-  let stopResolve = null;
-  function cleanupConnection() {
-    if (pingInterval) {
-      clearInterval(pingInterval);
-      pingInterval = null;
-    }
-    if (reconnectTimer) {
-      clearTimeout(reconnectTimer);
-      reconnectTimer = null;
-    }
-    if (ws) {
-      ws.removeAllListeners();
-      if (ws.readyState === WebSocket.OPEN || ws.readyState === WebSocket.CONNECTING) {
-        ws.close(1e3, "Resetting connection");
-      }
-      ws = null;
-    }
-    connected = false;
-  }
-  function setupWebSocket() {
-    return new Promise((resolve, reject) => {
-      lastPongReceived = Date.now();
-      const wsUrl = `${session.websocket_url}?websocket_feature=${encodeURIComponent(session.websocket_authorized_feature)}`;
-      ws = new WebSocket(wsUrl, {
-        headers: {
-          "Accept-Encoding": "identity",
-          "User-Agent": `Stripe/v1 stripe-cli/${CLI_VERSION}`,
-          "X-Stripe-Client-User-Agent": getClientUserAgent(),
-          "Websocket-Id": session.websocket_id
-        }
-      });
-      const connectionTimeout = setTimeout(() => {
-        if (ws && ws.readyState === WebSocket.CONNECTING) {
-          ws.terminate();
-          reject(new Error("WebSocket connection timeout"));
-        }
-      }, CONNECT_ATTEMPT_WAIT);
-      ws.on("pong", () => {
-        lastPongReceived = Date.now();
-      });
-      ws.on("open", () => {
-        clearTimeout(connectionTimeout);
-        connected = true;
-        pingInterval = setInterval(() => {
-          if (ws && ws.readyState === WebSocket.OPEN) {
-            const timeSinceLastPong = Date.now() - lastPongReceived;
-            if (timeSinceLastPong > PONG_WAIT) {
-              if (onError) {
-                onError(new Error(`WebSocket stale: no pong in ${timeSinceLastPong}ms`));
-              }
-              if (notifyCloseResolve) {
-                notifyCloseResolve();
-                notifyCloseResolve = null;
-              }
-              ws.terminate();
-              return;
-            }
-            ws.ping();
-          }
-        }, PING_PERIOD);
-        if (onReady) {
-          onReady(session.secret);
-        }
-        resolve();
-      });
-      ws.on("message", async (data) => {
-        try {
-          const message = JSON.parse(data.toString());
-          const ack = {
-            type: "event_ack",
-            event_id: message.webhook_id,
-            webhook_conversation_id: message.webhook_conversation_id,
-            webhook_id: message.webhook_id
-          };
-          if (ws && ws.readyState === WebSocket.OPEN) {
-            ws.send(JSON.stringify(ack));
-          }
-          let response;
-          try {
-            const result = await onEvent(message);
-            response = {
-              type: "webhook_response",
-              webhook_id: message.webhook_id,
-              webhook_conversation_id: message.webhook_conversation_id,
-              forward_url: "stripe-sync-engine",
-              status: result?.status ?? 200,
-              http_headers: {},
-              body: JSON.stringify({
-                event_type: result?.event_type,
-                event_id: result?.event_id,
-                database_url: result?.databaseUrl,
-                error: result?.error
-              }),
-              request_headers: message.http_headers,
-              request_body: message.event_payload,
-              notification_id: message.webhook_id
-            };
-          } catch (err) {
-            const errorMessage = err instanceof Error ? err.message : String(err);
-            response = {
-              type: "webhook_response",
-              webhook_id: message.webhook_id,
-              webhook_conversation_id: message.webhook_conversation_id,
-              forward_url: "stripe-sync-engine",
-              status: 500,
-              http_headers: {},
-              body: JSON.stringify({ error: errorMessage }),
-              request_headers: message.http_headers,
-              request_body: message.event_payload,
-              notification_id: message.webhook_id
-            };
-            if (onError) {
-              onError(err instanceof Error ? err : new Error(errorMessage));
-            }
-          }
-          if (ws && ws.readyState === WebSocket.OPEN) {
-            ws.send(JSON.stringify(response));
-          }
-        } catch (err) {
-          if (onError) {
-            onError(err instanceof Error ? err : new Error(String(err)));
-          }
-        }
-      });
-      ws.on("error", (error) => {
-        clearTimeout(connectionTimeout);
-        if (onError) {
-          onError(error);
-        }
-        if (!connected) {
-          reject(error);
-        }
-      });
-      ws.on("close", (code, reason) => {
-        clearTimeout(connectionTimeout);
-        connected = false;
-        if (pingInterval) {
-          clearInterval(pingInterval);
-          pingInterval = null;
-        }
-        if (onClose) {
-          onClose(code, reason.toString());
-        }
-        if (notifyCloseResolve) {
-          notifyCloseResolve();
-          notifyCloseResolve = null;
-        }
-      });
-    });
-  }
-  async function runLoop() {
-    while (shouldRun) {
-      connected = false;
-      let connectError = null;
-      do {
-        try {
-          await setupWebSocket();
-          connectError = null;
-        } catch (err) {
-          connectError = err instanceof Error ? err : new Error(String(err));
-          if (onError) {
-            onError(connectError);
-          }
-          if (shouldRun) {
-            await sleep3(CONNECT_ATTEMPT_WAIT);
-          }
-        }
-      } while (connectError && shouldRun);
-      if (!shouldRun) break;
-      await new Promise((resolve) => {
-        notifyCloseResolve = resolve;
-        stopResolve = resolve;
-        reconnectTimer = setTimeout(() => {
-          cleanupConnection();
-          resolve();
-        }, reconnectInterval);
-      });
-      if (reconnectTimer) {
-        clearTimeout(reconnectTimer);
-        reconnectTimer = null;
-      }
-      notifyCloseResolve = null;
-      stopResolve = null;
-    }
-    cleanupConnection();
-  }
-  runLoop();
-  return {
-    close: () => {
-      shouldRun = false;
-      if (stopResolve) {
-        stopResolve();
-        stopResolve = null;
-      }
-      cleanupConnection();
-    },
-    isConnected: () => connected
-  };
-}
-
-// src/index.ts
-var VERSION = package_default.version;
-
-export {
-  PostgresClient,
-  hashApiKey,
-  StripeSync,
-  runMigrations,
-  createStripeWebSocketClient,
-  VERSION
-};