stripe-experiment-sync 0.0.5 → 1.0.0

package/dist/index.js

@@ -1,29 +1,161 @@
+// package.json
+var package_default = {
+  name: "stripe-experiment-sync",
+  version: "1.0.0",
+  private: false,
+  description: "Stripe Sync Engine to sync Stripe data to Postgres",
+  type: "module",
+  main: "./dist/index.cjs",
+  exports: {
+    ".": {
+      import: {
+        types: "./dist/index.d.ts",
+        default: "./dist/index.js"
+      },
+      require: {
+        types: "./dist/index.d.cts",
+        default: "./dist/index.cjs"
+      }
+    },
+    "./pg": {
+      import: {
+        types: "./dist/pg.d.ts",
+        default: "./dist/pg.js"
+      },
+      require: {
+        types: "./dist/pg.d.cts",
+        default: "./dist/pg.cjs"
+      }
+    },
+    "./postgres-js": {
+      import: {
+        types: "./dist/postgres-js.d.ts",
+        default: "./dist/postgres-js.js"
+      },
+      require: {
+        types: "./dist/postgres-js.d.cts",
+        default: "./dist/postgres-js.cjs"
+      }
+    }
+  },
+  scripts: {
+    clean: "rimraf dist",
+    prebuild: "npm run clean",
+    build: "tsup src/index.ts src/pg.ts src/postgres-js.ts --format esm,cjs --dts --shims && cp -r src/database/migrations dist/migrations",
+    lint: "eslint src --ext .ts",
+    test: "vitest"
+  },
+  files: [
+    "dist"
+  ],
+  dependencies: {
+    pg: "^8.16.3",
+    "pg-node-migrations": "0.0.8",
+    postgres: "^3.4.7",
+    ws: "^8.18.0",
+    yesql: "^7.0.0"
+  },
+  peerDependencies: {
+    stripe: "> 11"
+  },
+  devDependencies: {
+    "@types/node": "^24.10.1",
+    "@types/pg": "^8.15.5",
+    "@types/ws": "^8.5.13",
+    "@types/yesql": "^4.1.4",
+    "@vitest/ui": "^4.0.9",
+    stripe: "^20.0.0",
+    vitest: "^3.2.4"
+  },
+  repository: {
+    type: "git",
+    url: "https://github.com/tx-stripe/stripe-sync-engine.git"
+  },
+  homepage: "https://github.com/tx-stripe/stripe-sync-engine#readme",
+  bugs: {
+    url: "https://github.com/tx-stripe/stripe-sync-engine/issues"
+  },
+  keywords: [
+    "stripe",
+    "postgres",
+    "sync",
+    "webhooks",
+    "supabase",
+    "billing",
+    "database",
+    "typescript"
+  ],
+  author: "Supabase <https://supabase.com/>"
+};
+
 // src/stripeSync.ts
-import Stripe from "stripe";
+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);
+    this.adapter = config.adapter;
+  }
+  adapter;
+  /**
+   * Get the underlying adapter.
+   * Useful for accessing adapter-specific features.
+   */
+  getAdapter() {
+    return this.adapter;
+  }
+  /**
+   * Close all database connections.
+   */
+  async end() {
+    await this.adapter.end();
   }
