@paymentsdb/sync-engine 0.0.1

package/dist/chunk-3OQVG44L.js

@@ -0,0 +1,4196 @@
+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",
+  "balance_transactions",
+  "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
+    },
+    balance_transaction: {
+      order: 8,
+      // Before charge
+      listFn: (p) => this.stripe.balanceTransactions.list(p),
+      upsertFn: (items, id) => this.upsertBalanceTransactions(items, id),
+      supportsCreatedFilter: true
+    },
+    charge: {
+      order: 9,
+      // 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: 10,
+      // Depends on customer
+      listFn: (p) => this.stripe.setupIntents.list(p),
+      upsertFn: (items, id, bf) => this.upsertSetupIntents(items, id, bf),
+      supportsCreatedFilter: true
+    },
+    payment_method: {
+      order: 11,
+      // 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: 12,
+      // Depends on customer
+      listFn: (p) => this.stripe.paymentIntents.list(p),
+      upsertFn: (items, id, bf) => this.upsertPaymentIntents(items, id, bf),
+      supportsCreatedFilter: true
+    },
+    tax_id: {
+      order: 13,
+      // 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: 14,
+      // 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: 15,
+      // 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: 16,
+      // Depends on charge
+      listFn: (p) => this.stripe.radar.earlyFraudWarnings.list(p),
+      upsertFn: (items, id) => this.upsertEarlyFraudWarning(items, id),
+      supportsCreatedFilter: true
+    },
+    refund: {
+      order: 17,
+      // Depends on charge
+      listFn: (p) => this.stripe.refunds.list(p),
+      upsertFn: (items, id, bf) => this.upsertRefunds(items, id, bf),
+      supportsCreatedFilter: true
+    },
+    checkout_sessions: {
+      order: 18,
+      // 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: 19,
+      supportsCreatedFilter: false,
+      sigma: SIGMA_INGESTION_CONFIGS.subscription_item_change_events_v2_beta
+    },
+    exchange_rates_from_usd: {
+      order: 20,
+      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, { expand: ["balance_transaction"] }),
+      (charge2) => charge2.status === "failed" || charge2.status === "succeeded"
+    );
+    const syncTimestamp = this.getSyncTimestamp(event, refetched);
+    if (charge.balance_transaction && typeof charge.balance_transaction === "object") {
+      await this.upsertBalanceTransactions(
+        [charge.balance_transaction],
+        accountId,
+        syncTimestamp
+      );
+    }
+    await this.upsertCharges([charge], accountId, false, syncTimestamp);
+  }
+  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, { expand: ["balance_transactions"] }),
+      (dispute2) => dispute2.status === "won" || dispute2.status === "lost"
+    );
+    const syncTimestamp = this.getSyncTimestamp(event, refetched);
+    if (dispute.balance_transactions && Array.isArray(dispute.balance_transactions)) {
+      const expandedBalanceTransactions = dispute.balance_transactions.filter(
+        (bt) => typeof bt === "object" && bt !== null
+      );
+      if (expandedBalanceTransactions.length > 0) {
+        await this.upsertBalanceTransactions(expandedBalanceTransactions, accountId, syncTimestamp);
+      }
+    }
+    await this.upsertDisputes([dispute], accountId, false, syncTimestamp);
+  }
+  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, { expand: ["balance_transaction"] })
+    );
+    const syncTimestamp = this.getSyncTimestamp(event, refetched);
+    if (refund.balance_transaction && typeof refund.balance_transaction === "object") {
+      await this.upsertBalanceTransactions(
+        [refund.balance_transaction],
+        accountId,
+        syncTimestamp
+      );
+    }
+    await this.upsertRefunds([refund], accountId, false, syncTimestamp);
+  }
+  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",
+      balance_transaction: "balance_transactions",
+      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 syncBalanceTransactions(syncParams) {
+    this.config.logger?.info("Syncing balance_transactions");
+    return this.withSyncRun(
+      "balance_transactions",
+      "syncBalanceTransactions",
+      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.balanceTransactions.list({ ...params, ...pagination }),
+          (items) => this.upsertBalanceTransactions(items, accountId),
+          accountId,
+          "balance_transactions",
+          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 upsertBalanceTransactions(balanceTransactions, accountId, syncTimestamp) {
+    return this.postgresClient.upsertManyWithTimestampProtection(
+      balanceTransactions,
+      "balance_transactions",
+      accountId,
+      syncTimestamp
+    );
+  }
+  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
+};