stripe-experiment-sync 0.0.0

package/dist/index.js

@@ -0,0 +1,2328 @@
+// src/stripeSync.ts
+import Stripe from "stripe";
+import { pg as sql2 } from "yesql";
+
+// src/database/postgres.ts
+import pg from "pg";
+import { pg as sql } from "yesql";
+var PostgresClient = class {
+  constructor(config) {
+    this.config = config;
+    this.pool = new pg.Pool(config.poolConfig);
+  }
+  pool;
+  async delete(table, id) {
+    const prepared = sql(`
+    delete from "${this.config.schema}"."${table}" 
+    where id = :id
+    returning id;
+    `)({ id });
+    const { rows } = await this.query(prepared.text, prepared.values);
+    return rows.length > 0;
+  }
+  async query(text, params) {
+    return this.pool.query(text, params);
+  }
+  async upsertMany(entries, table, tableSchema) {
+    if (!entries.length) return [];
+    const chunkSize = 5;
+    const results = [];
+    for (let i = 0; i < entries.length; i += chunkSize) {
+      const chunk = entries.slice(i, i + chunkSize);
+      const queries = [];
+      chunk.forEach((entry) => {
+        const 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));
+      });
+      results.push(...await Promise.all(queries));
+    }
+    return results.flatMap((it) => it.rows);
+  }
+  async upsertManyWithTimestampProtection(entries, table, tableSchema, syncTimestamp) {
+    const timestamp = syncTimestamp || (/* @__PURE__ */ new Date()).toISOString();
+    if (!entries.length) return [];
+    const chunkSize = 5;
+    const results = [];
+    for (let i = 0; i < entries.length; i += chunkSize) {
+      const chunk = entries.slice(i, i + chunkSize);
+      const queries = [];
+      chunk.forEach((entry) => {
+        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));
+      });
+      results.push(...await Promise.all(queries));
+    }
+    return results.flatMap((it) => it.rows);
+  }
+  async findMissingEntries(table, ids) {
+    if (!ids.length) return [];
+    const prepared = sql(`
+    select id from "${this.config.schema}"."${table}"
+    where id=any(:ids::text[]);
+    `)({ ids });
+    const { rows } = await this.query(prepared.text, prepared.values);
+    const existingIds = rows.map((it) => it.id);
+    const missingIds = ids.filter((it) => !existingIds.includes(it));
+    return missingIds;
+  }
+  /**
+   * 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
+   *  )
+   */
+  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(",")}
+    ;`;
+  }
+  /**
+   * Returns an (yesql formatted) upsert function with timestamp protection.
+   *
+   * 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.
+   *
+   *
+   * 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;
+   */
+  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;`;
+  };
+  /**
+   * For array object field like invoice.custom_fields
+   * ex: [{"name":"Project name","value":"Test Project"}]
+   *
+   * 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\\"}"}',
+   * }
+   */
+  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;
+  }
+};
+
+// 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 = {
+  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",
+    "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",
+    "livemode",
+    "memo",
+    "metadata",
+    "number",
+    "out_of_band_amount",
+    "pdf",
+    "reason",
+    "refund",
+    "shipping_cost",
+    "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",
+    "created",
+    "currency",
+    "default_source",
+    "delinquent",
+    "discount",
+    "invoice_prefix",
+    "invoice_settings",
+    "livemode",
+    "next_invoice_sequence",
+    "preferred_locales",
+    "tax_exempt"
+  ]
+};
+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/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/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/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
+    };
+  }
+  /**
+   * 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
+   */
+  async start(app) {
+    try {
+      await runMigrations({
+        databaseUrl: this.options.databaseUrl,
+        schema: this.options.schema
+      });
+      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.createManagedWebhook(
+        `${baseUrl}${this.options.webhookPath}`,
+        {
+          enabled_events: ["*"],
+          // Subscribe to all events
+          description: "stripe-sync-cli development webhook"
+        }
+      );
+      this.webhookId = webhook.id;
+      this.webhookUuid = uuid;
+      this.mountWebhook(app);
+      app.use(this.getBodyParserMiddleware());
+      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;
+    }
+  }
+  /**
+   * Stops all services and cleans up resources:
+   * 1. Deletes Stripe webhook endpoint from Stripe and database
+   */
+  async stop() {
+    if (this.webhookId && this.stripeSync) {
+      try {
+        await this.stripeSync.deleteManagedWebhook(this.webhookId);
+      } catch (error) {
+        console.error("Could not delete webhook:", error);
+      }
+    }
+  }
+  /**
+   * 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
+   */
+  getBodyParserMiddleware() {
+    const webhookPath = this.options.webhookPath;
+    return (req, res, next) => {
+      if (req.path.startsWith(webhookPath)) {
+        return next();
+      }
+      express.json()(req, res, (err) => {
+        if (err) return next(err);
+        express.urlencoded({ extended: false })(req, res, next);
+      });
+    };
+  }
+  /**
+   * 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.
+   */
+  mountWebhook(app) {
+    const webhookRoute = `${this.options.webhookPath}/:uuid`;
+    app.use(webhookRoute, express.raw({ type: "application/json" }));
+    app.post(webhookRoute, async (req, res) => {
+      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" });
+      }
+      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
+        });
+        return res.status(400).send({ error: "Missing raw body for signature verification" });
+      }
+      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 });
+      }
+    });
+  }
+};
+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"
+      }
+    });
+    this.config.logger?.info(
+      { autoExpandLists: config.autoExpandLists, stripeApiVersion: config.stripeApiVersion },
+      "StripeSync initialized"
+    );
+    const poolConfig = config.poolConfig ?? {};
+    if (config.databaseUrl) {
+      poolConfig.connectionString = config.databaseUrl;
+    }
+    if (config.maxPostgresConnections) {
+      poolConfig.max = config.maxPostgresConnections;
+    }
+    if (poolConfig.max === void 0) {
+      poolConfig.max = 10;
+    }
+    if (poolConfig.keepAlive === void 0) {
+      poolConfig.keepAlive = true;
+    }
+    this.postgresClient = new PostgresClient({
+      schema: 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]
+    );
+    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
+    );
+    return this.processEvent(event);
+  }
+  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": {
+        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;
+      }
+      case "price.deleted": {
+        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;
+      }
+      case "plan.deleted": {
+        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;
+      }
+      default:
+        throw new Error("Unhandled webhook event");
+    }
+  }
+  getSyncTimestamp(event, refetched) {
+    return refetched ? (/* @__PURE__ */ new Date()).toISOString() : new Date(event.created * 1e3).toISOString();
+  }
+  shouldRefetchEntity(entity) {
+    return this.config.revalidateObjectsViaStripeApi?.includes(entity.object);
+  }
+  async fetchOrUseWebhookData(entity, fetchFn, entityInFinalState) {
+    if (!entity.id) return { entity, refetched: false };
+    if (entityInFinalState && entityInFinalState(entity)) return { entity, refetched: false };
+    if (this.shouldRefetchEntity(entity)) {
+      const fetchedEntity = await fetchFn(entity.id);
+      return { entity: fetchedEntity, refetched: true };
+    }
+    return { entity, refetched: false };
+  }
+  async syncSingleEntity(stripeId) {
+    if (stripeId.startsWith("cus_")) {
+      return this.stripe.customers.retrieve(stripeId).then((it) => {
+        if (!it || it.deleted) return;
+        return this.upsertCustomers([it]);
+      });
+    } 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:
+        break;
+    }
+    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)
+    );
+  }
+  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)
+    );
+  }
+  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)
+    );
+  }
+  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)
+    );
+  }
+  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)
+    );
+  }
+  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)
+    );
+  }
+  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)
+    );
+  }
+  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)
+    );
+  }
+  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)
+    );
+  }
+  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)
+    );
+  }
+  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)
+    );
+  }
+  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)
+          );
+          synced += syncResult.synced;
+        })
+      );
+    }
+    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)
+    );
+  }
+  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)
+    );
+  }
+  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)
+    );
+  }
+  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)
+    );
+  }
+  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)
+    );
+  }
+  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)
+    );
+  }
+  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)
+    );
+  }
+  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);
+    }
+    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);
+    }
+    this.config.logger?.info("Upserted items");
+    return { synced: items.length };
+  }
+  async upsertCharges(charges, backfillRelatedEntities, syncTimestamp) {
+    if (backfillRelatedEntities ?? this.config.backfillRelatedEntities) {
+      await Promise.all([
+        this.backfillCustomers(getUniqueIds(charges, "customer")),
+        this.backfillInvoices(getUniqueIds(charges, "invoice"))
+      ]);
+    }
+    await this.expandEntity(
+      charges,
+      "refunds",
+      (id) => this.stripe.refunds.list({ charge: id, limit: 100 })
+    );
+    return this.postgresClient.upsertManyWithTimestampProtection(
+      charges,
+      "charges",
+      chargeSchema,
+      syncTimestamp
+    );
+  }
+  async backfillCharges(chargeIds) {
+    const missingChargeIds = await this.postgresClient.findMissingEntries("charges", chargeIds);
+    await this.fetchMissingEntities(
+      missingChargeIds,
+      (id) => this.stripe.charges.retrieve(id)
+    ).then((charges) => this.upsertCharges(charges));
+  }
+  async backfillPaymentIntents(paymentIntentIds) {
+    const missingIds = await this.postgresClient.findMissingEntries(
+      "payment_intents",
+      paymentIntentIds
+    );
+    await this.fetchMissingEntities(
+      missingIds,
+      (id) => this.stripe.paymentIntents.retrieve(id)
+    ).then((paymentIntents) => this.upsertPaymentIntents(paymentIntents));
+  }
+  async upsertCreditNotes(creditNotes, backfillRelatedEntities, syncTimestamp) {
+    if (backfillRelatedEntities ?? this.config.backfillRelatedEntities) {
+      await Promise.all([
+        this.backfillCustomers(getUniqueIds(creditNotes, "customer")),
+        this.backfillInvoices(getUniqueIds(creditNotes, "invoice"))
+      ]);
+    }
+    await this.expandEntity(
+      creditNotes,
+      "lines",
+      (id) => this.stripe.creditNotes.listLineItems(id, { limit: 100 })
+    );
+    return this.postgresClient.upsertManyWithTimestampProtection(
+      creditNotes,
+      "credit_notes",
+      creditNoteSchema,
+      syncTimestamp
+    );
+  }
+  async upsertCheckoutSessions(checkoutSessions, 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"))
+      ]);
+    }
+    const rows = await this.postgresClient.upsertManyWithTimestampProtection(
+      checkoutSessions,
+      "checkout_sessions",
+      checkoutSessionSchema,
+      syncTimestamp
+    );
+    await this.fillCheckoutSessionsLineItems(
+      checkoutSessions.map((cs) => cs.id),
+      syncTimestamp
+    );
+    return rows;
+  }
+  async upsertEarlyFraudWarning(earlyFraudWarnings, backfillRelatedEntities, syncTimestamp) {
+    if (backfillRelatedEntities ?? this.config.backfillRelatedEntities) {
+      await Promise.all([
+        this.backfillPaymentIntents(getUniqueIds(earlyFraudWarnings, "payment_intent")),
+        this.backfillCharges(getUniqueIds(earlyFraudWarnings, "charge"))
+      ]);
+    }
+    return this.postgresClient.upsertManyWithTimestampProtection(
+      earlyFraudWarnings,
+      "early_fraud_warnings",
+      earlyFraudWarningSchema,
+      syncTimestamp
+    );
+  }
+  async upsertRefunds(refunds, backfillRelatedEntities, syncTimestamp) {
+    if (backfillRelatedEntities ?? this.config.backfillRelatedEntities) {
+      await Promise.all([
+        this.backfillPaymentIntents(getUniqueIds(refunds, "payment_intent")),
+        this.backfillCharges(getUniqueIds(refunds, "charge"))
+      ]);
+    }
+    return this.postgresClient.upsertManyWithTimestampProtection(
+      refunds,
+      "refunds",
+      refundSchema,
+      syncTimestamp
+    );
+  }
+  async upsertReviews(reviews, backfillRelatedEntities, syncTimestamp) {
+    if (backfillRelatedEntities ?? this.config.backfillRelatedEntities) {
+      await Promise.all([
+        this.backfillPaymentIntents(getUniqueIds(reviews, "payment_intent")),
+        this.backfillCharges(getUniqueIds(reviews, "charge"))
+      ]);
+    }
+    return this.postgresClient.upsertManyWithTimestampProtection(
+      reviews,
+      "reviews",
+      reviewSchema,
+      syncTimestamp
+    );
+  }
+  async upsertCustomers(customers, syncTimestamp) {
+    const deletedCustomers = customers.filter((customer) => customer.deleted);
+    const nonDeletedCustomers = customers.filter((customer) => !customer.deleted);
+    await this.postgresClient.upsertManyWithTimestampProtection(
+      nonDeletedCustomers,
+      "customers",
+      customerSchema,
+      syncTimestamp
+    );
+    await this.postgresClient.upsertManyWithTimestampProtection(
+      deletedCustomers,
+      "customers",
+      customerDeletedSchema,
+      syncTimestamp
+    );
+    return customers;
+  }
+  async backfillCustomers(customerIds) {
+    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) => {
+      this.config.logger?.error(err, "Failed to backfill");
+      throw err;
+    });
+  }
+  async upsertDisputes(disputes, backfillRelatedEntities, syncTimestamp) {
+    if (backfillRelatedEntities ?? this.config.backfillRelatedEntities) {
+      await this.backfillCharges(getUniqueIds(disputes, "charge"));
+    }
+    return this.postgresClient.upsertManyWithTimestampProtection(
+      disputes,
+      "disputes",
+      disputeSchema,
+      syncTimestamp
+    );
+  }
+  async upsertInvoices(invoices, backfillRelatedEntities, syncTimestamp) {
+    if (backfillRelatedEntities ?? this.config.backfillRelatedEntities) {
+      await Promise.all([
+        this.backfillCustomers(getUniqueIds(invoices, "customer")),
+        this.backfillSubscriptions(getUniqueIds(invoices, "subscription"))
+      ]);
+    }
+    await this.expandEntity(
+      invoices,
+      "lines",
+      (id) => this.stripe.invoices.listLineItems(id, { limit: 100 })
+    );
+    return this.postgresClient.upsertManyWithTimestampProtection(
+      invoices,
+      "invoices",
+      invoiceSchema,
+      syncTimestamp
+    );
+  }
+  backfillInvoices = async (invoiceIds) => {
+    const missingIds = await this.postgresClient.findMissingEntries("invoices", invoiceIds);
+    await this.fetchMissingEntities(missingIds, (id) => this.stripe.invoices.retrieve(id)).then(
+      (entries) => this.upsertInvoices(entries)
+    );
+  };
+  backfillPrices = async (priceIds) => {
+    const missingIds = await this.postgresClient.findMissingEntries("prices", priceIds);
+    await this.fetchMissingEntities(missingIds, (id) => this.stripe.prices.retrieve(id)).then(
+      (entries) => this.upsertPrices(entries)
+    );
+  };
+  async upsertPlans(plans, backfillRelatedEntities, syncTimestamp) {
+    if (backfillRelatedEntities ?? this.config.backfillRelatedEntities) {
+      await this.backfillProducts(getUniqueIds(plans, "product"));
+    }
+    return this.postgresClient.upsertManyWithTimestampProtection(
+      plans,
+      "plans",
+      planSchema,
+      syncTimestamp
+    );
+  }
+  async deletePlan(id) {
+    return this.postgresClient.delete("plans", id);
+  }
+  async upsertPrices(prices, backfillRelatedEntities, syncTimestamp) {
+    if (backfillRelatedEntities ?? this.config.backfillRelatedEntities) {
+      await this.backfillProducts(getUniqueIds(prices, "product"));
+    }
+    return this.postgresClient.upsertManyWithTimestampProtection(
+      prices,
+      "prices",
+      priceSchema,
+      syncTimestamp
+    );
+  }
+  async deletePrice(id) {
+    return this.postgresClient.delete("prices", id);
+  }
+  async upsertProducts(products, syncTimestamp) {
+    return this.postgresClient.upsertManyWithTimestampProtection(
+      products,
+      "products",
+      productSchema,
+      syncTimestamp
+    );
+  }
+  async deleteProduct(id) {
+    return this.postgresClient.delete("products", id);
+  }
+  async backfillProducts(productIds) {
+    const missingProductIds = await this.postgresClient.findMissingEntries("products", productIds);
+    await this.fetchMissingEntities(
+      missingProductIds,
+      (id) => this.stripe.products.retrieve(id)
+    ).then((products) => this.upsertProducts(products));
+  }
+  async upsertPaymentIntents(paymentIntents, backfillRelatedEntities, syncTimestamp) {
+    if (backfillRelatedEntities ?? this.config.backfillRelatedEntities) {
+      await Promise.all([
+        this.backfillCustomers(getUniqueIds(paymentIntents, "customer")),
+        this.backfillInvoices(getUniqueIds(paymentIntents, "invoice"))
+      ]);
+    }
+    return this.postgresClient.upsertManyWithTimestampProtection(
+      paymentIntents,
+      "payment_intents",
+      paymentIntentSchema,
+      syncTimestamp
+    );
+  }
+  async upsertPaymentMethods(paymentMethods, backfillRelatedEntities = false, syncTimestamp) {
+    if (backfillRelatedEntities ?? this.config.backfillRelatedEntities) {
+      await this.backfillCustomers(getUniqueIds(paymentMethods, "customer"));
+    }
+    return this.postgresClient.upsertManyWithTimestampProtection(
+      paymentMethods,
+      "payment_methods",
+      paymentMethodsSchema,
+      syncTimestamp
+    );
+  }
+  async upsertSetupIntents(setupIntents, backfillRelatedEntities, syncTimestamp) {
+    if (backfillRelatedEntities ?? this.config.backfillRelatedEntities) {
+      await this.backfillCustomers(getUniqueIds(setupIntents, "customer"));
+    }
+    return this.postgresClient.upsertManyWithTimestampProtection(
+      setupIntents,
+      "setup_intents",
+      setupIntentsSchema,
+      syncTimestamp
+    );
+  }
+  async upsertTaxIds(taxIds, backfillRelatedEntities, syncTimestamp) {
+    if (backfillRelatedEntities ?? this.config.backfillRelatedEntities) {
+      await this.backfillCustomers(getUniqueIds(taxIds, "customer"));
+    }
+    return this.postgresClient.upsertManyWithTimestampProtection(
+      taxIds,
+      "tax_ids",
+      taxIdSchema,
+      syncTimestamp
+    );
+  }
+  async deleteTaxId(id) {
+    return this.postgresClient.delete("tax_ids", id);
+  }
+  async upsertSubscriptionItems(subscriptionItems, syncTimestamp) {
+    const modifiedSubscriptionItems = subscriptionItems.map((subscriptionItem) => {
+      const priceId = subscriptionItem.price.id.toString();
+      const deleted = subscriptionItem.deleted;
+      const quantity = subscriptionItem.quantity;
+      return {
+        ...subscriptionItem,
+        price: priceId,
+        deleted: deleted ?? false,
+        quantity: quantity ?? null
+      };
+    });
+    await this.postgresClient.upsertManyWithTimestampProtection(
+      modifiedSubscriptionItems,
+      "subscription_items",
+      subscriptionItemSchema,
+      syncTimestamp
+    );
+  }
+  async fillCheckoutSessionsLineItems(checkoutSessionIds, syncTimestamp) {
+    for (const checkoutSessionId of checkoutSessionIds) {
+      const lineItemResponses = [];
+      for await (const lineItem of this.stripe.checkout.sessions.listLineItems(checkoutSessionId, {
+        limit: 100
+      })) {
+        lineItemResponses.push(lineItem);
+      }
+      await this.upsertCheckoutSessionLineItems(lineItemResponses, checkoutSessionId, syncTimestamp);
+    }
+  }
+  async upsertCheckoutSessionLineItems(lineItems, checkoutSessionId, syncTimestamp) {
+    await this.backfillPrices(
+      lineItems.map((lineItem) => lineItem.price?.id?.toString() ?? void 0).filter((id) => id !== void 0)
+    );
+    const modifiedLineItems = lineItems.map((lineItem) => {
+      const priceId = typeof lineItem.price === "object" && lineItem.price?.id ? lineItem.price.id.toString() : lineItem.price?.toString() || null;
+      return {
+        ...lineItem,
+        price: priceId,
+        checkout_session: checkoutSessionId
+      };
+    });
+    await this.postgresClient.upsertManyWithTimestampProtection(
+      modifiedLineItems,
+      "checkout_session_line_items",
+      checkoutSessionLineItemSchema,
+      syncTimestamp
+    );
+  }
+  async markDeletedSubscriptionItems(subscriptionId, currentSubItemIds) {
+    let prepared = sql2(`
+    select id from "${this.config.schema}"."subscription_items"
+    where subscription = :subscriptionId and deleted = false;
+    `)({ subscriptionId });
+    const { rows } = await this.postgresClient.query(prepared.text, prepared.values);
+    const deletedIds = rows.filter(
+      ({ id }) => currentSubItemIds.includes(id) === false
+    );
+    if (deletedIds.length > 0) {
+      const ids = deletedIds.map(({ id }) => id);
+      prepared = sql2(`
+      update "${this.config.schema}"."subscription_items"
+      set deleted = true where id=any(:ids::text[]);
+      `)({ ids });
+      const { rowCount } = await await this.postgresClient.query(prepared.text, prepared.values);
+      return { rowCount: rowCount || 0 };
+    } else {
+      return { rowCount: 0 };
+    }
+  }
+  async upsertSubscriptionSchedules(subscriptionSchedules, backfillRelatedEntities, syncTimestamp) {
+    if (backfillRelatedEntities ?? this.config.backfillRelatedEntities) {
+      const customerIds = getUniqueIds(subscriptionSchedules, "customer");
+      await this.backfillCustomers(customerIds);
+    }
+    const rows = await this.postgresClient.upsertManyWithTimestampProtection(
+      subscriptionSchedules,
+      "subscription_schedules",
+      subscriptionScheduleSchema,
+      syncTimestamp
+    );
+    return rows;
+  }
+  async upsertSubscriptions(subscriptions, backfillRelatedEntities, syncTimestamp) {
+    if (backfillRelatedEntities ?? this.config.backfillRelatedEntities) {
+      const customerIds = getUniqueIds(subscriptions, "customer");
+      await this.backfillCustomers(customerIds);
+    }
+    await this.expandEntity(
+      subscriptions,
+      "items",
+      (id) => this.stripe.subscriptionItems.list({ subscription: id, limit: 100 })
+    );
+    const rows = await this.postgresClient.upsertManyWithTimestampProtection(
+      subscriptions,
+      "subscriptions",
+      subscriptionSchema,
+      syncTimestamp
+    );
+    const allSubscriptionItems = subscriptions.flatMap((subscription) => subscription.items.data);
+    await this.upsertSubscriptionItems(allSubscriptionItems, syncTimestamp);
+    const markSubscriptionItemsDeleted = [];
+    for (const subscription of subscriptions) {
+      const subscriptionItems = subscription.items.data;
+      const subItemIds = subscriptionItems.map((x) => x.id);
+      markSubscriptionItemsDeleted.push(
+        this.markDeletedSubscriptionItems(subscription.id, subItemIds)
+      );
+    }
+    await Promise.all(markSubscriptionItemsDeleted);
+    return rows;
+  }
+  async deleteRemovedActiveEntitlements(customerId, currentActiveEntitlementIds) {
+    const prepared = sql2(`
+      delete from "${this.config.schema}"."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) {
+    return this.postgresClient.upsertManyWithTimestampProtection(
+      features,
+      "features",
+      featureSchema,
+      syncTimestamp
+    );
+  }
+  async backfillFeatures(featureIds) {
+    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) => {
+      this.config.logger?.error(err, "Failed to backfill features");
+      throw err;
+    });
+  }
+  async upsertActiveEntitlements(customerId, activeEntitlements, backfillRelatedEntities, syncTimestamp) {
+    if (backfillRelatedEntities ?? this.config.backfillRelatedEntities) {
+      await Promise.all([
+        this.backfillCustomers(getUniqueIds(activeEntitlements, "customer")),
+        this.backfillFeatures(getUniqueIds(activeEntitlements, "feature"))
+      ]);
+    }
+    const entitlements = activeEntitlements.map((entitlement) => ({
+      id: entitlement.id,
+      object: entitlement.object,
+      feature: typeof entitlement.feature === "string" ? entitlement.feature : entitlement.feature.id,
+      customer: customerId,
+      livemode: entitlement.livemode,
+      lookup_key: entitlement.lookup_key
+    }));
+    return this.postgresClient.upsertManyWithTimestampProtection(
+      entitlements,
+      "active_entitlements",
+      activeEntitlementSchema,
+      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 getManagedWebhook(id) {
+    const result = await this.postgresClient.query(
+      `SELECT * FROM "${this.config.schema || DEFAULT_SCHEMA}"."managed_webhooks" WHERE id = $1`,
+      [id]
+    );
+    return result.rows.length > 0 ? result.rows[0] : null;
+  }
+  async listManagedWebhooks() {
+    const result = await this.postgresClient.query(
+      `SELECT * FROM "${this.config.schema || DEFAULT_SCHEMA}"."managed_webhooks" ORDER BY created DESC`
+    );
+    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]);
+    return webhook;
+  }
+  async deleteManagedWebhook(id) {
+    await this.stripe.webhookEndpoints.del(id);
+    return this.postgresClient.delete("managed_webhooks", id);
+  }
+  async upsertManagedWebhooks(webhooks, syncTimestamp) {
+    return this.postgresClient.upsertManyWithTimestampProtection(
+      webhooks,
+      "managed_webhooks",
+      managedWebhookSchema,
+      syncTimestamp
+    );
+  }
+  async backfillSubscriptions(subscriptionIds) {
+    const missingSubscriptionIds = await this.postgresClient.findMissingEntries(
+      "subscriptions",
+      subscriptionIds
+    );
+    await this.fetchMissingEntities(
+      missingSubscriptionIds,
+      (id) => this.stripe.subscriptions.retrieve(id)
+    ).then((subscriptions) => this.upsertSubscriptions(subscriptions));
+  }
+  backfillSubscriptionSchedules = async (subscriptionIds) => {
+    const missingSubscriptionIds = await this.postgresClient.findMissingEntries(
+      "subscription_schedules",
+      subscriptionIds
+    );
+    await this.fetchMissingEntities(
+      missingSubscriptionIds,
+      (id) => this.stripe.subscriptionSchedules.retrieve(id)
+    ).then((subscriptionSchedules) => this.upsertSubscriptionSchedules(subscriptionSchedules));
+  };
+  /**
+   * Stripe only sends the first 10 entries by default, the option will actively fetch all entries.
+   */
+  async expandEntity(entities, property, listFn) {
+    if (!this.config.autoExpandLists) return;
+    for (const entity of entities) {
+      if (entity[property]?.has_more) {
+        const allData = [];
+        for await (const fetchedEntity of listFn(entity.id)) {
+          allData.push(fetchedEntity);
+        }
+        entity[property] = {
+          ...entity[property],
+          data: allData,
+          has_more: false
+        };
+      }
+    }
+  }
+  async fetchMissingEntities(ids, fetch) {
+    if (!ids.length) return [];
+    const entities = [];
+    for (const id of ids) {
+      const entity = await fetch(id);
+      entities.push(entity);
+    }
+    return entities;
+  }
+};
+function chunkArray(array, chunkSize) {
+  const result = [];
+  for (let i = 0; i < array.length; i += chunkSize) {
+    result.push(array.slice(i, i + chunkSize));
+  }
+  return result;
+}
+export {
+  PostgresClient,
+  StripeAutoSync
+};