-  pool;
   async delete(table, id) {
     const prepared = sql(`
-    delete from "${this.config.schema}"."${table}" 
+    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);
+    return this.adapter.query(text, params);
   }
-  async upsertMany(entries, table, tableSchema) {
+  async upsertMany(entries, table) {
     if (!entries.length) return [];
     const chunkSize = 5;
     const results = [];
@@ -31,18 +163,22 @@ var PostgresClient = class {
       const chunk = entries.slice(i, i + chunkSize);
       const queries = [];
       chunk.forEach((entry) => {
-        const cleansed = this.cleanseArrayField(entry);
-        const upsertSql = this.constructUpsertSql(this.config.schema, table, tableSchema);
-        const prepared = sql(upsertSql, {
-          useNullForMissing: true
-        })(cleansed);
-        queries.push(this.pool.query(prepared.text, prepared.values));
+        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.adapter.query(upsertSql, [rawData]));
       });
       results.push(...await Promise.all(queries));
     }
     return results.flatMap((it) => it.rows);
   }
-  async upsertManyWithTimestampProtection(entries, table, tableSchema, syncTimestamp) {
+  async upsertManyWithTimestampProtection(entries, table, accountId, syncTimestamp) {
     const timestamp = syncTimestamp || (/* @__PURE__ */ new Date()).toISOString();
     if (!entries.length) return [];
     const chunkSize = 5;
@@ -51,22 +187,62 @@ var PostgresClient = class {
       const chunk = entries.slice(i, i + chunkSize);
       const queries = [];
       chunk.forEach((entry) => {
-        const cleansed = this.cleanseArrayField(entry);
-        cleansed.last_synced_at = timestamp;
-        const upsertSql = this.constructUpsertWithTimestampProtectionSql(
-          this.config.schema,
-          table,
-          tableSchema
-        );
-        const prepared = sql(upsertSql, {
-          useNullForMissing: true
-        })(cleansed);
-        queries.push(this.pool.query(prepared.text, prepared.values));
+        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.adapter.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.adapter.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(`
@@ -78,1389 +254,1319 @@ var PostgresClient = class {
     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;
+  }
   /**
-   * Returns an (yesql formatted) upsert function based on the key/vals of an object.
-   * eg,
-   *  insert into customers ("id", "name")
-   *  values (:id, :name)
-   *  on conflict (id)
-   *  do update set (
-   *   "id" = :id,
-   *   "name" = :name
-   *  )
+   * Hash a string to a 32-bit integer for use with PostgreSQL advisory locks.
+   * Uses a simple hash algorithm that produces consistent results.
    */
-  constructUpsertSql(schema, table, tableSchema, options) {
-    const { conflict = "id" } = options || {};
-    const properties = tableSchema.properties;
-    return `
-    insert into "${schema}"."${table}" (
-      ${properties.map((x) => `"${x}"`).join(",")}
-    )
-    values (
-      ${properties.map((x) => `:${x}`).join(",")}
-    )
-    on conflict (
-      ${conflict}
-    )
-    do update set 
-      ${properties.map((x) => `"${x}" = :${x}`).join(",")}
-    ;`;
+  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;
   }
   /**
-   * Returns an (yesql formatted) upsert function with timestamp protection.
+   * 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.
    *
-   * The WHERE clause in ON CONFLICT DO UPDATE only applies to the conflicting row
-   * (the row being updated), not to all rows in the table. PostgreSQL ensures that
-   * the condition is evaluated only for the specific row that conflicts with the INSERT.
+   * @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).
    *
-   * eg:
-   *   INSERT INTO "stripe"."charges" (
-   *     "id", "amount", "created", "last_synced_at"
-   *   )
-   *   VALUES (
-   *     :id, :amount, :created, :last_synced_at
-   *   )
-   *   ON CONFLICT (id) DO UPDATE SET
-   *     "amount" = EXCLUDED."amount",
-   *     "created" = EXCLUDED."created",
-   *     last_synced_at = :last_synced_at
-   *   WHERE "charges"."last_synced_at" IS NULL
-   *      OR "charges"."last_synced_at" < :last_synced_at;
+   * @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
    */
-  constructUpsertWithTimestampProtectionSql = (schema, table, tableSchema) => {
-    const conflict = "id";
-    const properties = tableSchema.properties;
-    return `
-      INSERT INTO "${schema}"."${table}" (
-        ${properties.map((x) => `"${x}"`).join(",")}, "last_synced_at"
-      )
-      VALUES (
-        ${properties.map((x) => `:${x}`).join(",")}, :last_synced_at
-      )
-      ON CONFLICT (${conflict}) DO UPDATE SET
-        ${properties.filter((x) => x !== "last_synced_at").map((x) => `"${x}" = EXCLUDED."${x}"`).join(",")},
-        last_synced_at = :last_synced_at
-      WHERE "${table}"."last_synced_at" IS NULL 
-         OR "${table}"."last_synced_at" < :last_synced_at;`;
-  };
+  async withAdvisoryLock(key, fn) {
+    const lockId = this.hashToInt32(key);
+    return this.adapter.withAdvisoryLock(lockId, fn);
+  }
+  // =============================================================================
+  // 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_run" r
+       SET status = 'error',
+           error_message = 'Auto-cancelled: stale (no update in 5 min)',
+           completed_at = now()
+       WHERE r."_account_id" = $1
+         AND r.status = 'running'
+         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.updated_at >= now() - interval '5 minutes'
+         )`,
+      [accountId]
+    );
+  }
   /**
-   * For array object field like invoice.custom_fields
-   * ex: [{"name":"Project name","value":"Test Project"}]
+   * 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.
    *
-   * we need to stringify it first cos passing array object directly will end up with
-   * {
-   * invalid input syntax for type json
-   * detail: 'Expected ":", but found "}".',
-   * where: 'JSON data, line 1: ...\\":\\"Project name\\",\\"value\\":\\"Test Project\\"}"}',
-   * }
+   * @returns RunKey with isNew flag, or null if constraint violation (race condition)
    */
-  cleanseArrayField(obj) {
-    const cleansed = { ...obj };
-    Object.keys(cleansed).map((k) => {
-      const data = cleansed[k];
-      if (Array.isArray(data)) {
-        cleansed[k] = JSON.stringify(data);
+  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 status = 'running'`,
+      [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;
       }
-    });
-    return cleansed;
+      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 status = 'running'`,
+      [accountId]
+    );
+    if (result.rows.length === 0) return null;
+    const row = result.rows[0];
+    return { accountId: row._account_id, runStartedAt: row.started_at };
+  }
+  /**
+   * Get full sync run details.
+   */
+  async getSyncRun(accountId, runStartedAt) {
+    const result = await this.query(
+      `SELECT "_account_id", started_at, status, max_concurrent
+       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,
+      status: row.status,
+      maxConcurrent: row.max_concurrent
+    };
+  }
+  /**
+   * Mark a sync run as complete.
+   */
+  async completeSyncRun(accountId, runStartedAt) {
+    await this.query(
+      `UPDATE "${this.config.schema}"."_sync_run"
+       SET status = 'complete', completed_at = now()
+       WHERE "_account_id" = $1 AND started_at = $2`,
+      [accountId, runStartedAt]
+    );
+  }
+  /**
+   * Mark a sync run as failed.
+   */
+  async failSyncRun(accountId, runStartedAt, errorMessage) {
+    await this.query(
+      `UPDATE "${this.config.schema}"."_sync_run"
+       SET status = 'error', error_message = $3, completed_at = now()
+       WHERE "_account_id" = $1 AND started_at = $2`,
+      [accountId, runStartedAt, errorMessage]
+    );
+  }
+  /**
+   * 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.
+   */
+  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]
+    );
+  }
+  /**
+   * Mark an object sync as failed.
+   */
+  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]
+    );
+  }
+  /**
+   * 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;
   }
 };
 
-// src/schemas/charge.ts
-var chargeSchema = {
-  properties: [
-    "id",
-    "object",
-    "paid",
-    "order",
-    "amount",
-    "review",
-    "source",
-    "status",
-    "created",
-    "dispute",
-    "invoice",
-    "outcome",
-    "refunds",
-    "captured",
-    "currency",
-    "customer",
-    "livemode",
-    "metadata",
-    "refunded",
-    "shipping",
-    "application",
-    "description",
-    "destination",
-    "failure_code",
-    "on_behalf_of",
-    "fraud_details",
-    "receipt_email",
-    "payment_intent",
-    "receipt_number",
-    "transfer_group",
-    "amount_refunded",
-    "application_fee",
-    "failure_message",
-    "source_transfer",
-    "balance_transaction",
-    "statement_descriptor",
-    "payment_method_details"
-  ]
-};
-
-// src/schemas/checkout_sessions.ts
-var checkoutSessionSchema = {
+// src/schemas/managed_webhook.ts
+var managedWebhookSchema = {
   properties: [
     "id",
     "object",
-    "adaptive_pricing",
-    "after_expiration",
-    "allow_promotion_codes",
-    "amount_subtotal",
-    "amount_total",
-    "automatic_tax",
-    "billing_address_collection",
-    "cancel_url",
-    "client_reference_id",
-    "client_secret",
-    "collected_information",
-    "consent",
-    "consent_collection",
-    "created",
-    "currency",
-    "currency_conversion",
-    "custom_fields",
-    "custom_text",
-    "customer",
-    "customer_creation",
-    "customer_details",
-    "customer_email",
-    "discounts",
-    "expires_at",
-    "invoice",
-    "invoice_creation",
-    "livemode",
-    "locale",
-    "metadata",
-    "mode",
-    "optional_items",
-    "payment_intent",
-    "payment_link",
-    "payment_method_collection",
-    "payment_method_configuration_details",
-    "payment_method_options",
-    "payment_method_types",
-    "payment_status",
-    "permissions",
-    "phone_number_collection",
-    "presentment_details",
-    "recovered_from",
-    "redirect_on_completion",
-    "return_url",
-    "saved_payment_method_options",
-    "setup_intent",
-    "shipping_address_collection",
-    "shipping_cost",
-    "shipping_details",
-    "shipping_options",
-    "status",
-    "submit_type",
-    "subscription",
-    "success_url",
-    "tax_id_collection",
-    "total_details",
-    "ui_mode",
     "url",
-    "wallet_options"
-  ]
-};
-
-// src/schemas/checkout_session_line_items.ts
-var checkoutSessionLineItemSchema = {
-  properties: [
-    "id",
-    "object",
-    "amount_discount",
-    "amount_subtotal",
-    "amount_tax",
-    "amount_total",
-    "currency",
+    "enabled_events",
     "description",
-    "price",
-    "quantity",
-    "checkout_session"
-  ]
-};
-
-// src/schemas/credit_note.ts
-var creditNoteSchema = {
-  properties: [
-    "id",
-    "object",
-    "amount",
-    "amount_shipping",
-    "created",
-    "currency",
-    "customer",
-    "customer_balance_transaction",
-    "discount_amount",
-    "discount_amounts",
-    "invoice",
-    "lines",
+    "enabled",
     "livemode",
-    "memo",
     "metadata",
-    "number",
-    "out_of_band_amount",
-    "pdf",
-    "reason",
-    "refund",
-    "shipping_cost",
+    "secret",
     "status",
-    "subtotal",
-    "subtotal_excluding_tax",
-    "tax_amounts",
-    "total",
-    "total_excluding_tax",
-    "type",
-    "voided_at"
-  ]
-};
-
-// src/schemas/customer.ts
-var customerSchema = {
-  properties: [
-    "id",
-    "object",
-    "address",
-    "description",
-    "email",
-    "metadata",
-    "name",
-    "phone",
-    "shipping",
-    "balance",
+    "api_version",
     "created",
-    "currency",
-    "default_source",
-    "delinquent",
-    "discount",
-    "invoice_prefix",
-    "invoice_settings",
-    "livemode",
-    "next_invoice_sequence",
-    "preferred_locales",
-    "tax_exempt"
+    "account_id"
   ]
 };
-var customerDeletedSchema = {
-  properties: ["id", "object", "deleted"]
-};
 
-// src/schemas/dispute.ts
-var disputeSchema = {
-  properties: [
-    "id",
-    "object",
-    "amount",
-    "charge",
-    "created",
-    "currency",
-    "balance_transactions",
-    "evidence",
-    "evidence_details",
-    "is_charge_refundable",
-    "livemode",
-    "metadata",
-    "payment_intent",
-    "reason",
-    "status"
-  ]
+// 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/schemas/invoice.ts
-var invoiceSchema = {
-  properties: [
-    "id",
-    "object",
-    "auto_advance",
-    "collection_method",
-    "currency",
-    "description",
-    "hosted_invoice_url",
-    "lines",
-    "metadata",
-    "period_end",
-    "period_start",
-    "status",
-    "total",
-    "account_country",
-    "account_name",
-    "account_tax_ids",
-    "amount_due",
-    "amount_paid",
-    "amount_remaining",
-    "application_fee_amount",
-    "attempt_count",
-    "attempted",
-    "billing_reason",
-    "created",
-    "custom_fields",
-    "customer_address",
-    "customer_email",
-    "customer_name",
-    "customer_phone",
-    "customer_shipping",
-    "customer_tax_exempt",
-    "customer_tax_ids",
-    "default_tax_rates",
-    "discount",
-    "discounts",
-    "due_date",
-    "ending_balance",
-    "footer",
-    "invoice_pdf",
-    "last_finalization_error",
-    "livemode",
-    "next_payment_attempt",
-    "number",
-    "paid",
-    "payment_settings",
-    "post_payment_credit_notes_amount",
-    "pre_payment_credit_notes_amount",
-    "receipt_number",
-    "starting_balance",
-    "statement_descriptor",
-    "status_transitions",
-    "subtotal",
-    "tax",
-    "total_discount_amounts",
-    "total_tax_amounts",
-    "transfer_data",
-    "webhooks_delivered_at",
-    "customer",
-    "subscription",
-    "payment_intent",
-    "default_payment_method",
-    "default_source",
-    "on_behalf_of",
-    "charge"
-  ]
-};
+// 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/schemas/plan.ts
-var planSchema = {
-  properties: [
-    "id",
-    "object",
-    "active",
-    "amount",
-    "created",
-    "product",
-    "currency",
-    "interval",
-    "livemode",
-    "metadata",
-    "nickname",
-    "tiers_mode",
-    "usage_type",
-    "billing_scheme",
-    "interval_count",
-    "aggregate_usage",
-    "transform_usage",
-    "trial_period_days"
-  ]
-};
-
-// src/schemas/price.ts
-var priceSchema = {
-  properties: [
-    "id",
-    "object",
-    "active",
-    "currency",
-    "metadata",
-    "nickname",
-    "recurring",
-    "type",
-    "unit_amount",
-    "billing_scheme",
-    "created",
-    "livemode",
-    "lookup_key",
-    "tiers_mode",
-    "transform_quantity",
-    "unit_amount_decimal",
-    "product"
-  ]
-};
-
-// src/schemas/product.ts
-var productSchema = {
-  properties: [
-    "id",
-    "object",
-    "active",
-    "default_price",
-    "description",
-    "metadata",
-    "name",
-    "created",
-    "images",
-    "marketing_features",
-    "livemode",
-    "package_dimensions",
-    "shippable",
-    "statement_descriptor",
-    "unit_label",
-    "updated",
-    "url"
-  ]
-};
-
-// src/schemas/payment_intent.ts
-var paymentIntentSchema = {
-  properties: [
-    "id",
-    "object",
-    "amount",
-    "amount_capturable",
-    "amount_details",
-    "amount_received",
-    "application",
-    "application_fee_amount",
-    "automatic_payment_methods",
-    "canceled_at",
-    "cancellation_reason",
-    "capture_method",
-    "client_secret",
-    "confirmation_method",
-    "created",
-    "currency",
-    "customer",
-    "description",
-    "invoice",
-    "last_payment_error",
-    "livemode",
-    "metadata",
-    "next_action",
-    "on_behalf_of",
-    "payment_method",
-    "payment_method_options",
-    "payment_method_types",
-    "processing",
-    "receipt_email",
-    "review",
-    "setup_future_usage",
-    "shipping",
-    "statement_descriptor",
-    "statement_descriptor_suffix",
-    "status",
-    "transfer_data",
-    "transfer_group"
-  ]
-};
-
-// src/schemas/payment_methods.ts
-var paymentMethodsSchema = {
-  properties: [
-    "id",
-    "object",
-    "created",
-    "customer",
-    "type",
-    "billing_details",
-    "metadata",
-    "card"
-  ]
-};
-
-// src/schemas/setup_intents.ts
-var setupIntentsSchema = {
-  properties: [
-    "id",
-    "object",
-    "created",
-    "customer",
-    "description",
-    "payment_method",
-    "status",
-    "usage",
-    "cancellation_reason",
-    "latest_attempt",
-    "mandate",
-    "single_use_mandate",
-    "on_behalf_of"
-  ]
-};
-
-// src/schemas/tax_id.ts
-var taxIdSchema = {
-  properties: [
-    "id",
-    "country",
-    "customer",
-    "type",
-    "value",
-    "object",
-    "created",
-    "livemode",
-    "owner"
-  ]
-};
-
-// src/schemas/subscription_item.ts
-var subscriptionItemSchema = {
-  properties: [
-    "id",
-    "object",
-    "billing_thresholds",
-    "created",
-    "deleted",
-    "metadata",
-    "quantity",
-    "price",
-    "subscription",
-    "tax_rates",
-    "current_period_end",
-    "current_period_start"
-  ]
-};
-
-// src/schemas/subscription_schedules.ts
-var subscriptionScheduleSchema = {
-  properties: [
-    "id",
-    "object",
-    "application",
-    "canceled_at",
-    "completed_at",
-    "created",
-    "current_phase",
-    "customer",
-    "default_settings",
-    "end_behavior",
-    "livemode",
-    "metadata",
-    "phases",
-    "released_at",
-    "released_subscription",
-    "status",
-    "subscription",
-    "test_clock"
-  ]
-};
-
-// src/schemas/subscription.ts
-var subscriptionSchema = {
-  properties: [
-    "id",
-    "object",
-    "cancel_at_period_end",
-    "current_period_end",
-    "current_period_start",
-    "default_payment_method",
-    "items",
-    "metadata",
-    "pending_setup_intent",
-    "pending_update",
-    "status",
-    "application_fee_percent",
-    "billing_cycle_anchor",
-    "billing_thresholds",
-    "cancel_at",
-    "canceled_at",
-    "collection_method",
-    "created",
-    "days_until_due",
-    "default_source",
-    "default_tax_rates",
-    "discount",
-    "ended_at",
-    "livemode",
-    "next_pending_invoice_item_invoice",
-    "pause_collection",
-    "pending_invoice_item_interval",
-    "start_date",
-    "transfer_data",
-    "trial_end",
-    "trial_start",
-    "schedule",
-    "customer",
-    "latest_invoice",
-    "plan"
-  ]
-};
-
-// src/schemas/early_fraud_warning.ts
-var earlyFraudWarningSchema = {
-  properties: [
-    "id",
-    "object",
-    "actionable",
-    "charge",
-    "created",
-    "fraud_type",
-    "livemode",
-    "payment_intent"
-  ]
-};
-
-// src/schemas/review.ts
-var reviewSchema = {
-  properties: [
-    "id",
-    "object",
-    "billing_zip",
-    "created",
-    "charge",
-    "closed_reason",
-    "livemode",
-    "ip_address",
-    "ip_address_location",
-    "open",
-    "opened_reason",
-    "payment_intent",
-    "reason",
-    "session"
-  ]
-};
-
-// src/schemas/refund.ts
-var refundSchema = {
-  properties: [
-    "id",
-    "object",
-    "amount",
-    "balance_transaction",
-    "charge",
-    "created",
-    "currency",
-    "destination_details",
-    "metadata",
-    "payment_intent",
-    "reason",
-    "receipt_number",
-    "source_transfer_reversal",
-    "status",
-    "transfer_reversal"
-  ]
-};
-
-// src/schemas/active_entitlement.ts
-var activeEntitlementSchema = {
-  properties: ["id", "object", "feature", "lookup_key", "livemode", "customer"]
-};
-
-// src/schemas/feature.ts
-var featureSchema = {
-  properties: ["id", "object", "livemode", "name", "lookup_key", "active", "metadata"]
-};
-
-// src/schemas/managed_webhook.ts
-var managedWebhookSchema = {
-  properties: [
-    "id",
-    "object",
-    "uuid",
-    "url",
-    "enabled_events",
-    "description",
-    "enabled",
-    "livemode",
-    "metadata",
-    "secret",
-    "status",
-    "api_version",
-    "created"
-  ]
-};
-
-// src/stripeSync.ts
-import { randomUUID } from "crypto";
-
-// 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 connectAndMigrate(client, migrationsDirectory, config, logOnError = false) {
-  if (!fs.existsSync(migrationsDirectory)) {
-    config.logger?.info(`Migrations directory ${migrationsDirectory} not found, skipping`);
-    return;
-  }
-  const optionalConfig = {
-    schemaName: config.schema,
-    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
-  });
-  try {
-    await client.connect();
-    await client.query(`CREATE SCHEMA IF NOT EXISTS ${config.schema};`);
-    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/utils/hashApiKey.ts
+import { createHash } from "crypto";
+function hashApiKey(apiKey) {
+  return createHash("sha256").update(apiKey).digest("hex");
 }
 
 // src/stripeSync.ts
-import express from "express";
 function getUniqueIds(entries, key) {
   const set = new Set(
     entries.map((subscription) => subscription?.[key]?.toString()).filter((it) => Boolean(it))
   );
   return Array.from(set);
 }
-var DEFAULT_SCHEMA = "stripe";
-var StripeAutoSync = class {
-  options;
-  webhookId = null;
-  webhookUuid = null;
-  stripeSync = null;
-  constructor(options) {
-    this.options = {
-      ...options,
-      // Apply defaults for undefined values
-      schema: options.schema || "stripe",
-      webhookPath: options.webhookPath || "/stripe-webhooks",
-      stripeApiVersion: options.stripeApiVersion || "2020-08-27",
-      autoExpandLists: options.autoExpandLists !== void 0 ? options.autoExpandLists : false,
-      backfillRelatedEntities: options.backfillRelatedEntities !== void 0 ? options.backfillRelatedEntities : true,
-      keepWebhooksOnShutdown: options.keepWebhooksOnShutdown !== void 0 ? options.keepWebhooksOnShutdown : true
-    };
+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"
+    );
+    this.postgresClient = new PostgresClient({
+      schema: "stripe",
+      adapter: config.adapter
+    });
   }
+  stripe;
+  postgresClient;
   /**
-   * Starts the Stripe Sync infrastructure and mounts webhook handler:
-   * 1. Runs database migrations
-   * 2. Creates StripeSync instance
-   * 3. Creates managed webhook endpoint
-   * 4. Mounts webhook handler on provided Express app
-   * 5. Applies body parsing middleware (automatically skips webhook routes)
-   *
-   * @param app - Express app to mount webhook handler on
-   * @returns Information about the running instance
+   * Get the Stripe account ID. Delegates to getCurrentAccount() for the actual lookup.
    */
