stripe-experiment-sync 1.0.6 → 1.0.7

package/dist/index.js

@@ -1,3259 +1,11 @@
 import {
-  package_default
-} from "./chunk-3UERGK2O.js";
-
-// src/stripeSync.ts
-import Stripe2 from "stripe";
-import { pg as sql2 } from "yesql";
-
-// src/database/postgres.ts
-import pg from "pg";
-import { pg as sql } from "yesql";
-var ORDERED_STRIPE_TABLES = [
-  "subscription_items",
-  "subscriptions",
-  "subscription_schedules",
-  "checkout_session_line_items",
-  "checkout_sessions",
-  "tax_ids",
-  "charges",
-  "refunds",
-  "credit_notes",
-  "disputes",
-  "early_fraud_warnings",
-  "invoices",
-  "payment_intents",
-  "payment_methods",
-  "setup_intents",
-  "prices",
-  "plans",
-  "products",
-  "features",
-  "active_entitlements",
-  "reviews",
-  "_managed_webhooks",
-  "customers",
-  "_sync_obj_run",
-  // Must be deleted before _sync_run (foreign key)
-  "_sync_run"
-];
-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) {
-    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 rawData = JSON.stringify(entry);
-          const upsertSql = `
-            INSERT INTO "${this.config.schema}"."${table}" ("_raw_data", "_last_synced_at", "_account_id")
-            VALUES ($1::jsonb, $2, $3)
-            ON CONFLICT (id)
-            DO UPDATE SET
-              "_raw_data" = EXCLUDED."_raw_data",
-              "_last_synced_at" = $2,
-              "_account_id" = EXCLUDED."_account_id"
-            WHERE "${table}"."_last_synced_at" IS NULL
-               OR "${table}"."_last_synced_at" < $2
-            RETURNING *
-          `;
-          queries.push(this.pool.query(upsertSql, [rawData, timestamp, accountId]));
-        }
-      });
-      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_run (parent) and _sync_obj_run (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_run" o
-       SET status = 'error',
-           error_message = 'Auto-cancelled: stale (no update in 5 min)',
-           completed_at = now()
-       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_run" 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_run" 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_run" 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_run"
-       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_run" ("_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_run"
-       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_dashboard view.
-   */
-  async getSyncRun(accountId, runStartedAt) {
-    const result = await this.query(
-      `SELECT "_account_id", started_at, max_concurrent, closed_at
-       FROM "${this.config.schema}"."_sync_run"
-       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_run"
-       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'.
-   */
-  async createObjectRuns(accountId, runStartedAt, objects) {
-    if (objects.length === 0) return;
-    const values = objects.map((_, i) => `($1, $2, $${i + 3})`).join(", ");
-    await this.query(
-      `INSERT INTO "${this.config.schema}"."_sync_obj_run" ("_account_id", run_started_at, object)
-       VALUES ${values}
-       ON CONFLICT ("_account_id", run_started_at, object) DO NOTHING`,
-      [accountId, runStartedAt, ...objects]
-    );
-  }
-  /**
-   * 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_run"
-       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
-       FROM "${this.config.schema}"."_sync_obj_run"
-       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
-    };
-  }
-  /**
-   * 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_run"
-       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 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_run"
-         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_run"
-         SET cursor = $4, 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.
-   * This considers completed, error, AND running runs to ensure recovery syncs
-   * don't re-process data that was already synced before a crash.
-   * A 'running' status with a cursor means the process was killed mid-sync.
-   */
-  async getLastCompletedCursor(accountId, object) {
-    const result = await this.query(
-      `SELECT MAX(o.cursor::bigint)::text as cursor
-       FROM "${this.config.schema}"."_sync_obj_run" o
-       WHERE o."_account_id" = $1
-         AND o.object = $2
-         AND o.cursor IS NOT NULL`,
-      [accountId, object]
-    );
-    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_run" WHERE "_account_id" = $1`,
-      [accountId]
-    );
-    await this.query(`DELETE FROM "${this.config.schema}"."_sync_run" 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_run"
-       SET status = 'complete', completed_at = now()
-       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_run"
-       SET status = 'error', error_message = $4, completed_at = now()
-       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_run"
-       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_run"
-       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_run"
-       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_run"
-       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/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 Stripe2(config.stripeSecretKey, {
-      // https://github.com/stripe/stripe-node#configuration
-      // @ts-ignore
-      apiVersion: config.stripeApiVersion,
-      appInfo: {
-        name: "Stripe Postgres Sync"
-      }
-    });
-    this.stripe = createRetryableStripeClient(baseStripe, {}, config.logger);
-    this.config.logger = config.logger ?? console;
-    this.config.logger?.info(
-      { autoExpandLists: config.autoExpandLists, stripeApiVersion: config.stripeApiVersion },
-      "StripeSync initialized"
-    );
-    const poolConfig = config.poolConfig ?? {};
-    if (config.databaseUrl) {
-      poolConfig.connectionString = config.databaseUrl;
-    }
-    if (config.maxPostgresConnections) {
-      poolConfig.max = config.maxPostgresConnections;
-    }
-    if (poolConfig.max === void 0) {
-      poolConfig.max = 10;
-    }
-    if (poolConfig.keepAlive === void 0) {
-      poolConfig.keepAlive = true;
-    }
-    this.postgresClient = new PostgresClient({
-      schema: "stripe",
-      poolConfig
-    });
-  }
-  stripe;
-  postgresClient;
-  /**
-   * Get the Stripe account ID. Delegates to getCurrentAccount() for the actual lookup.
-   */
-  async getAccountId(objectAccountId) {
-    const account = await this.getCurrentAccount(objectAccountId);
-    if (!account) {
-      throw new Error("Failed to retrieve Stripe account. Please ensure API key is valid.");
-    }
-    return account.id;
-  }
-  /**
-   * Upsert Stripe account information to the database
-   * @param account - Stripe account object
-   * @param apiKeyHash - SHA-256 hash of API key to store for fast lookups
-   */
-  async upsertAccount(account, apiKeyHash) {
-    try {
-      await this.postgresClient.upsertAccount(
-        {
-          id: account.id,
-          raw_data: account
-        },
-        apiKeyHash
-      );
-    } catch (error) {
-      this.config.logger?.error(error, "Failed to upsert account to database");
-      const errorMessage = error instanceof Error ? error.message : "Unknown error";
-      throw new Error(`Failed to upsert account to database: ${errorMessage}`);
-    }
-  }
-  /**
-   * Get the current account being synced. Uses database lookup by API key hash,
-   * with fallback to Stripe API if not found (first-time setup or new API key).
-   * @param objectAccountId - Optional account ID from event data (Connect scenarios)
-   */
-  async getCurrentAccount(objectAccountId) {
-    const apiKeyHash = hashApiKey(this.config.stripeSecretKey);
-    try {
-      const account = await this.postgresClient.getAccountByApiKeyHash(apiKeyHash);
-      if (account) {
-        return account;
-      }
-    } catch (error) {
-      this.config.logger?.warn(
-        error,
-        "Failed to lookup account by API key hash, falling back to API"
-      );
-    }
-    try {
-      const accountIdParam = objectAccountId || this.config.stripeAccountId;
-      const account = accountIdParam ? await this.stripe.accounts.retrieve(accountIdParam) : await this.stripe.accounts.retrieve();
-      await this.upsertAccount(account, apiKeyHash);
-      return account;
-    } catch (error) {
-      this.config.logger?.error(error, "Failed to retrieve account from Stripe API");
-      return null;
-    }
-  }
-  /**
-   * Get all accounts that have been synced to the database
-   */
-  async getAllSyncedAccounts() {
-    try {
-      const accountsData = await this.postgresClient.getAllAccounts();
-      return accountsData;
-    } catch (error) {
-      this.config.logger?.error(error, "Failed to retrieve accounts from database");
-      throw new Error("Failed to retrieve synced accounts from database");
-    }
-  }
-  /**
-   * DANGEROUS: Delete an account and all associated data from the database
-   * This operation cannot be undone!
-   *
-   * @param accountId - The Stripe account ID to delete
-   * @param options - Options for deletion behavior
-   * @param options.dryRun - If true, only count records without deleting (default: false)
-   * @param options.useTransaction - If true, use transaction for atomic deletion (default: true)
-   * @returns Deletion summary with counts and warnings
-   */
-  async dangerouslyDeleteSyncedAccountData(accountId, options) {
-    const dryRun = options?.dryRun ?? false;
-    const useTransaction = options?.useTransaction ?? true;
-    this.config.logger?.info(
-      `${dryRun ? "Preview" : "Deleting"} account ${accountId} (transaction: ${useTransaction})`
-    );
-    try {
-      const counts = await this.postgresClient.getAccountRecordCounts(accountId);
-      const warnings = [];
-      let totalRecords = 0;
-      for (const [table, count] of Object.entries(counts)) {
-        if (count > 0) {
-          totalRecords += count;
-          warnings.push(`Will delete ${count} ${table} record${count !== 1 ? "s" : ""}`);
-        }
-      }
-      if (totalRecords > 1e5) {
-        warnings.push(
-          `Large dataset detected (${totalRecords} total records). Consider using useTransaction: false for better performance.`
-        );
-      }
-      if (dryRun) {
-        this.config.logger?.info(`Dry-run complete: ${totalRecords} total records would be deleted`);
-        return {
-          deletedAccountId: accountId,
-          deletedRecordCounts: counts,
-          warnings
-        };
-      }
-      const deletionCounts = await this.postgresClient.deleteAccountWithCascade(
-        accountId,
-        useTransaction
-      );
-      this.config.logger?.info(
-        `Successfully deleted account ${accountId} with ${totalRecords} total records`
-      );
-      return {
-        deletedAccountId: accountId,
-        deletedRecordCounts: deletionCounts,
-        warnings
-      };
-    } catch (error) {
-      this.config.logger?.error(error, `Failed to delete account ${accountId}`);
-      const errorMessage = error instanceof Error ? error.message : "Unknown error";
-      throw new Error(`Failed to delete account ${accountId}: ${errorMessage}`);
-    }
-  }
-  async processWebhook(payload, signature) {
-    let webhookSecret = this.config.stripeWebhookSecret;
-    if (!webhookSecret) {
-      const accountId = await this.getAccountId();
-      const result = await this.postgresClient.query(
-        `SELECT secret FROM "stripe"."_managed_webhooks" WHERE account_id = $1 LIMIT 1`,
-        [accountId]
-      );
-      if (result.rows.length > 0) {
-        webhookSecret = result.rows[0].secret;
-      }
-    }
-    if (!webhookSecret) {
-      throw new Error(
-        "No webhook secret provided. Either create a managed webhook or configure stripeWebhookSecret."
-      );
-    }
-    const event = await this.stripe.webhooks.constructEventAsync(payload, signature, webhookSecret);
-    return this.processEvent(event);
-  }
-  // Event handler registry - maps event types to handler functions
-  // Note: Uses 'any' for event parameter to allow handlers with specific Stripe event types
-  // (e.g., CustomerDeletedEvent, ProductDeletedEvent) which TypeScript won't accept
-  // as contravariant parameters when using the base Stripe.Event type
-  eventHandlers = {
-    "charge.captured": this.handleChargeEvent.bind(this),
-    "charge.expired": this.handleChargeEvent.bind(this),
-    "charge.failed": this.handleChargeEvent.bind(this),
-    "charge.pending": this.handleChargeEvent.bind(this),
-    "charge.refunded": this.handleChargeEvent.bind(this),
-    "charge.succeeded": this.handleChargeEvent.bind(this),
-    "charge.updated": this.handleChargeEvent.bind(this),
-    "customer.deleted": this.handleCustomerDeletedEvent.bind(this),
-    "customer.created": this.handleCustomerEvent.bind(this),
-    "customer.updated": this.handleCustomerEvent.bind(this),
-    "checkout.session.async_payment_failed": this.handleCheckoutSessionEvent.bind(this),
-    "checkout.session.async_payment_succeeded": this.handleCheckoutSessionEvent.bind(this),
-    "checkout.session.completed": this.handleCheckoutSessionEvent.bind(this),
-    "checkout.session.expired": this.handleCheckoutSessionEvent.bind(this),
-    "customer.subscription.created": this.handleSubscriptionEvent.bind(this),
-    "customer.subscription.deleted": this.handleSubscriptionEvent.bind(this),
-    "customer.subscription.paused": this.handleSubscriptionEvent.bind(this),
-    "customer.subscription.pending_update_applied": this.handleSubscriptionEvent.bind(this),
-    "customer.subscription.pending_update_expired": this.handleSubscriptionEvent.bind(this),
-    "customer.subscription.trial_will_end": this.handleSubscriptionEvent.bind(this),
-    "customer.subscription.resumed": this.handleSubscriptionEvent.bind(this),
-    "customer.subscription.updated": this.handleSubscriptionEvent.bind(this),
-    "customer.tax_id.updated": this.handleTaxIdEvent.bind(this),
-    "customer.tax_id.created": this.handleTaxIdEvent.bind(this),
-    "customer.tax_id.deleted": this.handleTaxIdDeletedEvent.bind(this),
-    "invoice.created": this.handleInvoiceEvent.bind(this),
-    "invoice.deleted": this.handleInvoiceEvent.bind(this),
-    "invoice.finalized": this.handleInvoiceEvent.bind(this),
-    "invoice.finalization_failed": this.handleInvoiceEvent.bind(this),
-    "invoice.paid": this.handleInvoiceEvent.bind(this),
-    "invoice.payment_action_required": this.handleInvoiceEvent.bind(this),
-    "invoice.payment_failed": this.handleInvoiceEvent.bind(this),
-    "invoice.payment_succeeded": this.handleInvoiceEvent.bind(this),
-    "invoice.upcoming": this.handleInvoiceEvent.bind(this),
-    "invoice.sent": this.handleInvoiceEvent.bind(this),
-    "invoice.voided": this.handleInvoiceEvent.bind(this),
-    "invoice.marked_uncollectible": this.handleInvoiceEvent.bind(this),
-    "invoice.updated": this.handleInvoiceEvent.bind(this),
-    "product.created": this.handleProductEvent.bind(this),
-    "product.updated": this.handleProductEvent.bind(this),
-    "product.deleted": this.handleProductDeletedEvent.bind(this),
-    "price.created": this.handlePriceEvent.bind(this),
-    "price.updated": this.handlePriceEvent.bind(this),
-    "price.deleted": this.handlePriceDeletedEvent.bind(this),
-    "plan.created": this.handlePlanEvent.bind(this),
-    "plan.updated": this.handlePlanEvent.bind(this),
-    "plan.deleted": this.handlePlanDeletedEvent.bind(this),
-    "setup_intent.canceled": this.handleSetupIntentEvent.bind(this),
-    "setup_intent.created": this.handleSetupIntentEvent.bind(this),
-    "setup_intent.requires_action": this.handleSetupIntentEvent.bind(this),
-    "setup_intent.setup_failed": this.handleSetupIntentEvent.bind(this),
-    "setup_intent.succeeded": this.handleSetupIntentEvent.bind(this),
-    "subscription_schedule.aborted": this.handleSubscriptionScheduleEvent.bind(this),
-    "subscription_schedule.canceled": this.handleSubscriptionScheduleEvent.bind(this),
-    "subscription_schedule.completed": this.handleSubscriptionScheduleEvent.bind(this),
-    "subscription_schedule.created": this.handleSubscriptionScheduleEvent.bind(this),
-    "subscription_schedule.expiring": this.handleSubscriptionScheduleEvent.bind(this),
-    "subscription_schedule.released": this.handleSubscriptionScheduleEvent.bind(this),
-    "subscription_schedule.updated": this.handleSubscriptionScheduleEvent.bind(this),
-    "payment_method.attached": this.handlePaymentMethodEvent.bind(this),
-    "payment_method.automatically_updated": this.handlePaymentMethodEvent.bind(this),
-    "payment_method.detached": this.handlePaymentMethodEvent.bind(this),
-    "payment_method.updated": this.handlePaymentMethodEvent.bind(this),
-    "charge.dispute.created": this.handleDisputeEvent.bind(this),
-    "charge.dispute.funds_reinstated": this.handleDisputeEvent.bind(this),
-    "charge.dispute.funds_withdrawn": this.handleDisputeEvent.bind(this),
-    "charge.dispute.updated": this.handleDisputeEvent.bind(this),
-    "charge.dispute.closed": this.handleDisputeEvent.bind(this),
-    "payment_intent.amount_capturable_updated": this.handlePaymentIntentEvent.bind(this),
-    "payment_intent.canceled": this.handlePaymentIntentEvent.bind(this),
-    "payment_intent.created": this.handlePaymentIntentEvent.bind(this),
-    "payment_intent.partially_funded": this.handlePaymentIntentEvent.bind(this),
-    "payment_intent.payment_failed": this.handlePaymentIntentEvent.bind(this),
-    "payment_intent.processing": this.handlePaymentIntentEvent.bind(this),
-    "payment_intent.requires_action": this.handlePaymentIntentEvent.bind(this),
-    "payment_intent.succeeded": this.handlePaymentIntentEvent.bind(this),
-    "credit_note.created": this.handleCreditNoteEvent.bind(this),
-    "credit_note.updated": this.handleCreditNoteEvent.bind(this),
-    "credit_note.voided": this.handleCreditNoteEvent.bind(this),
-    "radar.early_fraud_warning.created": this.handleEarlyFraudWarningEvent.bind(this),
-    "radar.early_fraud_warning.updated": this.handleEarlyFraudWarningEvent.bind(this),
-    "refund.created": this.handleRefundEvent.bind(this),
-    "refund.failed": this.handleRefundEvent.bind(this),
-    "refund.updated": this.handleRefundEvent.bind(this),
-    "charge.refund.updated": this.handleRefundEvent.bind(this),
-    "review.closed": this.handleReviewEvent.bind(this),
-    "review.opened": this.handleReviewEvent.bind(this),
-    "entitlements.active_entitlement_summary.updated": this.handleEntitlementSummaryEvent.bind(this)
-  };
-  // Resource registry - maps SyncObject → list/upsert operations for processNext()
-  // Complements eventHandlers which maps event types → handlers for webhooks
-  // Both registries share the same underlying upsert methods
-  // Order field determines backfill sequence - parents before children for FK dependencies
-  resourceRegistry = {
-    product: {
-      order: 1,
-      // No dependencies
-      listFn: (p) => this.stripe.products.list(p),
-      upsertFn: (items, id) => this.upsertProducts(items, id),
-      supportsCreatedFilter: true
-    },
-    price: {
-      order: 2,
-      // Depends on product
-      listFn: (p) => this.stripe.prices.list(p),
-      upsertFn: (items, id, bf) => this.upsertPrices(items, id, bf),
-      supportsCreatedFilter: true
-    },
-    plan: {
-      order: 3,
-      // Depends on product
-      listFn: (p) => this.stripe.plans.list(p),
-      upsertFn: (items, id, bf) => this.upsertPlans(items, id, bf),
-      supportsCreatedFilter: true
-    },
-    customer: {
-      order: 4,
-      // No dependencies
-      listFn: (p) => this.stripe.customers.list(p),
-      upsertFn: (items, id) => this.upsertCustomers(items, id),
-      supportsCreatedFilter: true
-    },
-    subscription: {
-      order: 5,
-      // Depends on customer, price
-      listFn: (p) => this.stripe.subscriptions.list(p),
-      upsertFn: (items, id, bf) => this.upsertSubscriptions(items, id, bf),
-      supportsCreatedFilter: true
-    },
-    subscription_schedules: {
-      order: 6,
-      // Depends on customer
-      listFn: (p) => this.stripe.subscriptionSchedules.list(p),
-      upsertFn: (items, id, bf) => this.upsertSubscriptionSchedules(items, id, bf),
-      supportsCreatedFilter: true
-    },
-    invoice: {
-      order: 7,
-      // Depends on customer, subscription
-      listFn: (p) => this.stripe.invoices.list(p),
-      upsertFn: (items, id, bf) => this.upsertInvoices(items, id, bf),
-      supportsCreatedFilter: true
-    },
-    charge: {
-      order: 8,
-      // Depends on customer, invoice
-      listFn: (p) => this.stripe.charges.list(p),
-      upsertFn: (items, id, bf) => this.upsertCharges(items, id, bf),
-      supportsCreatedFilter: true
-    },
-    setup_intent: {
-      order: 9,
-      // Depends on customer
-      listFn: (p) => this.stripe.setupIntents.list(p),
-      upsertFn: (items, id, bf) => this.upsertSetupIntents(items, id, bf),
-      supportsCreatedFilter: true
-    },
-    payment_method: {
-      order: 10,
-      // Depends on customer (special: iterates customers)
-      listFn: (p) => this.stripe.paymentMethods.list(p),
-      upsertFn: (items, id, bf) => this.upsertPaymentMethods(items, id, bf),
-      supportsCreatedFilter: false
-      // Requires customer param, can't filter by created
-    },
-    payment_intent: {
-      order: 11,
-      // Depends on customer
-      listFn: (p) => this.stripe.paymentIntents.list(p),
-      upsertFn: (items, id, bf) => this.upsertPaymentIntents(items, id, bf),
-      supportsCreatedFilter: true
-    },
-    tax_id: {
-      order: 12,
-      // Depends on customer
-      listFn: (p) => this.stripe.taxIds.list(p),
-      upsertFn: (items, id, bf) => this.upsertTaxIds(items, id, bf),
-      supportsCreatedFilter: false
-      // taxIds don't support created filter
-    },
-    credit_note: {
-      order: 13,
-      // Depends on invoice
-      listFn: (p) => this.stripe.creditNotes.list(p),
-      upsertFn: (items, id, bf) => this.upsertCreditNotes(items, id, bf),
-      supportsCreatedFilter: true
-      // credit_notes support created filter
-    },
-    dispute: {
-      order: 14,
-      // Depends on charge
-      listFn: (p) => this.stripe.disputes.list(p),
-      upsertFn: (items, id, bf) => this.upsertDisputes(items, id, bf),
-      supportsCreatedFilter: true
-    },
-    early_fraud_warning: {
-      order: 15,
-      // Depends on charge
-      listFn: (p) => this.stripe.radar.earlyFraudWarnings.list(p),
-      upsertFn: (items, id) => this.upsertEarlyFraudWarning(items, id),
-      supportsCreatedFilter: true
-    },
-    refund: {
-      order: 16,
-      // Depends on charge
-      listFn: (p) => this.stripe.refunds.list(p),
-      upsertFn: (items, id, bf) => this.upsertRefunds(items, id, bf),
-      supportsCreatedFilter: true
-    },
-    checkout_sessions: {
-      order: 17,
-      // Depends on customer (optional)
-      listFn: (p) => this.stripe.checkout.sessions.list(p),
-      upsertFn: (items, id) => this.upsertCheckoutSessions(items, id),
-      supportsCreatedFilter: true
-    }
-  };
-  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() {
-    return Object.entries(this.resourceRegistry).sort(([, a], [, b]) => a.order - b.order).map(([key]) => key);
-  }
-  // Event handler methods
-  async handleChargeEvent(event, accountId) {
-    const { entity: charge, refetched } = await this.fetchOrUseWebhookData(
-      event.data.object,
-      (id) => this.stripe.charges.retrieve(id),
-      (charge2) => charge2.status === "failed" || charge2.status === "succeeded"
-    );
-    await this.upsertCharges([charge], accountId, false, this.getSyncTimestamp(event, refetched));
-  }
-  async handleCustomerDeletedEvent(event, accountId) {
-    const customer = {
-      id: event.data.object.id,
-      object: "customer",
-      deleted: true
-    };
-    await this.upsertCustomers([customer], accountId, this.getSyncTimestamp(event, false));
-  }
-  async handleCustomerEvent(event, accountId) {
-    const { entity: customer, refetched } = await this.fetchOrUseWebhookData(
-      event.data.object,
-      (id) => this.stripe.customers.retrieve(id),
-      (customer2) => customer2.deleted === true
-    );
-    await this.upsertCustomers([customer], accountId, this.getSyncTimestamp(event, refetched));
-  }
-  async handleCheckoutSessionEvent(event, accountId) {
-    const { entity: checkoutSession, refetched } = await this.fetchOrUseWebhookData(
-      event.data.object,
-      (id) => this.stripe.checkout.sessions.retrieve(id)
-    );
-    await this.upsertCheckoutSessions(
-      [checkoutSession],
-      accountId,
-      false,
-      this.getSyncTimestamp(event, refetched)
-    );
-  }
-  async handleSubscriptionEvent(event, accountId) {
-    const { entity: subscription, refetched } = await this.fetchOrUseWebhookData(
-      event.data.object,
-      (id) => this.stripe.subscriptions.retrieve(id),
-      (subscription2) => subscription2.status === "canceled" || subscription2.status === "incomplete_expired"
-    );
-    await this.upsertSubscriptions(
-      [subscription],
-      accountId,
-      false,
-      this.getSyncTimestamp(event, refetched)
-    );
-  }
-  async handleTaxIdEvent(event, accountId) {
-    const { entity: taxId, refetched } = await this.fetchOrUseWebhookData(
-      event.data.object,
-      (id) => this.stripe.taxIds.retrieve(id)
-    );
-    await this.upsertTaxIds([taxId], accountId, false, this.getSyncTimestamp(event, refetched));
-  }
-  async handleTaxIdDeletedEvent(event, _accountId) {
-    const taxId = event.data.object;
-    await this.deleteTaxId(taxId.id);
-  }
-  async handleInvoiceEvent(event, accountId) {
-    const { entity: invoice, refetched } = await this.fetchOrUseWebhookData(
-      event.data.object,
-      (id) => this.stripe.invoices.retrieve(id),
-      (invoice2) => invoice2.status === "void"
-    );
-    await this.upsertInvoices([invoice], accountId, false, this.getSyncTimestamp(event, refetched));
-  }
-  async handleProductEvent(event, accountId) {
-    try {
-      const { entity: product, refetched } = await this.fetchOrUseWebhookData(
-        event.data.object,
-        (id) => this.stripe.products.retrieve(id)
-      );
-      await this.upsertProducts([product], accountId, this.getSyncTimestamp(event, refetched));
-    } catch (err) {
-      if (err instanceof Stripe2.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 Stripe2.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 Stripe2.errors.StripeAPIError && err.code === "resource_missing") {
-        const plan = event.data.object;
-        await this.deletePlan(plan.id);
-      } else {
-        throw err;
-      }
-    }
-  }
-  async handlePlanDeletedEvent(event, _accountId) {
-    const plan = event.data.object;
-    await this.deletePlan(plan.id);
-  }
-  async handleSetupIntentEvent(event, accountId) {
-    const { entity: setupIntent, refetched } = await this.fetchOrUseWebhookData(
-      event.data.object,
-      (id) => this.stripe.setupIntents.retrieve(id),
-      (setupIntent2) => setupIntent2.status === "canceled" || setupIntent2.status === "succeeded"
-    );
-    await this.upsertSetupIntents(
-      [setupIntent],
-      accountId,
-      false,
-      this.getSyncTimestamp(event, refetched)
-    );
-  }
-  async handleSubscriptionScheduleEvent(event, accountId) {
-    const { entity: subscriptionSchedule, refetched } = await this.fetchOrUseWebhookData(
-      event.data.object,
-      (id) => this.stripe.subscriptionSchedules.retrieve(id),
-      (schedule) => schedule.status === "canceled" || schedule.status === "completed"
-    );
-    await this.upsertSubscriptionSchedules(
-      [subscriptionSchedule],
-      accountId,
-      false,
-      this.getSyncTimestamp(event, refetched)
-    );
-  }
-  async handlePaymentMethodEvent(event, accountId) {
-    const { entity: paymentMethod, refetched } = await this.fetchOrUseWebhookData(
-      event.data.object,
-      (id) => this.stripe.paymentMethods.retrieve(id)
-    );
-    await this.upsertPaymentMethods(
-      [paymentMethod],
-      accountId,
-      false,
-      this.getSyncTimestamp(event, refetched)
-    );
-  }
-  async handleDisputeEvent(event, accountId) {
-    const { entity: dispute, refetched } = await this.fetchOrUseWebhookData(
-      event.data.object,
-      (id) => this.stripe.disputes.retrieve(id),
-      (dispute2) => dispute2.status === "won" || dispute2.status === "lost"
-    );
-    await this.upsertDisputes([dispute], accountId, false, this.getSyncTimestamp(event, refetched));
-  }
-  async handlePaymentIntentEvent(event, accountId) {
-    const { entity: paymentIntent, refetched } = await this.fetchOrUseWebhookData(
-      event.data.object,
-      (id) => this.stripe.paymentIntents.retrieve(id),
-      // Final states - do not re-fetch from API
-      (entity) => entity.status === "canceled" || entity.status === "succeeded"
-    );
-    await this.upsertPaymentIntents(
-      [paymentIntent],
-      accountId,
-      false,
-      this.getSyncTimestamp(event, refetched)
-    );
-  }
-  async handleCreditNoteEvent(event, accountId) {
-    const { entity: creditNote, refetched } = await this.fetchOrUseWebhookData(
-      event.data.object,
-      (id) => this.stripe.creditNotes.retrieve(id),
-      (creditNote2) => creditNote2.status === "void"
-    );
-    await this.upsertCreditNotes(
-      [creditNote],
-      accountId,
-      false,
-      this.getSyncTimestamp(event, refetched)
-    );
-  }
-  async handleEarlyFraudWarningEvent(event, accountId) {
-    const { entity: earlyFraudWarning, refetched } = await this.fetchOrUseWebhookData(
-      event.data.object,
-      (id) => this.stripe.radar.earlyFraudWarnings.retrieve(id)
-    );
-    await this.upsertEarlyFraudWarning(
-      [earlyFraudWarning],
-      accountId,
-      false,
-      this.getSyncTimestamp(event, refetched)
-    );
-  }
-  async handleRefundEvent(event, accountId) {
-    const { entity: refund, refetched } = await this.fetchOrUseWebhookData(
-      event.data.object,
-      (id) => this.stripe.refunds.retrieve(id)
-    );
-    await this.upsertRefunds([refund], accountId, false, this.getSyncTimestamp(event, refetched));
-  }
-  async handleReviewEvent(event, accountId) {
-    const { entity: review, refetched } = await this.fetchOrUseWebhookData(
-      event.data.object,
-      (id) => this.stripe.reviews.retrieve(id)
-    );
-    await this.upsertReviews([review], accountId, false, this.getSyncTimestamp(event, refetched));
-  }
-  async handleEntitlementSummaryEvent(event, accountId) {
-    const activeEntitlementSummary = event.data.object;
-    let entitlements = activeEntitlementSummary.entitlements;
-    let refetched = false;
-    if (this.config.revalidateObjectsViaStripeApi?.includes("entitlements")) {
-      const { lastResponse, ...rest } = await this.stripe.entitlements.activeEntitlements.list({
-        customer: activeEntitlementSummary.customer
-      });
-      entitlements = rest;
-      refetched = true;
-    }
-    await this.deleteRemovedActiveEntitlements(
-      activeEntitlementSummary.customer,
-      entitlements.data.map((entitlement) => entitlement.id)
-    );
-    await this.upsertActiveEntitlements(
-      activeEntitlementSummary.customer,
-      entitlements.data,
-      accountId,
-      false,
-      this.getSyncTimestamp(event, refetched)
-    );
-  }
-  getSyncTimestamp(event, refetched) {
-    return refetched ? (/* @__PURE__ */ new Date()).toISOString() : new Date(event.created * 1e3).toISOString();
-  }
-  shouldRefetchEntity(entity) {
-    return this.config.revalidateObjectsViaStripeApi?.includes(entity.object);
-  }
-  async fetchOrUseWebhookData(entity, fetchFn, entityInFinalState) {
-    if (!entity.id) return { entity, refetched: false };
-    if (entityInFinalState && entityInFinalState(entity)) return { entity, refetched: false };
-    if (this.shouldRefetchEntity(entity)) {
-      const fetchedEntity = await fetchFn(entity.id);
-      return { entity: fetchedEntity, refetched: true };
-    }
-    return { entity, refetched: false };
-  }
-  async syncSingleEntity(stripeId) {
-    const accountId = await this.getAccountId();
-    if (stripeId.startsWith("cus_")) {
-      return this.stripe.customers.retrieve(stripeId).then((it) => {
-        if (!it || it.deleted) return;
-        return this.upsertCustomers([it], accountId);
-      });
-    } else if (stripeId.startsWith("in_")) {
-      return this.stripe.invoices.retrieve(stripeId).then((it) => this.upsertInvoices([it], accountId));
-    } else if (stripeId.startsWith("price_")) {
-      return this.stripe.prices.retrieve(stripeId).then((it) => this.upsertPrices([it], accountId));
-    } else if (stripeId.startsWith("prod_")) {
-      return this.stripe.products.retrieve(stripeId).then((it) => this.upsertProducts([it], accountId));
-    } else if (stripeId.startsWith("sub_")) {
-      return this.stripe.subscriptions.retrieve(stripeId).then((it) => this.upsertSubscriptions([it], accountId));
-    } else if (stripeId.startsWith("seti_")) {
-      return this.stripe.setupIntents.retrieve(stripeId).then((it) => this.upsertSetupIntents([it], accountId));
-    } else if (stripeId.startsWith("pm_")) {
-      return this.stripe.paymentMethods.retrieve(stripeId).then((it) => this.upsertPaymentMethods([it], accountId));
-    } else if (stripeId.startsWith("dp_") || stripeId.startsWith("du_")) {
-      return this.stripe.disputes.retrieve(stripeId).then((it) => this.upsertDisputes([it], accountId));
-    } else if (stripeId.startsWith("ch_")) {
-      return this.stripe.charges.retrieve(stripeId).then((it) => this.upsertCharges([it], accountId, true));
-    } else if (stripeId.startsWith("pi_")) {
-      return this.stripe.paymentIntents.retrieve(stripeId).then((it) => this.upsertPaymentIntents([it], accountId));
-    } else if (stripeId.startsWith("txi_")) {
-      return this.stripe.taxIds.retrieve(stripeId).then((it) => this.upsertTaxIds([it], accountId));
-    } else if (stripeId.startsWith("cn_")) {
-      return this.stripe.creditNotes.retrieve(stripeId).then((it) => this.upsertCreditNotes([it], accountId));
-    } else if (stripeId.startsWith("issfr_")) {
-      return this.stripe.radar.earlyFraudWarnings.retrieve(stripeId).then((it) => this.upsertEarlyFraudWarning([it], accountId));
-    } else if (stripeId.startsWith("prv_")) {
-      return this.stripe.reviews.retrieve(stripeId).then((it) => this.upsertReviews([it], accountId));
-    } else if (stripeId.startsWith("re_")) {
-      return this.stripe.refunds.retrieve(stripeId).then((it) => this.upsertRefunds([it], accountId));
-    } else if (stripeId.startsWith("feat_")) {
-      return this.stripe.entitlements.features.retrieve(stripeId).then((it) => this.upsertFeatures([it], accountId));
-    } else if (stripeId.startsWith("cs_")) {
-      return this.stripe.checkout.sessions.retrieve(stripeId).then((it) => this.upsertCheckoutSessions([it], accountId));
-    }
-  }
-  /**
-   * Process one page of items for the specified object type.
-   * Returns the number of items processed and whether there are more pages.
-   *
-   * This method is designed for queue-based consumption where each page
-   * is processed as a separate job. Uses the observable sync system for tracking.
-   *
-   * @param object - The Stripe object type to sync (e.g., 'customer', 'product')
-   * @param params - Optional parameters for filtering and run context
-   * @returns ProcessNextResult with processed count, hasMore flag, and runStartedAt
-   *
-   * @example
-   * ```typescript
-   * // Queue worker
-   * const { hasMore, runStartedAt } = await stripeSync.processNext('customer')
-   * if (hasMore) {
-   *   await queue.send({ object: 'customer', runStartedAt })
-   * }
-   * ```
-   */
-  async processNext(object, params) {
-    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.postgresClient.getOrCreateSyncRun(
-        accountId,
-        params?.triggeredBy ?? "processNext"
-      );
-      if (!runKey) {
-        const activeRun = await this.postgresClient.getActiveSyncRun(accountId);
-        if (!activeRun) {
-          throw new Error("Failed to get or create sync run");
-        }
-        runStartedAt = activeRun.runStartedAt;
-      } else {
-        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) {
-      if (objRun?.cursor) {
-        cursor = parseInt(objRun.cursor);
-      } else {
-        const lastCursor = await this.postgresClient.getLastCompletedCursor(accountId, resourceName);
-        cursor = lastCursor ? parseInt(lastCursor) : null;
-      }
-    }
-    const result = await this.fetchOnePage(
-      object,
-      accountId,
-      resourceName,
-      runStartedAt,
-      cursor,
-      params
-    );
-    return result;
-  }
-  /**
-   * Get the database resource name for a SyncObject type
-   */
-  getResourceName(object) {
-    const mapping = {
-      customer: "customers",
-      invoice: "invoices",
-      price: "prices",
-      product: "products",
-      subscription: "subscriptions",
-      subscription_schedules: "subscription_schedules",
-      setup_intent: "setup_intents",
-      payment_method: "payment_methods",
-      dispute: "disputes",
-      charge: "charges",
-      payment_intent: "payment_intents",
-      plan: "plans",
-      tax_id: "tax_ids",
-      credit_note: "credit_notes",
-      early_fraud_warning: "early_fraud_warnings",
-      refund: "refunds",
-      checkout_sessions: "checkout_sessions"
-    };
-    return mapping[object] || object;
-  }
-  /**
-   * Fetch one page of items from Stripe and upsert to database.
-   * Uses resourceRegistry for DRY list/upsert operations.
-   * Uses the observable sync system for tracking progress.
-   */
-  async fetchOnePage(object, accountId, resourceName, runStartedAt, cursor, 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 {
-      const listParams = { limit };
-      if (config.supportsCreatedFilter) {
-        const created = params?.created ?? (cursor ? { gte: cursor } : void 0);
-        if (created) {
-          listParams.created = created;
-        }
-      }
-      const response = await config.listFn(listParams);
-      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)
-          );
-        }
-      }
-      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;
-    }
-  }
-  /**
-   * 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 };
-  }
-  async processUntilDone(params) {
-    const { object } = params ?? { object: "all" };
-    await this.getCurrentAccount();
-    const accountId = await this.getAccountId();
-    const runKey = await this.postgresClient.getOrCreateSyncRun(accountId, "processUntilDone");
-    if (!runKey) {
-      const activeRun = await this.postgresClient.getActiveSyncRun(accountId);
-      if (!activeRun) {
-        throw new Error("Failed to get or create sync run");
-      }
-      return this.processUntilDoneWithRun(activeRun.runStartedAt, object, params);
-    }
-    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;
-          }
-        }
-      }
-      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;
-      for (const customerIdChunk of chunkArray(customerIds, 10)) {
-        await Promise.all(
-          customerIdChunk.map(async (customerId) => {
-            const CHECKPOINT_SIZE = 100;
-            let currentBatch = [];
-            for await (const item of this.stripe.paymentMethods.list({
-              limit: 100,
-              customer: customerId
-            })) {
-              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 = [];
-              }
-            }
-            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(
-        () => this.stripe.products.list(params),
-        (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(
-        () => this.stripe.prices.list(params),
-        (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(
-        () => this.stripe.plans.list(params),
-        (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(
-        () => this.stripe.customers.list(params),
-        // @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(
-        () => this.stripe.subscriptions.list(params),
-        (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(
-          () => this.stripe.subscriptionSchedules.list(params),
-          (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(
-        () => this.stripe.invoices.list(params),
-        (items) => this.upsertInvoices(items, accountId, syncParams?.backfillRelatedEntities),
-        accountId,
-        "invoices",
-        runStartedAt
-      );
-    });
-  }
-  async syncCharges(syncParams) {
-    this.config.logger?.info("Syncing charges");
-    return this.withSyncRun("charges", "syncCharges", async (cursor, runStartedAt) => {
-      const accountId = await this.getAccountId();
-      const params = { limit: 100 };
-      if (syncParams?.created) {
-        params.created = syncParams.created;
-      } else if (cursor) {
-        params.created = { gte: cursor };
-        this.config.logger?.info(`Incremental sync from cursor: ${cursor}`);
-      }
-      return this.fetchAndUpsert(
-        () => this.stripe.charges.list(params),
-        (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(
-        () => this.stripe.setupIntents.list(params),
-        (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(
-          () => this.stripe.paymentIntents.list(params),
-          (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(
-        () => this.stripe.taxIds.list(params),
-        (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;
-        for (const customerIdChunk of chunkArray(customerIds, 10)) {
-          await Promise.all(
-            customerIdChunk.map(async (customerId) => {
-              const CHECKPOINT_SIZE = 100;
-              let currentBatch = [];
-              for await (const item of this.stripe.paymentMethods.list({
-                limit: 100,
-                customer: customerId
-              })) {
-                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 = [];
-                }
-              }
-              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(
-        () => this.stripe.disputes.list(params),
-        (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(
-          () => this.stripe.radar.earlyFraudWarnings.list(params),
-          (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(
-        () => this.stripe.refunds.list(params),
-        (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(
-        () => this.stripe.creditNotes.list(params),
-        (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(
-          () => this.stripe.checkout.sessions.list(params),
-          (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(fetch, 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 {
-        for await (const item of fetch()) {
-          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 = [];
-          }
-        }
-        if (currentBatch.length > 0) {
-          this.config.logger?.info(`Upserting final batch of ${currentBatch.length} items`);
-          await upsert(currentBatch, accountId);
-          totalSynced += currentBatch.length;
-          await this.postgresClient.incrementObjectProgress(
-            accountId,
-            runStartedAt,
-            resourceName,
-            currentBatch.length
-          );
-          const maxCreated = Math.max(
-            ...currentBatch.map((i) => i.created || 0)
-          );
-          if (maxCreated > 0) {
-            await this.postgresClient.updateObjectCursor(
-              accountId,
-              runStartedAt,
-              resourceName,
-              String(maxCreated)
-            );
-          }
-        }
-      } catch (error) {
-        if (currentBatch.length > 0) {
-          this.config.logger?.info(
-            `Error occurred, saving partial progress: ${currentBatch.length} items`
-          );
-          await upsert(currentBatch, accountId);
-          totalSynced += currentBatch.length;
-          await this.postgresClient.incrementObjectProgress(
-            accountId,
-            runStartedAt,
-            resourceName,
-            currentBatch.length
-          );
-          const maxCreated = Math.max(
-            ...currentBatch.map((i) => i.created || 0)
-          );
-          if (maxCreated > 0) {
-            await this.postgresClient.updateObjectCursor(
-              accountId,
-              runStartedAt,
-              resourceName,
-              String(maxCreated)
-            );
-          }
-        }
-        throw error;
-      }
-      await this.postgresClient.completeObjectSync(accountId, runStartedAt, resourceName);
-      this.config.logger?.info(`Sync complete: ${totalSynced} items synced`);
-      return { synced: totalSynced };
-    } catch (error) {
-      await this.postgresClient.failObjectSync(
-        accountId,
-        runStartedAt,
-        resourceName,
-        error instanceof Error ? error.message : "Unknown error"
-      );
-      throw error;
-    }
-  }
-  async upsertCharges(charges, accountId, backfillRelatedEntities, syncTimestamp) {
-    if (backfillRelatedEntities ?? this.config.backfillRelatedEntities) {
-      await Promise.all([
-        this.backfillCustomers(getUniqueIds(charges, "customer"), accountId),
-        this.backfillInvoices(getUniqueIds(charges, "invoice"), accountId)
-      ]);
-    }
-    await this.expandEntity(
-      charges,
-      "refunds",
-      (id) => this.stripe.refunds.list({ charge: id, limit: 100 })
-    );
-    return this.postgresClient.upsertManyWithTimestampProtection(
-      charges,
-      "charges",
-      accountId,
-      syncTimestamp
-    );
-  }
-  async backfillCharges(chargeIds, accountId) {
-    const missingChargeIds = await this.postgresClient.findMissingEntries("charges", chargeIds);
-    await this.fetchMissingEntities(
-      missingChargeIds,
-      (id) => this.stripe.charges.retrieve(id)
-    ).then((charges) => this.upsertCharges(charges, accountId));
-  }
-  async backfillPaymentIntents(paymentIntentIds, accountId) {
-    const missingIds = await this.postgresClient.findMissingEntries(
-      "payment_intents",
-      paymentIntentIds
-    );
-    await this.fetchMissingEntities(
-      missingIds,
-      (id) => this.stripe.paymentIntents.retrieve(id)
-    ).then((paymentIntents) => this.upsertPaymentIntents(paymentIntents, accountId));
-  }
-  async upsertCreditNotes(creditNotes, accountId, backfillRelatedEntities, syncTimestamp) {
-    if (backfillRelatedEntities ?? this.config.backfillRelatedEntities) {
-      await Promise.all([
-        this.backfillCustomers(getUniqueIds(creditNotes, "customer"), accountId),
-        this.backfillInvoices(getUniqueIds(creditNotes, "invoice"), accountId)
-      ]);
-    }
-    await this.expandEntity(
-      creditNotes,
-      "lines",
-      (id) => this.stripe.creditNotes.listLineItems(id, { limit: 100 })
-    );
-    return this.postgresClient.upsertManyWithTimestampProtection(
-      creditNotes,
-      "credit_notes",
-      accountId,
-      syncTimestamp
-    );
-  }
-  async upsertCheckoutSessions(checkoutSessions, accountId, backfillRelatedEntities, syncTimestamp) {
-    if (backfillRelatedEntities ?? this.config.backfillRelatedEntities) {
-      await Promise.all([
-        this.backfillCustomers(getUniqueIds(checkoutSessions, "customer"), accountId),
-        this.backfillSubscriptions(getUniqueIds(checkoutSessions, "subscription"), accountId),
-        this.backfillPaymentIntents(getUniqueIds(checkoutSessions, "payment_intent"), accountId),
-        this.backfillInvoices(getUniqueIds(checkoutSessions, "invoice"), accountId)
-      ]);
-    }
-    const rows = await this.postgresClient.upsertManyWithTimestampProtection(
-      checkoutSessions,
-      "checkout_sessions",
-      accountId,
-      syncTimestamp
-    );
-    await this.fillCheckoutSessionsLineItems(
-      checkoutSessions.map((cs) => cs.id),
-      accountId,
-      syncTimestamp
-    );
-    return rows;
-  }
-  async upsertEarlyFraudWarning(earlyFraudWarnings, accountId, backfillRelatedEntities, syncTimestamp) {
-    if (backfillRelatedEntities ?? this.config.backfillRelatedEntities) {
-      await Promise.all([
-        this.backfillPaymentIntents(getUniqueIds(earlyFraudWarnings, "payment_intent"), accountId),
-        this.backfillCharges(getUniqueIds(earlyFraudWarnings, "charge"), accountId)
-      ]);
-    }
-    return this.postgresClient.upsertManyWithTimestampProtection(
-      earlyFraudWarnings,
-      "early_fraud_warnings",
-      accountId,
-      syncTimestamp
-    );
-  }
-  async upsertRefunds(refunds, accountId, backfillRelatedEntities, syncTimestamp) {
-    if (backfillRelatedEntities ?? this.config.backfillRelatedEntities) {
-      await Promise.all([
-        this.backfillPaymentIntents(getUniqueIds(refunds, "payment_intent"), accountId),
-        this.backfillCharges(getUniqueIds(refunds, "charge"), accountId)
-      ]);
-    }
-    return this.postgresClient.upsertManyWithTimestampProtection(
-      refunds,
-      "refunds",
-      accountId,
-      syncTimestamp
-    );
-  }
-  async upsertReviews(reviews, accountId, backfillRelatedEntities, syncTimestamp) {
-    if (backfillRelatedEntities ?? this.config.backfillRelatedEntities) {
-      await Promise.all([
-        this.backfillPaymentIntents(getUniqueIds(reviews, "payment_intent"), accountId),
-        this.backfillCharges(getUniqueIds(reviews, "charge"), accountId)
-      ]);
-    }
-    return this.postgresClient.upsertManyWithTimestampProtection(
-      reviews,
-      "reviews",
-      accountId,
-      syncTimestamp
-    );
-  }
-  async upsertCustomers(customers, accountId, syncTimestamp) {
-    const deletedCustomers = customers.filter((customer) => customer.deleted);
-    const nonDeletedCustomers = customers.filter((customer) => !customer.deleted);
-    await this.postgresClient.upsertManyWithTimestampProtection(
-      nonDeletedCustomers,
-      "customers",
-      accountId,
-      syncTimestamp
-    );
-    await this.postgresClient.upsertManyWithTimestampProtection(
-      deletedCustomers,
-      "customers",
-      accountId,
-      syncTimestamp
-    );
-    return customers;
-  }
-  async backfillCustomers(customerIds, accountId) {
-    const missingIds = await this.postgresClient.findMissingEntries("customers", customerIds);
-    await this.fetchMissingEntities(missingIds, (id) => this.stripe.customers.retrieve(id)).then((entries) => this.upsertCustomers(entries, accountId)).catch((err) => {
-      this.config.logger?.error(err, "Failed to backfill");
-      throw err;
-    });
-  }
-  async upsertDisputes(disputes, accountId, backfillRelatedEntities, syncTimestamp) {
-    if (backfillRelatedEntities ?? this.config.backfillRelatedEntities) {
-      await this.backfillCharges(getUniqueIds(disputes, "charge"), accountId);
-    }
-    return this.postgresClient.upsertManyWithTimestampProtection(
-      disputes,
-      "disputes",
-      accountId,
-      syncTimestamp
-    );
-  }
-  async upsertInvoices(invoices, accountId, backfillRelatedEntities, syncTimestamp) {
-    if (backfillRelatedEntities ?? this.config.backfillRelatedEntities) {
-      await Promise.all([
-        this.backfillCustomers(getUniqueIds(invoices, "customer"), accountId),
-        this.backfillSubscriptions(getUniqueIds(invoices, "subscription"), accountId)
-      ]);
-    }
-    await this.expandEntity(
-      invoices,
-      "lines",
-      (id) => this.stripe.invoices.listLineItems(id, { limit: 100 })
-    );
-    return this.postgresClient.upsertManyWithTimestampProtection(
-      invoices,
-      "invoices",
-      accountId,
-      syncTimestamp
-    );
-  }
-  backfillInvoices = async (invoiceIds, accountId) => {
-    const missingIds = await this.postgresClient.findMissingEntries("invoices", invoiceIds);
-    await this.fetchMissingEntities(missingIds, (id) => this.stripe.invoices.retrieve(id)).then(
-      (entries) => this.upsertInvoices(entries, accountId)
-    );
-  };
-  backfillPrices = async (priceIds, accountId) => {
-    const missingIds = await this.postgresClient.findMissingEntries("prices", priceIds);
-    await this.fetchMissingEntities(missingIds, (id) => this.stripe.prices.retrieve(id)).then(
-      (entries) => this.upsertPrices(entries, accountId)
-    );
-  };
-  async upsertPlans(plans, accountId, backfillRelatedEntities, syncTimestamp) {
-    if (backfillRelatedEntities ?? this.config.backfillRelatedEntities) {
-      await this.backfillProducts(getUniqueIds(plans, "product"), accountId);
-    }
-    return this.postgresClient.upsertManyWithTimestampProtection(
-      plans,
-      "plans",
-      accountId,
-      syncTimestamp
-    );
-  }
-  async deletePlan(id) {
-    return this.postgresClient.delete("plans", id);
-  }
-  async upsertPrices(prices, accountId, backfillRelatedEntities, syncTimestamp) {
-    if (backfillRelatedEntities ?? this.config.backfillRelatedEntities) {
-      await this.backfillProducts(getUniqueIds(prices, "product"), accountId);
-    }
-    return this.postgresClient.upsertManyWithTimestampProtection(
-      prices,
-      "prices",
-      accountId,
-      syncTimestamp
-    );
-  }
-  async deletePrice(id) {
-    return this.postgresClient.delete("prices", id);
-  }
-  async upsertProducts(products, accountId, syncTimestamp) {
-    return this.postgresClient.upsertManyWithTimestampProtection(
-      products,
-      "products",
-      accountId,
-      syncTimestamp
-    );
-  }
-  async deleteProduct(id) {
-    return this.postgresClient.delete("products", id);
-  }
-  async backfillProducts(productIds, accountId) {
-    const missingProductIds = await this.postgresClient.findMissingEntries("products", productIds);
-    await this.fetchMissingEntities(
-      missingProductIds,
-      (id) => this.stripe.products.retrieve(id)
-    ).then((products) => this.upsertProducts(products, accountId));
-  }
-  async upsertPaymentIntents(paymentIntents, accountId, backfillRelatedEntities, syncTimestamp) {
-    if (backfillRelatedEntities ?? this.config.backfillRelatedEntities) {
-      await Promise.all([
-        this.backfillCustomers(getUniqueIds(paymentIntents, "customer"), accountId),
-        this.backfillInvoices(getUniqueIds(paymentIntents, "invoice"), accountId)
-      ]);
-    }
-    return this.postgresClient.upsertManyWithTimestampProtection(
-      paymentIntents,
-      "payment_intents",
-      accountId,
-      syncTimestamp
-    );
-  }
-  async upsertPaymentMethods(paymentMethods, accountId, backfillRelatedEntities = false, syncTimestamp) {
-    if (backfillRelatedEntities ?? this.config.backfillRelatedEntities) {
-      await this.backfillCustomers(getUniqueIds(paymentMethods, "customer"), accountId);
-    }
-    return this.postgresClient.upsertManyWithTimestampProtection(
-      paymentMethods,
-      "payment_methods",
-      accountId,
-      syncTimestamp
-    );
-  }
-  async upsertSetupIntents(setupIntents, accountId, backfillRelatedEntities, syncTimestamp) {
-    if (backfillRelatedEntities ?? this.config.backfillRelatedEntities) {
-      await this.backfillCustomers(getUniqueIds(setupIntents, "customer"), accountId);
-    }
-    return this.postgresClient.upsertManyWithTimestampProtection(
-      setupIntents,
-      "setup_intents",
-      accountId,
-      syncTimestamp
-    );
-  }
-  async upsertTaxIds(taxIds, accountId, backfillRelatedEntities, syncTimestamp) {
-    if (backfillRelatedEntities ?? this.config.backfillRelatedEntities) {
-      await this.backfillCustomers(getUniqueIds(taxIds, "customer"), accountId);
-    }
-    return this.postgresClient.upsertManyWithTimestampProtection(
-      taxIds,
-      "tax_ids",
-      accountId,
-      syncTimestamp
-    );
-  }
-  async deleteTaxId(id) {
-    return this.postgresClient.delete("tax_ids", id);
-  }
-  async upsertSubscriptionItems(subscriptionItems, accountId, syncTimestamp) {
-    const modifiedSubscriptionItems = subscriptionItems.map((subscriptionItem) => {
-      const priceId = subscriptionItem.price.id.toString();
-      const deleted = subscriptionItem.deleted;
-      const quantity = subscriptionItem.quantity;
-      return {
-        ...subscriptionItem,
-        price: priceId,
-        deleted: deleted ?? false,
-        quantity: quantity ?? null
-      };
-    });
-    await this.postgresClient.upsertManyWithTimestampProtection(
-      modifiedSubscriptionItems,
-      "subscription_items",
-      accountId,
-      syncTimestamp
-    );
-  }
-  async fillCheckoutSessionsLineItems(checkoutSessionIds, accountId, syncTimestamp) {
-    for (const checkoutSessionId of checkoutSessionIds) {
-      const lineItemResponses = [];
-      for await (const lineItem of this.stripe.checkout.sessions.listLineItems(checkoutSessionId, {
-        limit: 100
-      })) {
-        lineItemResponses.push(lineItem);
-      }
-      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.
-   */
-  async expandEntity(entities, property, listFn) {
-    if (!this.config.autoExpandLists) return;
-    for (const entity of entities) {
-      if (entity[property]?.has_more) {
-        const allData = [];
-        for await (const fetchedEntity of listFn(entity.id)) {
-          allData.push(fetchedEntity);
-        }
-        entity[property] = {
-          ...entity[property],
-          data: allData,
-          has_more: false
-        };
-      }
-    }
-  }
-  async fetchMissingEntities(ids, fetch) {
-    if (!ids.length) return [];
-    const entities = [];
-    for (const id of ids) {
-      const entity = await fetch(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/index.ts
-var VERSION = package_default.version;
+  PostgresClient,
+  StripeSync,
+  VERSION,
+  hashApiKey,
+  runMigrations
+} from "./chunk-7JWRDXNB.js";
+import "./chunk-YXQZXR7S.js";
 export {
   PostgresClient,
   StripeSync,