-  async start(app) {
+  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 {
-      try {
-        await runMigrations({
-          databaseUrl: this.options.databaseUrl,
-          schema: this.options.schema
-        });
-      } catch (migrationError) {
-        console.warn("Migration failed, dropping schema and retrying...");
-        console.warn("Migration error:", migrationError instanceof Error ? migrationError.message : String(migrationError));
-        const { Client: Client2 } = await import("pg");
-        const client = new Client2({ connectionString: this.options.databaseUrl });
-        try {
-          await client.connect();
-          await client.query(`DROP SCHEMA IF EXISTS "${this.options.schema}" CASCADE`);
-          console.log(`\u2713 Dropped schema: ${this.options.schema}`);
-        } finally {
-          await client.end();
-        }
-        console.log("Retrying migrations...");
-        await runMigrations({
-          databaseUrl: this.options.databaseUrl,
-          schema: this.options.schema
-        });
-        console.log("\u2713 Migrations completed successfully after retry");
-      }
-      const poolConfig = {
-        max: 10,
-        connectionString: this.options.databaseUrl,
-        keepAlive: true
-      };
-      this.stripeSync = new StripeSync({
-        databaseUrl: this.options.databaseUrl,
-        schema: this.options.schema,
-        stripeSecretKey: this.options.stripeApiKey,
-        stripeApiVersion: this.options.stripeApiVersion,
-        autoExpandLists: this.options.autoExpandLists,
-        backfillRelatedEntities: this.options.backfillRelatedEntities,
-        poolConfig
-      });
-      const baseUrl = this.options.baseUrl();
-      const { webhook, uuid } = await this.stripeSync.findOrCreateManagedWebhook(
-        `${baseUrl}${this.options.webhookPath}`,
+      await this.postgresClient.upsertAccount(
         {
-          enabled_events: ["*"],
-          // Subscribe to all events
-          description: "stripe-sync-cli development webhook"
-        }
+          id: account.id,
+          raw_data: account
+        },
+        apiKeyHash
       );
-      this.webhookId = webhook.id;
-      this.webhookUuid = uuid;
-      app.use(this.getBodyParserMiddleware());
-      this.mountWebhook(app);
-      console.log("Starting initial backfill of all Stripe data...");
-      const backfillResult = await this.stripeSync.syncBackfill({ object: "all" });
-      const totalSynced = Object.values(backfillResult).reduce((sum, result) => sum + (result?.synced || 0), 0);
-      console.log(`\u2713 Backfill complete: ${totalSynced} objects synced`);
-      return {
-        baseUrl,
-        webhookUrl: webhook.url,
-        webhookUuid: uuid
-      };
     } catch (error) {
-      if (error instanceof Error) {
-        console.error("Failed to start Stripe Sync:", error.message);
-        console.error(error.stack || "");
-      } else {
-        console.error("Failed to start Stripe Sync:", String(error));
-      }
-      await this.stop();
-      throw 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}`);
     }
   }
   /**
-   * Stops all services and cleans up resources:
-   * 1. Optionally deletes Stripe webhook endpoint from Stripe and database (based on keepWebhooksOnShutdown)
+   * 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 stop() {
-    if (this.webhookId && this.stripeSync && !this.options.keepWebhooksOnShutdown) {
-      try {
-        await this.stripeSync.deleteManagedWebhook(this.webhookId);
-      } catch (error) {
-        console.error("Could not delete webhook:", error);
+  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;
     }
   }
   /**
-   * Returns Express middleware for body parsing that automatically skips webhook routes.
-   * This middleware applies JSON and URL-encoded parsers to all routes EXCEPT the webhook path,
-   * which needs raw body for signature verification.
-   *
-   * @returns Express middleware function
+   * Get all accounts that have been synced to the database
    */
-  getBodyParserMiddleware() {
-    const webhookPath = this.options.webhookPath;
-    return (req, res, next) => {
-      const path2 = req.path || req.url || "";
-      if (path2.startsWith(webhookPath)) {
-        console.log("[BodyParser] Skipping webhook route:", path2);
-        return next();
-      }
-      express.json()(req, res, (err) => {
-        if (err) return next(err);
-        express.urlencoded({ extended: false })(req, res, next);
-      });
-    };
+  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");
+    }
   }
   /**
-   * Mounts the Stripe webhook handler on the provided Express app.
-   * Applies raw body parser middleware for signature verification.
-   * IMPORTANT: Must be called BEFORE app.use(express.json()) to ensure raw body parsing.
+   * 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
    */
-  mountWebhook(app) {
-    const webhookRoute = `${this.options.webhookPath}/:uuid`;
-    app.use(webhookRoute, express.raw({ type: "application/json" }));
-    app.post(webhookRoute, async (req, res) => {
-      console.log("[Webhook] Received request:", {
-        path: req.path,
-        url: req.url,
-        method: req.method,
-        contentType: req.headers["content-type"]
-      });
-      const sig = req.headers["stripe-signature"];
-      if (!sig || typeof sig !== "string") {
-        console.error("[Webhook] Missing stripe-signature header");
-        return res.status(400).send({ error: "Missing stripe-signature header" });
+  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" : ""}`);
+        }
       }
-      const { uuid } = req.params;
-      const rawBody = req.body;
-      if (!rawBody || !Buffer.isBuffer(rawBody)) {
-        console.error("[Webhook] Body is not a Buffer!", {
-          hasBody: !!rawBody,
-          bodyType: typeof rawBody,
-          isBuffer: Buffer.isBuffer(rawBody),
-          bodyConstructor: rawBody?.constructor?.name,
-          path: req.path,
-          url: req.url
-        });
-        return res.status(400).send({ error: "Missing raw body for signature verification" });
+      if (totalRecords > 1e5) {
+        warnings.push(
+          `Large dataset detected (${totalRecords} total records). Consider using useTransaction: false for better performance.`
+        );
       }
-      try {
-        await this.stripeSync.processWebhook(rawBody, sig, uuid);
-        return res.status(200).send({ received: true });
-      } catch (error) {
-        console.error("[Webhook] Processing error:", error.message);
-        return res.status(400).send({ error: error.message });
+      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}`);
+    }
   }
-};
-var StripeSync = class {
-  constructor(config) {
-    this.config = config;
-    this.stripe = new Stripe(config.stripeSecretKey, {
-      // https://github.com/stripe/stripe-node#configuration
-      // @ts-ignore
-      apiVersion: config.stripeApiVersion,
-      appInfo: {
-        name: "Stripe Postgres Sync"
+  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;
       }
-    });
-    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 (!webhookSecret) {
+      throw new Error(
+        "No webhook secret provided. Either create a managed webhook or configure stripeWebhookSecret."
+      );
     }
-    if (poolConfig.max === void 0) {
-      poolConfig.max = 10;
+    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: false
+      // credit_notes don't 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
     }
-    if (poolConfig.keepAlive === void 0) {
-      poolConfig.keepAlive = 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.`
+      );
     }
-    this.postgresClient = new PostgresClient({
-      schema: config.schema || DEFAULT_SCHEMA,
-      poolConfig
-    });
   }
-  stripe;
-  postgresClient;
-  async processWebhook(payload, signature, uuid) {
-    const result = await this.postgresClient.query(
-      `SELECT secret FROM "${this.config.schema || DEFAULT_SCHEMA}"."_managed_webhooks" WHERE uuid = $1`,
-      [uuid]
+  /**
+   * 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"
     );
-    if (result.rows.length === 0) {
-      throw new Error(`No managed webhook found with UUID: ${uuid}`);
-    }
-    const webhookSecret = result.rows[0].secret;
-    const event = await this.stripe.webhooks.constructEventAsync(
-      payload,
-      signature,
-      webhookSecret
+    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
     );
-    return this.processEvent(event);
+    await this.upsertCustomers([customer], accountId, this.getSyncTimestamp(event, refetched));
   }
-  async processEvent(event) {
-    switch (event.type) {
-      case "charge.captured":
-      case "charge.expired":
-      case "charge.failed":
-      case "charge.pending":
-      case "charge.refunded":
-      case "charge.succeeded":
-      case "charge.updated": {
-        const { entity: charge, refetched } = await this.fetchOrUseWebhookData(
-          event.data.object,
-          (id) => this.stripe.charges.retrieve(id),
-          (charge2) => charge2.status === "failed" || charge2.status === "succeeded"
-        );
-        this.config.logger?.info(
-          `Received webhook ${event.id}: ${event.type} for charge ${charge.id}`
-        );
-        await this.upsertCharges([charge], false, this.getSyncTimestamp(event, refetched));
-        break;
-      }
-      case "customer.deleted": {
-        const customer = {
-          id: event.data.object.id,
-          object: "customer",
-          deleted: true
-        };
-        this.config.logger?.info(
-          `Received webhook ${event.id}: ${event.type} for customer ${customer.id}`
-        );
-        await this.upsertCustomers([customer], this.getSyncTimestamp(event, false));
-        break;
-      }
-      case "checkout.session.async_payment_failed":
-      case "checkout.session.async_payment_succeeded":
-      case "checkout.session.completed":
-      case "checkout.session.expired": {
-        const { entity: checkoutSession, refetched } = await this.fetchOrUseWebhookData(
-          event.data.object,
-          (id) => this.stripe.checkout.sessions.retrieve(id)
-        );
-        this.config.logger?.info(
-          `Received webhook ${event.id}: ${event.type} for checkout session ${checkoutSession.id}`
-        );
-        await this.upsertCheckoutSessions(
-          [checkoutSession],
-          false,
-          this.getSyncTimestamp(event, refetched)
-        );
-        break;
-      }
-      case "customer.created":
-      case "customer.updated": {
-        const { entity: customer, refetched } = await this.fetchOrUseWebhookData(
-          event.data.object,
-          (id) => this.stripe.customers.retrieve(id),
-          (customer2) => customer2.deleted === true
-        );
-        this.config.logger?.info(
-          `Received webhook ${event.id}: ${event.type} for customer ${customer.id}`
-        );
-        await this.upsertCustomers([customer], this.getSyncTimestamp(event, refetched));
-        break;
-      }
-      case "customer.subscription.created":
-      case "customer.subscription.deleted":
-      // Soft delete using `status = canceled`
-      case "customer.subscription.paused":
-      case "customer.subscription.pending_update_applied":
-      case "customer.subscription.pending_update_expired":
-      case "customer.subscription.trial_will_end":
-      case "customer.subscription.resumed":
-      case "customer.subscription.updated": {
-        const { entity: subscription, refetched } = await this.fetchOrUseWebhookData(
-          event.data.object,
-          (id) => this.stripe.subscriptions.retrieve(id),
-          (subscription2) => subscription2.status === "canceled" || subscription2.status === "incomplete_expired"
-        );
-        this.config.logger?.info(
-          `Received webhook ${event.id}: ${event.type} for subscription ${subscription.id}`
-        );
-        await this.upsertSubscriptions(
-          [subscription],
-          false,
-          this.getSyncTimestamp(event, refetched)
-        );
-        break;
-      }
-      case "customer.tax_id.updated":
-      case "customer.tax_id.created": {
-        const { entity: taxId, refetched } = await this.fetchOrUseWebhookData(
-          event.data.object,
-          (id) => this.stripe.taxIds.retrieve(id)
-        );
-        this.config.logger?.info(
-          `Received webhook ${event.id}: ${event.type} for taxId ${taxId.id}`
-        );
-        await this.upsertTaxIds([taxId], false, this.getSyncTimestamp(event, refetched));
-        break;
-      }
-      case "customer.tax_id.deleted": {
-        const taxId = event.data.object;
-        this.config.logger?.info(
-          `Received webhook ${event.id}: ${event.type} for taxId ${taxId.id}`
-        );
-        await this.deleteTaxId(taxId.id);
-        break;
-      }
-      case "invoice.created":
-      case "invoice.deleted":
-      case "invoice.finalized":
-      case "invoice.finalization_failed":
-      case "invoice.paid":
-      case "invoice.payment_action_required":
-      case "invoice.payment_failed":
-      case "invoice.payment_succeeded":
-      case "invoice.upcoming":
-      case "invoice.sent":
-      case "invoice.voided":
-      case "invoice.marked_uncollectible":
-      case "invoice.updated": {
-        const { entity: invoice, refetched } = await this.fetchOrUseWebhookData(
-          event.data.object,
-          (id) => this.stripe.invoices.retrieve(id),
-          (invoice2) => invoice2.status === "void"
-        );
-        this.config.logger?.info(
-          `Received webhook ${event.id}: ${event.type} for invoice ${invoice.id}`
-        );
-        await this.upsertInvoices([invoice], false, this.getSyncTimestamp(event, refetched));
-        break;
-      }
-      case "product.created":
-      case "product.updated": {
-        try {
-          const { entity: product, refetched } = await this.fetchOrUseWebhookData(
-            event.data.object,
-            (id) => this.stripe.products.retrieve(id)
-          );
-          this.config.logger?.info(
-            `Received webhook ${event.id}: ${event.type} for product ${product.id}`
-          );
-          await this.upsertProducts([product], this.getSyncTimestamp(event, refetched));
-        } catch (err) {
-          if (err instanceof Stripe.errors.StripeAPIError && err.code === "resource_missing") {
-            await this.deleteProduct(event.data.object.id);
-          } else {
-            throw err;
-          }
-        }
-        break;
-      }
-      case "product.deleted": {
+  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;
-        this.config.logger?.info(
-          `Received webhook ${event.id}: ${event.type} for product ${product.id}`
-        );
         await this.deleteProduct(product.id);
-        break;
-      }
-      case "price.created":
-      case "price.updated": {
-        try {
-          const { entity: price, refetched } = await this.fetchOrUseWebhookData(
-            event.data.object,
-            (id) => this.stripe.prices.retrieve(id)
-          );
-          this.config.logger?.info(
-            `Received webhook ${event.id}: ${event.type} for price ${price.id}`
-          );
-          await this.upsertPrices([price], false, this.getSyncTimestamp(event, refetched));
-        } catch (err) {
-          if (err instanceof Stripe.errors.StripeAPIError && err.code === "resource_missing") {
-            await this.deletePrice(event.data.object.id);
-          } else {
-            throw err;
-          }
-        }
-        break;
+      } else {
+        throw err;
       }
-      case "price.deleted": {
+    }
+  }
+  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;
-        this.config.logger?.info(
-          `Received webhook ${event.id}: ${event.type} for price ${price.id}`
-        );
         await this.deletePrice(price.id);
-        break;
-      }
-      case "plan.created":
-      case "plan.updated": {
-        try {
-          const { entity: plan, refetched } = await this.fetchOrUseWebhookData(
-            event.data.object,
-            (id) => this.stripe.plans.retrieve(id)
-          );
-          this.config.logger?.info(
-            `Received webhook ${event.id}: ${event.type} for plan ${plan.id}`
-          );
-          await this.upsertPlans([plan], false, this.getSyncTimestamp(event, refetched));
-        } catch (err) {
-          if (err instanceof Stripe.errors.StripeAPIError && err.code === "resource_missing") {
-            await this.deletePlan(event.data.object.id);
-          } else {
-            throw err;
-          }
-        }
-        break;
+      } else {
+        throw err;
       }
-      case "plan.deleted": {
+    }
+  }
+  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;
-        this.config.logger?.info(`Received webhook ${event.id}: ${event.type} for plan ${plan.id}`);
         await this.deletePlan(plan.id);
-        break;
-      }
-      case "setup_intent.canceled":
-      case "setup_intent.created":
-      case "setup_intent.requires_action":
-      case "setup_intent.setup_failed":
-      case "setup_intent.succeeded": {
-        const { entity: setupIntent, refetched } = await this.fetchOrUseWebhookData(
-          event.data.object,
-          (id) => this.stripe.setupIntents.retrieve(id),
-          (setupIntent2) => setupIntent2.status === "canceled" || setupIntent2.status === "succeeded"
-        );
-        this.config.logger?.info(
-          `Received webhook ${event.id}: ${event.type} for setupIntent ${setupIntent.id}`
-        );
-        await this.upsertSetupIntents([setupIntent], false, this.getSyncTimestamp(event, refetched));
-        break;
-      }
-      case "subscription_schedule.aborted":
-      case "subscription_schedule.canceled":
-      case "subscription_schedule.completed":
-      case "subscription_schedule.created":
-      case "subscription_schedule.expiring":
-      case "subscription_schedule.released":
-      case "subscription_schedule.updated": {
-        const { entity: subscriptionSchedule, refetched } = await this.fetchOrUseWebhookData(
-          event.data.object,
-          (id) => this.stripe.subscriptionSchedules.retrieve(id),
-          (schedule) => schedule.status === "canceled" || schedule.status === "completed"
-        );
-        this.config.logger?.info(
-          `Received webhook ${event.id}: ${event.type} for subscriptionSchedule ${subscriptionSchedule.id}`
-        );
-        await this.upsertSubscriptionSchedules(
-          [subscriptionSchedule],
-          false,
-          this.getSyncTimestamp(event, refetched)
-        );
-        break;
-      }
-      case "payment_method.attached":
-      case "payment_method.automatically_updated":
-      case "payment_method.detached":
-      case "payment_method.updated": {
-        const { entity: paymentMethod, refetched } = await this.fetchOrUseWebhookData(
-          event.data.object,
-          (id) => this.stripe.paymentMethods.retrieve(id)
-        );
-        this.config.logger?.info(
-          `Received webhook ${event.id}: ${event.type} for paymentMethod ${paymentMethod.id}`
-        );
-        await this.upsertPaymentMethods(
-          [paymentMethod],
-          false,
-          this.getSyncTimestamp(event, refetched)
-        );
-        break;
-      }
-      case "charge.dispute.created":
-      case "charge.dispute.funds_reinstated":
-      case "charge.dispute.funds_withdrawn":
-      case "charge.dispute.updated":
-      case "charge.dispute.closed": {
-        const { entity: dispute, refetched } = await this.fetchOrUseWebhookData(
-          event.data.object,
-          (id) => this.stripe.disputes.retrieve(id),
-          (dispute2) => dispute2.status === "won" || dispute2.status === "lost"
-        );
-        this.config.logger?.info(
-          `Received webhook ${event.id}: ${event.type} for dispute ${dispute.id}`
-        );
-        await this.upsertDisputes([dispute], false, this.getSyncTimestamp(event, refetched));
-        break;
-      }
-      case "payment_intent.amount_capturable_updated":
-      case "payment_intent.canceled":
-      case "payment_intent.created":
-      case "payment_intent.partially_funded":
-      case "payment_intent.payment_failed":
-      case "payment_intent.processing":
-      case "payment_intent.requires_action":
-      case "payment_intent.succeeded": {
-        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"
-        );
-        this.config.logger?.info(
-          `Received webhook ${event.id}: ${event.type} for paymentIntent ${paymentIntent.id}`
-        );
-        await this.upsertPaymentIntents(
-          [paymentIntent],
-          false,
-          this.getSyncTimestamp(event, refetched)
-        );
-        break;
-      }
-      case "credit_note.created":
-      case "credit_note.updated":
-      case "credit_note.voided": {
-        const { entity: creditNote, refetched } = await this.fetchOrUseWebhookData(
-          event.data.object,
-          (id) => this.stripe.creditNotes.retrieve(id),
-          (creditNote2) => creditNote2.status === "void"
-        );
-        this.config.logger?.info(
-          `Received webhook ${event.id}: ${event.type} for creditNote ${creditNote.id}`
-        );
-        await this.upsertCreditNotes([creditNote], false, this.getSyncTimestamp(event, refetched));
-        break;
-      }
-      case "radar.early_fraud_warning.created":
-      case "radar.early_fraud_warning.updated": {
-        const { entity: earlyFraudWarning, refetched } = await this.fetchOrUseWebhookData(
-          event.data.object,
-          (id) => this.stripe.radar.earlyFraudWarnings.retrieve(id)
-        );
-        this.config.logger?.info(
-          `Received webhook ${event.id}: ${event.type} for earlyFraudWarning ${earlyFraudWarning.id}`
-        );
-        await this.upsertEarlyFraudWarning(
-          [earlyFraudWarning],
-          false,
-          this.getSyncTimestamp(event, refetched)
-        );
-        break;
-      }
-      case "refund.created":
-      case "refund.failed":
-      case "refund.updated":
-      case "charge.refund.updated": {
-        const { entity: refund, refetched } = await this.fetchOrUseWebhookData(
-          event.data.object,
-          (id) => this.stripe.refunds.retrieve(id)
-        );
-        this.config.logger?.info(
-          `Received webhook ${event.id}: ${event.type} for refund ${refund.id}`
-        );
-        await this.upsertRefunds([refund], false, this.getSyncTimestamp(event, refetched));
-        break;
-      }
-      case "review.closed":
-      case "review.opened": {
-        const { entity: review, refetched } = await this.fetchOrUseWebhookData(
-          event.data.object,
-          (id) => this.stripe.reviews.retrieve(id)
-        );
-        this.config.logger?.info(
-          `Received webhook ${event.id}: ${event.type} for review ${review.id}`
-        );
-        await this.upsertReviews([review], false, this.getSyncTimestamp(event, refetched));
-        break;
-      }
-      case "entitlements.active_entitlement_summary.updated": {
-        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;
-        }
-        this.config.logger?.info(
-          `Received webhook ${event.id}: ${event.type} for activeEntitlementSummary for customer ${activeEntitlementSummary.customer}`
-        );
-        await this.deleteRemovedActiveEntitlements(
-          activeEntitlementSummary.customer,
-          entitlements.data.map((entitlement) => entitlement.id)
-        );
-        await this.upsertActiveEntitlements(
-          activeEntitlementSummary.customer,
-          entitlements.data,
-          false,
-          this.getSyncTimestamp(event, refetched)
-        );
-        break;
+      } else {
+        throw err;
       }
-      default:
-        throw new Error("Unhandled webhook event");
     }
   }
+  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();
   }
@@ -1477,351 +1583,979 @@ var StripeSync = class {
     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]);
+        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"
       });
-    } else if (stripeId.startsWith("in_")) {
-      return this.stripe.invoices.retrieve(stripeId).then((it) => this.upsertInvoices([it]));
-    } else if (stripeId.startsWith("price_")) {
-      return this.stripe.prices.retrieve(stripeId).then((it) => this.upsertPrices([it]));
-    } else if (stripeId.startsWith("prod_")) {
-      return this.stripe.products.retrieve(stripeId).then((it) => this.upsertProducts([it]));
-    } else if (stripeId.startsWith("sub_")) {
-      return this.stripe.subscriptions.retrieve(stripeId).then((it) => this.upsertSubscriptions([it]));
-    } else if (stripeId.startsWith("seti_")) {
-      return this.stripe.setupIntents.retrieve(stripeId).then((it) => this.upsertSetupIntents([it]));
-    } else if (stripeId.startsWith("pm_")) {
-      return this.stripe.paymentMethods.retrieve(stripeId).then((it) => this.upsertPaymentMethods([it]));
-    } else if (stripeId.startsWith("dp_") || stripeId.startsWith("du_")) {
-      return this.stripe.disputes.retrieve(stripeId).then((it) => this.upsertDisputes([it]));
-    } else if (stripeId.startsWith("ch_")) {
-      return this.stripe.charges.retrieve(stripeId).then((it) => this.upsertCharges([it], true));
-    } else if (stripeId.startsWith("pi_")) {
-      return this.stripe.paymentIntents.retrieve(stripeId).then((it) => this.upsertPaymentIntents([it]));
-    } else if (stripeId.startsWith("txi_")) {
-      return this.stripe.taxIds.retrieve(stripeId).then((it) => this.upsertTaxIds([it]));
-    } else if (stripeId.startsWith("cn_")) {
-      return this.stripe.creditNotes.retrieve(stripeId).then((it) => this.upsertCreditNotes([it]));
-    } else if (stripeId.startsWith("issfr_")) {
-      return this.stripe.radar.earlyFraudWarnings.retrieve(stripeId).then((it) => this.upsertEarlyFraudWarning([it]));
-    } else if (stripeId.startsWith("prv_")) {
-      return this.stripe.reviews.retrieve(stripeId).then((it) => this.upsertReviews([it]));
-    } else if (stripeId.startsWith("re_")) {
-      return this.stripe.refunds.retrieve(stripeId).then((it) => this.upsertRefunds([it]));
-    } else if (stripeId.startsWith("feat_")) {
-      return this.stripe.entitlements.features.retrieve(stripeId).then((it) => this.upsertFeatures([it]));
-    } else if (stripeId.startsWith("cs_")) {
-      return this.stripe.checkout.sessions.retrieve(stripeId).then((it) => this.upsertCheckoutSessions([it]));
-    }
-  }
-  async syncBackfill(params) {
-    const { object } = params ?? {};
-    let products, prices, customers, checkoutSessions, subscriptions, subscriptionSchedules, invoices, setupIntents, paymentMethods, disputes, charges, paymentIntents, plans, taxIds, creditNotes, earlyFraudWarnings, refunds;
-    switch (object) {
-      case "all":
-        products = await this.syncProducts(params);
-        prices = await this.syncPrices(params);
-        plans = await this.syncPlans(params);
-        customers = await this.syncCustomers(params);
-        subscriptions = await this.syncSubscriptions(params);
-        subscriptionSchedules = await this.syncSubscriptionSchedules(params);
-        invoices = await this.syncInvoices(params);
-        charges = await this.syncCharges(params);
-        setupIntents = await this.syncSetupIntents(params);
-        paymentMethods = await this.syncPaymentMethods(params);
-        paymentIntents = await this.syncPaymentIntents(params);
-        taxIds = await this.syncTaxIds(params);
-        creditNotes = await this.syncCreditNotes(params);
-        disputes = await this.syncDisputes(params);
-        earlyFraudWarnings = await this.syncEarlyFraudWarnings(params);
-        refunds = await this.syncRefunds(params);
-        checkoutSessions = await this.syncCheckoutSessions(params);
-        break;
-      case "customer":
-        customers = await this.syncCustomers(params);
-        break;
-      case "invoice":
-        invoices = await this.syncInvoices(params);
-        break;
-      case "price":
-        prices = await this.syncPrices(params);
-        break;
-      case "product":
-        products = await this.syncProducts(params);
-        break;
-      case "subscription":
-        subscriptions = await this.syncSubscriptions(params);
-        break;
-      case "subscription_schedules":
-        subscriptionSchedules = await this.syncSubscriptionSchedules(params);
-        break;
-      case "setup_intent":
-        setupIntents = await this.syncSetupIntents(params);
-        break;
-      case "payment_method":
-        paymentMethods = await this.syncPaymentMethods(params);
-        break;
-      case "dispute":
-        disputes = await this.syncDisputes(params);
-        break;
-      case "charge":
-        charges = await this.syncCharges(params);
-        break;
-      case "payment_intent":
-        paymentIntents = await this.syncPaymentIntents(params);
-      case "plan":
-        plans = await this.syncPlans(params);
-        break;
-      case "tax_id":
-        taxIds = await this.syncTaxIds(params);
-        break;
-      case "credit_note":
-        creditNotes = await this.syncCreditNotes(params);
-        break;
-      case "early_fraud_warning":
-        earlyFraudWarnings = await this.syncEarlyFraudWarnings(params);
-        break;
-      case "refund":
-        refunds = await this.syncRefunds(params);
-        break;
-      case "checkout_sessions":
-        checkoutSessions = await this.syncCheckoutSessions(params);
-        break;
-      default:
+      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.completeSyncRun(accountId, runStartedAt);
+      return results;
+    } catch (error) {
+      await this.postgresClient.failSyncRun(
+        accountId,
+        runStartedAt,
+        error instanceof Error ? error.message : "Unknown error"
+      );
+      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;
     }
-    return {
-      products,
-      prices,
-      customers,
-      checkoutSessions,
-      subscriptions,
-      subscriptionSchedules,
-      invoices,
-      setupIntents,
-      paymentMethods,
-      disputes,
-      charges,
-      paymentIntents,
-      plans,
-      taxIds,
-      creditNotes,
-      earlyFraudWarnings,
-      refunds
-    };
   }
   async syncProducts(syncParams) {
     this.config.logger?.info("Syncing products");
-    const params = { limit: 100 };
-    if (syncParams?.created) params.created = syncParams?.created;
-    return this.fetchAndUpsert(
-      () => this.stripe.products.list(params),
-      (products) => this.upsertProducts(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");
-    const params = { limit: 100 };
-    if (syncParams?.created) params.created = syncParams?.created;
-    return this.fetchAndUpsert(
-      () => this.stripe.prices.list(params),
-      (prices) => this.upsertPrices(prices, syncParams?.backfillRelatedEntities)
-    );
+    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");
-    const params = { limit: 100 };
-    if (syncParams?.created) params.created = syncParams?.created;
-    return this.fetchAndUpsert(
-      () => this.stripe.plans.list(params),
-      (plans) => this.upsertPlans(plans, syncParams?.backfillRelatedEntities)
-    );
+    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");
-    const params = { limit: 100 };
-    if (syncParams?.created) params.created = syncParams.created;
-    return this.fetchAndUpsert(
-      () => this.stripe.customers.list(params),
-      // @ts-expect-error
-      (items) => this.upsertCustomers(items)
-    );
+    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");
-    const params = { status: "all", limit: 100 };
-    if (syncParams?.created) params.created = syncParams.created;
-    return this.fetchAndUpsert(
-      () => this.stripe.subscriptions.list(params),
-      (items) => this.upsertSubscriptions(items, syncParams?.backfillRelatedEntities)
-    );
+    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");
-    const params = { limit: 100 };
-    if (syncParams?.created) params.created = syncParams.created;
-    return this.fetchAndUpsert(
-      () => this.stripe.subscriptionSchedules.list(params),
-      (items) => this.upsertSubscriptionSchedules(items, syncParams?.backfillRelatedEntities)
+    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");
-    const params = { limit: 100 };
-    if (syncParams?.created) params.created = syncParams.created;
-    return this.fetchAndUpsert(
-      () => this.stripe.invoices.list(params),
-      (items) => this.upsertInvoices(items, syncParams?.backfillRelatedEntities)
-    );
+    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");
-    const params = { limit: 100 };
-    if (syncParams?.created) params.created = syncParams.created;
-    return this.fetchAndUpsert(
-      () => this.stripe.charges.list(params),
-      (items) => this.upsertCharges(items, syncParams?.backfillRelatedEntities)
-    );
+    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");
-    const params = { limit: 100 };
-    if (syncParams?.created) params.created = syncParams.created;
-    return this.fetchAndUpsert(
-      () => this.stripe.setupIntents.list(params),
-      (items) => this.upsertSetupIntents(items, syncParams?.backfillRelatedEntities)
-    );
+    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");
-    const params = { limit: 100 };
-    if (syncParams?.created) params.created = syncParams.created;
-    return this.fetchAndUpsert(
-      () => this.stripe.paymentIntents.list(params),
-      (items) => this.upsertPaymentIntents(items, syncParams?.backfillRelatedEntities)
+    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");
-    const params = { limit: 100 };
-    return this.fetchAndUpsert(
-      () => this.stripe.taxIds.list(params),
-      (items) => this.upsertTaxIds(items, syncParams?.backfillRelatedEntities)
-    );
+    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");
-    const prepared = sql2(
-      `select id from "${this.config.schema}"."customers" WHERE deleted <> 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 syncResult = await this.fetchAndUpsert(
-            () => this.stripe.paymentMethods.list({
-              limit: 100,
-              customer: customerId
-            }),
-            (items) => this.upsertPaymentMethods(items, syncParams?.backfillRelatedEntities)
+    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
+                );
+              }
+            })
           );
-          synced += syncResult.synced;
-        })
-      );
-    }
-    return { synced };
+        }
+        await this.postgresClient.completeObjectSync(accountId, runStartedAt, "payment_methods");
+        return { synced };
+      }
+    );
   }
   async syncDisputes(syncParams) {
-    const params = { limit: 100 };
-    if (syncParams?.created) params.created = syncParams.created;
-    return this.fetchAndUpsert(
-      () => this.stripe.disputes.list(params),
-      (items) => this.upsertDisputes(items, syncParams?.backfillRelatedEntities)
-    );
+    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");
-    const params = { limit: 100 };
-    if (syncParams?.created) params.created = syncParams.created;
-    return this.fetchAndUpsert(
-      () => this.stripe.radar.earlyFraudWarnings.list(params),
-      (items) => this.upsertEarlyFraudWarning(items, syncParams?.backfillRelatedEntities)
+    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");
-    const params = { limit: 100 };
-    if (syncParams?.created) params.created = syncParams.created;
-    return this.fetchAndUpsert(
-      () => this.stripe.refunds.list(params),
-      (items) => this.upsertRefunds(items, syncParams?.backfillRelatedEntities)
-    );
+    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");
-    const params = { limit: 100 };
-    if (syncParams?.created) params.created = syncParams?.created;
-    return this.fetchAndUpsert(
-      () => this.stripe.creditNotes.list(params),
-      (creditNotes) => this.upsertCreditNotes(creditNotes)
-    );
+    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");
-    const params = { limit: 100, ...syncParams?.pagination };
-    return this.fetchAndUpsert(
-      () => this.stripe.entitlements.features.list(params),
-      (features) => this.upsertFeatures(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");
-    const params = {
-      customer: customerId,
-      limit: 100,
-      ...syncParams?.pagination
-    };
-    return this.fetchAndUpsert(
-      () => this.stripe.entitlements.activeEntitlements.list(params),
-      (entitlements) => this.upsertActiveEntitlements(customerId, 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");
-    const params = {
-      limit: 100
-    };
-    if (syncParams?.created) params.created = syncParams.created;
-    return this.fetchAndUpsert(
-      () => this.stripe.checkout.sessions.list(params),
-      (items) => this.upsertCheckoutSessions(items, syncParams?.backfillRelatedEntities)
+    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
+        );
+      }
     );
   }
-  async fetchAndUpsert(fetch, upsert) {
-    const items = [];
-    this.config.logger?.info("Fetching items to sync from Stripe");
-    for await (const item of fetch()) {
-      items.push(item);
+  /**
+   * 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.completeSyncRun(accountId, runStartedAt);
+      return result;
+    } catch (error) {
+      await this.postgresClient.failSyncRun(
+        accountId,
+        runStartedAt,
+        error instanceof Error ? error.message : "Unknown error"
+      );
+      throw error;
     }
-    if (!items.length) return { synced: 0 };
-    this.config.logger?.info(`Upserting ${items.length} items`);
-    const chunkSize = 250;
-    for (let i = 0; i < items.length; i += chunkSize) {
-      const chunk = items.slice(i, i + chunkSize);
-      await upsert(chunk);
+  }
+  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;
     }
-    this.config.logger?.info("Upserted items");
-    return { synced: items.length };
   }
-  async upsertCharges(charges, backfillRelatedEntities, syncTimestamp) {
+  async upsertCharges(charges, accountId, backfillRelatedEntities, syncTimestamp) {
     if (backfillRelatedEntities ?? this.config.backfillRelatedEntities) {
       await Promise.all([
-        this.backfillCustomers(getUniqueIds(charges, "customer")),
-        this.backfillInvoices(getUniqueIds(charges, "invoice"))
+        this.backfillCustomers(getUniqueIds(charges, "customer"), accountId),
+        this.backfillInvoices(getUniqueIds(charges, "invoice"), accountId)
       ]);
     }
     await this.expandEntity(
@@ -1832,18 +2566,18 @@ var StripeSync = class {
     return this.postgresClient.upsertManyWithTimestampProtection(
       charges,
       "charges",
-      chargeSchema,
+      accountId,
       syncTimestamp
     );
   }
-  async backfillCharges(chargeIds) {
+  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));
+    ).then((charges) => this.upsertCharges(charges, accountId));
   }
-  async backfillPaymentIntents(paymentIntentIds) {
+  async backfillPaymentIntents(paymentIntentIds, accountId) {
     const missingIds = await this.postgresClient.findMissingEntries(
       "payment_intents",
       paymentIntentIds
@@ -1851,13 +2585,13 @@ var StripeSync = class {
     await this.fetchMissingEntities(
       missingIds,
       (id) => this.stripe.paymentIntents.retrieve(id)
-    ).then((paymentIntents) => this.upsertPaymentIntents(paymentIntents));
+    ).then((paymentIntents) => this.upsertPaymentIntents(paymentIntents, accountId));
   }
-  async upsertCreditNotes(creditNotes, backfillRelatedEntities, syncTimestamp) {
+  async upsertCreditNotes(creditNotes, accountId, backfillRelatedEntities, syncTimestamp) {
     if (backfillRelatedEntities ?? this.config.backfillRelatedEntities) {
       await Promise.all([
-        this.backfillCustomers(getUniqueIds(creditNotes, "customer")),
-        this.backfillInvoices(getUniqueIds(creditNotes, "invoice"))
+        this.backfillCustomers(getUniqueIds(creditNotes, "customer"), accountId),
+        this.backfillInvoices(getUniqueIds(creditNotes, "invoice"), accountId)
       ]);
     }
     await this.expandEntity(
@@ -1868,113 +2602,114 @@ var StripeSync = class {
     return this.postgresClient.upsertManyWithTimestampProtection(
       creditNotes,
       "credit_notes",
-      creditNoteSchema,
+      accountId,
       syncTimestamp
     );
   }
-  async upsertCheckoutSessions(checkoutSessions, backfillRelatedEntities, syncTimestamp) {
+  async upsertCheckoutSessions(checkoutSessions, accountId, backfillRelatedEntities, syncTimestamp) {
     if (backfillRelatedEntities ?? this.config.backfillRelatedEntities) {
       await Promise.all([
-        this.backfillCustomers(getUniqueIds(checkoutSessions, "customer")),
-        this.backfillSubscriptions(getUniqueIds(checkoutSessions, "subscription")),
-        this.backfillPaymentIntents(getUniqueIds(checkoutSessions, "payment_intent")),
-        this.backfillInvoices(getUniqueIds(checkoutSessions, "invoice"))
+        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",
-      checkoutSessionSchema,
+      accountId,
       syncTimestamp
     );
     await this.fillCheckoutSessionsLineItems(
       checkoutSessions.map((cs) => cs.id),
+      accountId,
       syncTimestamp
     );
     return rows;
   }
-  async upsertEarlyFraudWarning(earlyFraudWarnings, backfillRelatedEntities, syncTimestamp) {
+  async upsertEarlyFraudWarning(earlyFraudWarnings, accountId, backfillRelatedEntities, syncTimestamp) {
     if (backfillRelatedEntities ?? this.config.backfillRelatedEntities) {
       await Promise.all([
-        this.backfillPaymentIntents(getUniqueIds(earlyFraudWarnings, "payment_intent")),
-        this.backfillCharges(getUniqueIds(earlyFraudWarnings, "charge"))
+        this.backfillPaymentIntents(getUniqueIds(earlyFraudWarnings, "payment_intent"), accountId),
+        this.backfillCharges(getUniqueIds(earlyFraudWarnings, "charge"), accountId)
       ]);
     }
     return this.postgresClient.upsertManyWithTimestampProtection(
       earlyFraudWarnings,
       "early_fraud_warnings",
-      earlyFraudWarningSchema,
+      accountId,
       syncTimestamp
     );
   }
-  async upsertRefunds(refunds, backfillRelatedEntities, syncTimestamp) {
+  async upsertRefunds(refunds, accountId, backfillRelatedEntities, syncTimestamp) {
     if (backfillRelatedEntities ?? this.config.backfillRelatedEntities) {
       await Promise.all([
-        this.backfillPaymentIntents(getUniqueIds(refunds, "payment_intent")),
-        this.backfillCharges(getUniqueIds(refunds, "charge"))
+        this.backfillPaymentIntents(getUniqueIds(refunds, "payment_intent"), accountId),
+        this.backfillCharges(getUniqueIds(refunds, "charge"), accountId)
       ]);
     }
     return this.postgresClient.upsertManyWithTimestampProtection(
       refunds,
       "refunds",
-      refundSchema,
+      accountId,
       syncTimestamp
     );
   }
-  async upsertReviews(reviews, backfillRelatedEntities, syncTimestamp) {
+  async upsertReviews(reviews, accountId, backfillRelatedEntities, syncTimestamp) {
     if (backfillRelatedEntities ?? this.config.backfillRelatedEntities) {
       await Promise.all([
-        this.backfillPaymentIntents(getUniqueIds(reviews, "payment_intent")),
-        this.backfillCharges(getUniqueIds(reviews, "charge"))
+        this.backfillPaymentIntents(getUniqueIds(reviews, "payment_intent"), accountId),
+        this.backfillCharges(getUniqueIds(reviews, "charge"), accountId)
       ]);
     }
     return this.postgresClient.upsertManyWithTimestampProtection(
       reviews,
       "reviews",
-      reviewSchema,
+      accountId,
       syncTimestamp
     );
   }
-  async upsertCustomers(customers, 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",
-      customerSchema,
+      accountId,
       syncTimestamp
     );
     await this.postgresClient.upsertManyWithTimestampProtection(
       deletedCustomers,
       "customers",
-      customerDeletedSchema,
+      accountId,
       syncTimestamp
     );
     return customers;
   }
-  async backfillCustomers(customerIds) {
+  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)).catch((err) => {
+    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, backfillRelatedEntities, syncTimestamp) {
+  async upsertDisputes(disputes, accountId, backfillRelatedEntities, syncTimestamp) {
     if (backfillRelatedEntities ?? this.config.backfillRelatedEntities) {
-      await this.backfillCharges(getUniqueIds(disputes, "charge"));
+      await this.backfillCharges(getUniqueIds(disputes, "charge"), accountId);
     }
     return this.postgresClient.upsertManyWithTimestampProtection(
       disputes,
       "disputes",
-      disputeSchema,
+      accountId,
       syncTimestamp
     );
   }
-  async upsertInvoices(invoices, backfillRelatedEntities, syncTimestamp) {
+  async upsertInvoices(invoices, accountId, backfillRelatedEntities, syncTimestamp) {
     if (backfillRelatedEntities ?? this.config.backfillRelatedEntities) {
       await Promise.all([
-        this.backfillCustomers(getUniqueIds(invoices, "customer")),
-        this.backfillSubscriptions(getUniqueIds(invoices, "subscription"))
+        this.backfillCustomers(getUniqueIds(invoices, "customer"), accountId),
+        this.backfillSubscriptions(getUniqueIds(invoices, "subscription"), accountId)
       ]);
     }
     await this.expandEntity(
@@ -1985,119 +2720,119 @@ var StripeSync = class {
     return this.postgresClient.upsertManyWithTimestampProtection(
       invoices,
       "invoices",
-      invoiceSchema,
+      accountId,
       syncTimestamp
     );
   }
-  backfillInvoices = async (invoiceIds) => {
+  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)
+      (entries) => this.upsertInvoices(entries, accountId)
     );
   };
-  backfillPrices = async (priceIds) => {
+  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)
+      (entries) => this.upsertPrices(entries, accountId)
     );
   };
-  async upsertPlans(plans, backfillRelatedEntities, syncTimestamp) {
+  async upsertPlans(plans, accountId, backfillRelatedEntities, syncTimestamp) {
     if (backfillRelatedEntities ?? this.config.backfillRelatedEntities) {
-      await this.backfillProducts(getUniqueIds(plans, "product"));
+      await this.backfillProducts(getUniqueIds(plans, "product"), accountId);
     }
     return this.postgresClient.upsertManyWithTimestampProtection(
       plans,
       "plans",
-      planSchema,
+      accountId,
       syncTimestamp
     );
   }
   async deletePlan(id) {
     return this.postgresClient.delete("plans", id);
   }
-  async upsertPrices(prices, backfillRelatedEntities, syncTimestamp) {
+  async upsertPrices(prices, accountId, backfillRelatedEntities, syncTimestamp) {
     if (backfillRelatedEntities ?? this.config.backfillRelatedEntities) {
-      await this.backfillProducts(getUniqueIds(prices, "product"));
+      await this.backfillProducts(getUniqueIds(prices, "product"), accountId);
     }
     return this.postgresClient.upsertManyWithTimestampProtection(
       prices,
       "prices",
-      priceSchema,
+      accountId,
       syncTimestamp
     );
   }
   async deletePrice(id) {
     return this.postgresClient.delete("prices", id);
   }
-  async upsertProducts(products, syncTimestamp) {
+  async upsertProducts(products, accountId, syncTimestamp) {
     return this.postgresClient.upsertManyWithTimestampProtection(
       products,
       "products",
-      productSchema,
+      accountId,
       syncTimestamp
     );
   }
   async deleteProduct(id) {
     return this.postgresClient.delete("products", id);
   }
-  async backfillProducts(productIds) {
+  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));
+    ).then((products) => this.upsertProducts(products, accountId));
   }
-  async upsertPaymentIntents(paymentIntents, backfillRelatedEntities, syncTimestamp) {
+  async upsertPaymentIntents(paymentIntents, accountId, backfillRelatedEntities, syncTimestamp) {
     if (backfillRelatedEntities ?? this.config.backfillRelatedEntities) {
       await Promise.all([
-        this.backfillCustomers(getUniqueIds(paymentIntents, "customer")),
-        this.backfillInvoices(getUniqueIds(paymentIntents, "invoice"))
+        this.backfillCustomers(getUniqueIds(paymentIntents, "customer"), accountId),
+        this.backfillInvoices(getUniqueIds(paymentIntents, "invoice"), accountId)
       ]);
     }
     return this.postgresClient.upsertManyWithTimestampProtection(
       paymentIntents,
       "payment_intents",
-      paymentIntentSchema,
+      accountId,
       syncTimestamp
     );
   }
-  async upsertPaymentMethods(paymentMethods, backfillRelatedEntities = false, syncTimestamp) {
+  async upsertPaymentMethods(paymentMethods, accountId, backfillRelatedEntities = false, syncTimestamp) {
     if (backfillRelatedEntities ?? this.config.backfillRelatedEntities) {
-      await this.backfillCustomers(getUniqueIds(paymentMethods, "customer"));
+      await this.backfillCustomers(getUniqueIds(paymentMethods, "customer"), accountId);
     }
     return this.postgresClient.upsertManyWithTimestampProtection(
       paymentMethods,
       "payment_methods",
-      paymentMethodsSchema,
+      accountId,
       syncTimestamp
     );
   }
-  async upsertSetupIntents(setupIntents, backfillRelatedEntities, syncTimestamp) {
+  async upsertSetupIntents(setupIntents, accountId, backfillRelatedEntities, syncTimestamp) {
     if (backfillRelatedEntities ?? this.config.backfillRelatedEntities) {
-      await this.backfillCustomers(getUniqueIds(setupIntents, "customer"));
+      await this.backfillCustomers(getUniqueIds(setupIntents, "customer"), accountId);
     }
     return this.postgresClient.upsertManyWithTimestampProtection(
       setupIntents,
       "setup_intents",
-      setupIntentsSchema,
+      accountId,
       syncTimestamp
     );
   }
-  async upsertTaxIds(taxIds, backfillRelatedEntities, syncTimestamp) {
+  async upsertTaxIds(taxIds, accountId, backfillRelatedEntities, syncTimestamp) {
     if (backfillRelatedEntities ?? this.config.backfillRelatedEntities) {
-      await this.backfillCustomers(getUniqueIds(taxIds, "customer"));
+      await this.backfillCustomers(getUniqueIds(taxIds, "customer"), accountId);
     }
     return this.postgresClient.upsertManyWithTimestampProtection(
       taxIds,
       "tax_ids",
-      taxIdSchema,
+      accountId,
       syncTimestamp
     );
   }
   async deleteTaxId(id) {
     return this.postgresClient.delete("tax_ids", id);
   }
-  async upsertSubscriptionItems(subscriptionItems, syncTimestamp) {
+  async upsertSubscriptionItems(subscriptionItems, accountId, syncTimestamp) {
     const modifiedSubscriptionItems = subscriptionItems.map((subscriptionItem) => {
       const priceId = subscriptionItem.price.id.toString();
       const deleted = subscriptionItem.deleted;
@@ -2112,11 +2847,11 @@ var StripeSync = class {
     await this.postgresClient.upsertManyWithTimestampProtection(
       modifiedSubscriptionItems,
       "subscription_items",
-      subscriptionItemSchema,
+      accountId,
       syncTimestamp
     );
   }
-  async fillCheckoutSessionsLineItems(checkoutSessionIds, syncTimestamp) {
+  async fillCheckoutSessionsLineItems(checkoutSessionIds, accountId, syncTimestamp) {
     for (const checkoutSessionId of checkoutSessionIds) {
       const lineItemResponses = [];
       for await (const lineItem of this.stripe.checkout.sessions.listLineItems(checkoutSessionId, {
@@ -2124,12 +2859,18 @@ var StripeSync = class {
       })) {
         lineItemResponses.push(lineItem);
       }
-      await this.upsertCheckoutSessionLineItems(lineItemResponses, checkoutSessionId, syncTimestamp);
+      await this.upsertCheckoutSessionLineItems(
+        lineItemResponses,
+        checkoutSessionId,
+        accountId,
+        syncTimestamp
+      );
     }
   }
-  async upsertCheckoutSessionLineItems(lineItems, checkoutSessionId, syncTimestamp) {
+  async upsertCheckoutSessionLineItems(lineItems, checkoutSessionId, accountId, syncTimestamp) {
     await this.backfillPrices(
-      lineItems.map((lineItem) => lineItem.price?.id?.toString() ?? void 0).filter((id) => id !== void 0)
+      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;
@@ -2142,14 +2883,14 @@ var StripeSync = class {
     await this.postgresClient.upsertManyWithTimestampProtection(
       modifiedLineItems,
       "checkout_session_line_items",
-      checkoutSessionLineItemSchema,
+      accountId,
       syncTimestamp
     );
   }
   async markDeletedSubscriptionItems(subscriptionId, currentSubItemIds) {
     let prepared = sql2(`
-    select id from "${this.config.schema}"."subscription_items"
-    where subscription = :subscriptionId and deleted = false;
+    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(
@@ -2158,32 +2899,33 @@ var StripeSync = class {
     if (deletedIds.length > 0) {
       const ids = deletedIds.map(({ id }) => id);
       prepared = sql2(`
-      update "${this.config.schema}"."subscription_items"
-      set deleted = true where id=any(:ids::text[]);
+      update "stripe"."subscription_items"
+      set _raw_data = jsonb_set(_raw_data, '{deleted}', 'true'::jsonb)
+      where id=any(:ids::text[]);
       `)({ ids });
-      const { rowCount } = await await this.postgresClient.query(prepared.text, prepared.values);
+      const { rowCount } = await this.postgresClient.query(prepared.text, prepared.values);
       return { rowCount: rowCount || 0 };
     } else {
       return { rowCount: 0 };
     }
   }
-  async upsertSubscriptionSchedules(subscriptionSchedules, backfillRelatedEntities, syncTimestamp) {
+  async upsertSubscriptionSchedules(subscriptionSchedules, accountId, backfillRelatedEntities, syncTimestamp) {
     if (backfillRelatedEntities ?? this.config.backfillRelatedEntities) {
       const customerIds = getUniqueIds(subscriptionSchedules, "customer");
-      await this.backfillCustomers(customerIds);
+      await this.backfillCustomers(customerIds, accountId);
     }
     const rows = await this.postgresClient.upsertManyWithTimestampProtection(
       subscriptionSchedules,
       "subscription_schedules",
-      subscriptionScheduleSchema,
+      accountId,
       syncTimestamp
     );
     return rows;
   }
-  async upsertSubscriptions(subscriptions, backfillRelatedEntities, syncTimestamp) {
+  async upsertSubscriptions(subscriptions, accountId, backfillRelatedEntities, syncTimestamp) {
     if (backfillRelatedEntities ?? this.config.backfillRelatedEntities) {
       const customerIds = getUniqueIds(subscriptions, "customer");
-      await this.backfillCustomers(customerIds);
+      await this.backfillCustomers(customerIds, accountId);
     }
     await this.expandEntity(
       subscriptions,
@@ -2193,11 +2935,11 @@ var StripeSync = class {
     const rows = await this.postgresClient.upsertManyWithTimestampProtection(
       subscriptions,
       "subscriptions",
-      subscriptionSchema,
+      accountId,
       syncTimestamp
     );
     const allSubscriptionItems = subscriptions.flatMap((subscription) => subscription.items.data);
-    await this.upsertSubscriptionItems(allSubscriptionItems, syncTimestamp);
+    await this.upsertSubscriptionItems(allSubscriptionItems, accountId, syncTimestamp);
     const markSubscriptionItemsDeleted = [];
     for (const subscription of subscriptions) {
       const subscriptionItems = subscription.items.data;
@@ -2211,35 +2953,35 @@ var StripeSync = class {
   }
   async deleteRemovedActiveEntitlements(customerId, currentActiveEntitlementIds) {
     const prepared = sql2(`
-      delete from "${this.config.schema}"."active_entitlements"
+      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, syncTimestamp) {
+  async upsertFeatures(features, accountId, syncTimestamp) {
     return this.postgresClient.upsertManyWithTimestampProtection(
       features,
       "features",
-      featureSchema,
+      accountId,
       syncTimestamp
     );
   }
-  async backfillFeatures(featureIds) {
+  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)).catch((err) => {
+    ).then((features) => this.upsertFeatures(features, accountId)).catch((err) => {
       this.config.logger?.error(err, "Failed to backfill features");
       throw err;
     });
   }
-  async upsertActiveEntitlements(customerId, activeEntitlements, backfillRelatedEntities, syncTimestamp) {
+  async upsertActiveEntitlements(customerId, activeEntitlements, accountId, backfillRelatedEntities, syncTimestamp) {
     if (backfillRelatedEntities ?? this.config.backfillRelatedEntities) {
       await Promise.all([
-        this.backfillCustomers(getUniqueIds(activeEntitlements, "customer")),
-        this.backfillFeatures(getUniqueIds(activeEntitlements, "feature"))
+        this.backfillCustomers(getUniqueIds(activeEntitlements, "customer"), accountId),
+        this.backfillFeatures(getUniqueIds(activeEntitlements, "feature"), accountId)
       ]);
     }
     const entitlements = activeEntitlements.map((entitlement) => ({
@@ -2253,77 +2995,159 @@ var StripeSync = class {
     return this.postgresClient.upsertManyWithTimestampProtection(
       entitlements,
       "active_entitlements",
-      activeEntitlementSchema,
+      accountId,
       syncTimestamp
     );
   }
-  // Managed Webhook CRUD methods
-  async createManagedWebhook(baseUrl, params) {
-    const uuid = randomUUID();
-    const webhookUrl = `${baseUrl}/${uuid}`;
-    const webhook = await this.stripe.webhookEndpoints.create({
-      ...params,
-      url: webhookUrl
-    });
-    const webhookWithUuid = { ...webhook, uuid };
-    await this.upsertManagedWebhooks([webhookWithUuid]);
-    return { webhook, uuid };
-  }
-  async findOrCreateManagedWebhook(baseUrl, params) {
-    const existingWebhooks = await this.listManagedWebhooks();
-    for (const existingWebhook of existingWebhooks) {
-      const existingBaseUrl = existingWebhook.url.replace(/\/[^/]+$/, "");
-      if (existingBaseUrl === baseUrl) {
+  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
-          );
+          const stripeWebhook = await this.stripe.webhookEndpoints.retrieve(existingWebhook.id);
           if (stripeWebhook.status === "enabled") {
-            return {
-              webhook: stripeWebhook,
-              uuid: existingWebhook.uuid
-            };
+            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) {
-          continue;
+          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;
+          }
         }
       }
-    }
-    return this.createManagedWebhook(baseUrl, params);
+      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 "${this.config.schema || DEFAULT_SCHEMA}"."_managed_webhooks" WHERE id = $1`,
-      [id]
+      `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 "${this.config.schema || DEFAULT_SCHEMA}"."_managed_webhooks" ORDER BY created DESC`
+      `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 existing = await this.getManagedWebhook(id);
-    const webhookWithUuid = { ...webhook, uuid: existing?.uuid || randomUUID() };
-    await this.upsertManagedWebhooks([webhookWithUuid]);
+    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, syncTimestamp) {
+  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(
-      webhooks,
+      filteredWebhooks,
       "_managed_webhooks",
-      managedWebhookSchema,
+      accountId,
       syncTimestamp
     );
   }
-  async backfillSubscriptions(subscriptionIds) {
+  async backfillSubscriptions(subscriptionIds, accountId) {
     const missingSubscriptionIds = await this.postgresClient.findMissingEntries(
       "subscriptions",
       subscriptionIds
@@ -2331,9 +3155,9 @@ var StripeSync = class {
     await this.fetchMissingEntities(
       missingSubscriptionIds,
       (id) => this.stripe.subscriptions.retrieve(id)
-    ).then((subscriptions) => this.upsertSubscriptions(subscriptions));
+    ).then((subscriptions) => this.upsertSubscriptions(subscriptions, accountId));
   }
-  backfillSubscriptionSchedules = async (subscriptionIds) => {
+  backfillSubscriptionSchedules = async (subscriptionIds, accountId) => {
     const missingSubscriptionIds = await this.postgresClient.findMissingEntries(
       "subscription_schedules",
       subscriptionIds
@@ -2341,7 +3165,9 @@ var StripeSync = class {
     await this.fetchMissingEntities(
       missingSubscriptionIds,
       (id) => this.stripe.subscriptionSchedules.retrieve(id)
-    ).then((subscriptionSchedules) => this.upsertSubscriptionSchedules(subscriptionSchedules));
+    ).then(
+      (subscriptionSchedules) => this.upsertSubscriptionSchedules(subscriptionSchedules, accountId)
+    );
   };
   /**
    * Stripe only sends the first 10 entries by default, the option will actively fetch all entries.
@@ -2379,8 +3205,92 @@ function chunkArray(array, chunkSize) {
   }
   return result;
 }
+
+// src/database/migrate.ts
+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({
+    text: `SELECT EXISTS (
+      SELECT 1
+      FROM information_schema.tables
+      WHERE table_schema = $1
+      AND table_name = $2
+    )`,
+    values: [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, logger, logOnError = false) {
+  if (!fs.existsSync(migrationsDirectory)) {
+    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) {
+      logger?.error(error, "Migration error:");
+    } else {
+      throw error;
+    }
+  }
+}
+async function runMigrations(adapter, logger) {
+  const client = adapter.toPgClient();
+  const schema = "stripe";
+  try {
+    await client.query(`CREATE SCHEMA IF NOT EXISTS ${schema};`);
+    await renameMigrationsTableIfNeeded(client, schema, 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, logger);
+      }
+    }
+    logger?.info("Running migrations");
+    await connectAndMigrate(client, path.resolve(__dirname2, "./migrations"), logger);
+  } catch (err) {
+    logger?.error(err, "Error running migrations");
+    throw err;
+  } finally {
+    logger?.info("Finished migrations");
+  }
+}
+
+// src/index.ts
+var VERSION = package_default.version;
 export {
   PostgresClient,
-  StripeAutoSync,
+  StripeSync,
+  VERSION,
+  hashApiKey,
   runMigrations
 };