stripe-experiment-sync 1.0.8 → 1.0.9-beta.1765909347

package/dist/{chunk-J7BH3XD6.js → chunk-2CYYWBTD.js}

@@ -1,16 +1,62 @@
 import {
   package_default
-} from "./chunk-CKWVW2JK.js";
+} from "./chunk-3W3CERIG.js";
 
 // src/stripeSync.ts
-import Stripe2 from "stripe";
+import Stripe3 from "stripe";
 import { pg as sql2 } from "yesql";
 
 // src/database/postgres.ts
 import pg from "pg";
 import { pg as sql } from "yesql";
+
+// src/database/QueryUtils.ts
+var QueryUtils = class _QueryUtils {
+  constructor() {
+  }
+  static quoteIdent(name) {
+    return `"${name}"`;
+  }
+  static quotedList(names) {
+    return names.map(_QueryUtils.quoteIdent).join(", ");
+  }
+  static buildInsertParts(columns) {
+    const columnsSql = columns.map((c) => _QueryUtils.quoteIdent(c.column)).join(", ");
+    const valuesSql = columns.map((c, i) => {
+      const placeholder = `$${i + 1}`;
+      return `${placeholder}::${c.pgType}`;
+    }).join(", ");
+    const params = columns.map((c) => c.value);
+    return { columnsSql, valuesSql, params };
+  }
+  static buildRawJsonUpsertQuery(schema, table, columns, conflictTarget) {
+    const { columnsSql, valuesSql, params } = _QueryUtils.buildInsertParts(columns);
+    const conflictSql = _QueryUtils.quotedList(conflictTarget);
+    const tsParamIdx = columns.findIndex((c) => c.column === "_last_synced_at") + 1;
+    if (tsParamIdx <= 0) {
+      throw new Error("buildRawJsonUpsertQuery requires _last_synced_at column");
+    }
+    const sql3 = `
+    INSERT INTO ${_QueryUtils.quoteIdent(schema)}.${_QueryUtils.quoteIdent(table)} (${columnsSql})
+    VALUES (${valuesSql})
+    ON CONFLICT (${conflictSql})
+    DO UPDATE SET
+      "_raw_data" = EXCLUDED."_raw_data",
+      "_last_synced_at" = $${tsParamIdx},
+      "_account_id" = EXCLUDED."_account_id"
+    WHERE ${_QueryUtils.quoteIdent(table)}."_last_synced_at" IS NULL
+       OR ${_QueryUtils.quoteIdent(table)}."_last_synced_at" < $${tsParamIdx}
+    RETURNING *
+  `;
+    return { sql: sql3, params };
+  }
+};
+
+// src/database/postgres.ts
 var ORDERED_STRIPE_TABLES = [
+  "exchange_rates_from_usd",
   "subscription_items",
+  "subscription_item_change_events_v2_beta",
   "subscriptions",
   "subscription_schedules",
   "checkout_session_line_items",
@@ -80,7 +126,7 @@ var PostgresClient = class {
     }
     return results.flatMap((it) => it.rows);
   }
-  async upsertManyWithTimestampProtection(entries, table, accountId, syncTimestamp) {
+  async upsertManyWithTimestampProtection(entries, table, accountId, syncTimestamp, upsertOptions) {
     const timestamp = syncTimestamp || (/* @__PURE__ */ new Date()).toISOString();
     if (!entries.length) return [];
     const chunkSize = 5;
@@ -115,20 +161,33 @@ var PostgresClient = class {
           const prepared = sql(upsertSql, { useNullForMissing: true })(cleansed);
           queries.push(this.pool.query(prepared.text, prepared.values));
         } else {
-          const rawData = JSON.stringify(entry);
-          const upsertSql = `
-            INSERT INTO "${this.config.schema}"."${table}" ("_raw_data", "_last_synced_at", "_account_id")
-            VALUES ($1::jsonb, $2, $3)
-            ON CONFLICT (id)
-            DO UPDATE SET
-              "_raw_data" = EXCLUDED."_raw_data",
-              "_last_synced_at" = $2,
-              "_account_id" = EXCLUDED."_account_id"
-            WHERE "${table}"."_last_synced_at" IS NULL
-               OR "${table}"."_last_synced_at" < $2
-            RETURNING *
-          `;
-          queries.push(this.pool.query(upsertSql, [rawData, timestamp, accountId]));
+          const conflictTarget = upsertOptions?.conflictTarget ?? ["id"];
+          const extraColumns = upsertOptions?.extraColumns ?? [];
+          if (!conflictTarget.length) {
+            throw new Error(`Invalid upsert config for ${table}: conflictTarget must be non-empty`);
+          }
+          const columns = [
+            { column: "_raw_data", pgType: "jsonb", value: JSON.stringify(entry) },
+            ...extraColumns.map((c) => ({
+              column: c.column,
+              pgType: c.pgType,
+              value: entry[c.entryKey]
+            })),
+            { column: "_last_synced_at", pgType: "timestamptz", value: timestamp },
+            { column: "_account_id", pgType: "text", value: accountId }
+          ];
+          for (const c of columns) {
+            if (c.value === void 0) {
+              throw new Error(`Missing required value for ${table}.${c.column}`);
+            }
+          }
+          const { sql: upsertSql, params } = QueryUtils.buildRawJsonUpsertQuery(
+            this.config.schema,
+            table,
+            columns,
+            conflictTarget
+          );
+          queries.push(this.pool.query(upsertSql, params));
         }
       });
       results.push(...await Promise.all(queries));
@@ -528,7 +587,12 @@ var PostgresClient = class {
     } else {
       await this.query(
         `UPDATE "${this.config.schema}"."_sync_obj_runs"
-         SET cursor = $4, updated_at = now()
+         SET cursor = CASE
+           WHEN cursor IS NULL THEN $4
+           WHEN (cursor COLLATE "C") < ($4::text COLLATE "C") THEN $4
+           ELSE cursor
+         END,
+         updated_at = now()
          WHERE "_account_id" = $1 AND run_started_at = $2 AND object = $3`,
         [accountId, runStartedAt, object, cursor]
       );
@@ -539,10 +603,17 @@ var PostgresClient = class {
    * 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.
+   *
+   * Handles two cursor formats:
+   * - Numeric: compared as bigint for correct ordering
+   * - Composite cursors: compared as strings with COLLATE "C"
    */
   async getLastCompletedCursor(accountId, object) {
     const result = await this.query(
-      `SELECT MAX(o.cursor::bigint)::text as cursor
+      `SELECT CASE
+         WHEN BOOL_OR(o.cursor !~ '^\\d+$') THEN MAX(o.cursor COLLATE "C")
+         ELSE MAX(CASE WHEN o.cursor ~ '^\\d+$' THEN o.cursor::bigint END)::text
+       END as cursor
        FROM "${this.config.schema}"."_sync_obj_runs" o
        WHERE o."_account_id" = $1
          AND o.object = $2
@@ -827,6 +898,269 @@ function hashApiKey(apiKey) {
   return createHash("sha256").update(apiKey).digest("hex");
 }
 
+// src/sigma/sigmaApi.ts
+import Papa from "papaparse";
+import Stripe2 from "stripe";
+var STRIPE_FILES_BASE = "https://files.stripe.com/v1";
+function sleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function parseCsvObjects(csv) {
+  const input = csv.replace(/^\uFEFF/, "");
+  const parsed = Papa.parse(input, {
+    header: true,
+    skipEmptyLines: "greedy"
+  });
+  if (parsed.errors.length > 0) {
+    throw new Error(`Failed to parse Sigma CSV: ${parsed.errors[0]?.message ?? "unknown error"}`);
+  }
+  return parsed.data.filter((row) => row && Object.keys(row).length > 0).map(
+    (row) => Object.fromEntries(
+      Object.entries(row).map(([k, v]) => [k, v == null || v === "" ? null : String(v)])
+    )
+  );
+}
+function normalizeSigmaTimestampToIso(value) {
+  const v = value.trim();
+  if (!v) return null;
+  const hasExplicitTz = /z$|[+-]\d{2}:?\d{2}$/i.test(v);
+  const isoish = v.includes("T") ? v : v.replace(" ", "T");
+  const candidate = hasExplicitTz ? isoish : `${isoish}Z`;
+  const d = new Date(candidate);
+  if (Number.isNaN(d.getTime())) return null;
+  return d.toISOString();
+}
+async function fetchStripeText(url, apiKey, options) {
+  const res = await fetch(url, {
+    ...options,
+    headers: {
+      ...options.headers ?? {},
+      Authorization: `Bearer ${apiKey}`
+    }
+  });
+  const text = await res.text();
+  if (!res.ok) {
+    throw new Error(`Sigma file download error (${res.status}) for ${url}: ${text}`);
+  }
+  return text;
+}
+async function runSigmaQueryAndDownloadCsv(params) {
+  const pollTimeoutMs = params.pollTimeoutMs ?? 5 * 60 * 1e3;
+  const pollIntervalMs = params.pollIntervalMs ?? 2e3;
+  const stripe = new Stripe2(params.apiKey);
+  const created = await stripe.rawRequest("POST", "/v1/sigma/query_runs", {
+    sql: params.sql
+  });
+  const queryRunId = created.id;
+  const start = Date.now();
+  let current = created;
+  while (current.status === "running") {
+    if (Date.now() - start > pollTimeoutMs) {
+      throw new Error(`Sigma query run timed out after ${pollTimeoutMs}ms: ${queryRunId}`);
+    }
+    await sleep2(pollIntervalMs);
+    current = await stripe.rawRequest(
+      "GET",
+      `/v1/sigma/query_runs/${queryRunId}`,
+      {}
+    );
+  }
+  if (current.status !== "succeeded") {
+    throw new Error(
+      `Sigma query run did not succeed (status=${current.status}) id=${queryRunId} error=${JSON.stringify(
+        current.error
+      )}`
+    );
+  }
+  const fileId = current.result?.file;
+  if (!fileId) {
+    throw new Error(`Sigma query run succeeded but result.file is missing (id=${queryRunId})`);
+  }
+  const csv = await fetchStripeText(
+    `${STRIPE_FILES_BASE}/files/${fileId}/contents`,
+    params.apiKey,
+    { method: "GET" }
+  );
+  return { queryRunId, fileId, csv };
+}
+
+// src/sigma/sigmaIngestionConfigs.ts
+var SIGMA_INGESTION_CONFIGS = {
+  subscription_item_change_events_v2_beta: {
+    sigmaTable: "subscription_item_change_events_v2_beta",
+    destinationTable: "subscription_item_change_events_v2_beta",
+    pageSize: 1e4,
+    cursor: {
+      version: 1,
+      columns: [
+        { column: "event_timestamp", type: "timestamp" },
+        { column: "event_type", type: "string" },
+        { column: "subscription_item_id", type: "string" }
+      ]
+    },
+    upsert: {
+      conflictTarget: ["_account_id", "event_timestamp", "event_type", "subscription_item_id"],
+      extraColumns: [
+        { column: "event_timestamp", pgType: "timestamptz", entryKey: "event_timestamp" },
+        { column: "event_type", pgType: "text", entryKey: "event_type" },
+        { column: "subscription_item_id", pgType: "text", entryKey: "subscription_item_id" }
+      ]
+    }
+  },
+  exchange_rates_from_usd: {
+    sigmaTable: "exchange_rates_from_usd",
+    destinationTable: "exchange_rates_from_usd",
+    pageSize: 1e4,
+    cursor: {
+      version: 1,
+      columns: [
+        { column: "date", type: "string" },
+        { column: "sell_currency", type: "string" }
+      ]
+    },
+    upsert: {
+      conflictTarget: ["_account_id", "date", "sell_currency"],
+      extraColumns: [
+        { column: "date", pgType: "date", entryKey: "date" },
+        { column: "sell_currency", pgType: "text", entryKey: "sell_currency" }
+      ]
+    }
+  }
+};
+
+// src/sigma/sigmaIngestion.ts
+var SIGMA_CURSOR_DELIM = "";
+function escapeSigmaSqlStringLiteral(value) {
+  return value.replace(/'/g, "''");
+}
+function formatSigmaTimestampForSqlLiteral(date) {
+  return date.toISOString().replace("T", " ").replace("Z", "");
+}
+function decodeSigmaCursorValues(spec, cursor) {
+  const prefix = `v${spec.version}${SIGMA_CURSOR_DELIM}`;
+  if (!cursor.startsWith(prefix)) {
+    throw new Error(
+      `Unrecognized Sigma cursor format (expected prefix ${JSON.stringify(prefix)}): ${cursor}`
+    );
+  }
+  const parts = cursor.split(SIGMA_CURSOR_DELIM);
+  const expected = 1 + spec.columns.length;
+  if (parts.length !== expected) {
+    throw new Error(`Malformed Sigma cursor: expected ${expected} parts, got ${parts.length}`);
+  }
+  return parts.slice(1);
+}
+function encodeSigmaCursor(spec, values) {
+  if (values.length !== spec.columns.length) {
+    throw new Error(
+      `Cannot encode Sigma cursor: expected ${spec.columns.length} values, got ${values.length}`
+    );
+  }
+  for (const v of values) {
+    if (v.includes(SIGMA_CURSOR_DELIM)) {
+      throw new Error("Cannot encode Sigma cursor: value contains delimiter character");
+    }
+  }
+  return [`v${spec.version}`, ...values].join(SIGMA_CURSOR_DELIM);
+}
+function sigmaSqlLiteralForCursorValue(spec, rawValue) {
+  switch (spec.type) {
+    case "timestamp": {
+      const d = new Date(rawValue);
+      if (Number.isNaN(d.getTime())) {
+        throw new Error(`Invalid timestamp cursor value for ${spec.column}: ${rawValue}`);
+      }
+      return `timestamp '${formatSigmaTimestampForSqlLiteral(d)}'`;
+    }
+    case "number": {
+      if (!/^-?\d+(\.\d+)?$/.test(rawValue)) {
+        throw new Error(`Invalid numeric cursor value for ${spec.column}: ${rawValue}`);
+      }
+      return rawValue;
+    }
+    case "string":
+      return `'${escapeSigmaSqlStringLiteral(rawValue)}'`;
+  }
+}
+function buildSigmaCursorWhereClause(spec, cursorValues) {
+  if (cursorValues.length !== spec.columns.length) {
+    throw new Error(
+      `Cannot build Sigma cursor predicate: expected ${spec.columns.length} values, got ${cursorValues.length}`
+    );
+  }
+  const cols = spec.columns.map((c) => c.column);
+  const lits = spec.columns.map((c, i) => sigmaSqlLiteralForCursorValue(c, cursorValues[i] ?? ""));
+  const ors = [];
+  for (let i = 0; i < cols.length; i++) {
+    const ands = [];
+    for (let j = 0; j < i; j++) {
+      ands.push(`${cols[j]} = ${lits[j]}`);
+    }
+    ands.push(`${cols[i]} > ${lits[i]}`);
+    ors.push(`(${ands.join(" AND ")})`);
+  }
+  return ors.join(" OR ");
+}
+function buildSigmaQuery(config, cursor) {
+  const select = config.select === void 0 || config.select === "*" ? "*" : config.select.join(", ");
+  const whereParts = [];
+  if (config.additionalWhere) {
+    whereParts.push(`(${config.additionalWhere})`);
+  }
+  if (cursor) {
+    const values = decodeSigmaCursorValues(config.cursor, cursor);
+    const predicate = buildSigmaCursorWhereClause(config.cursor, values);
+    whereParts.push(`(${predicate})`);
+  }
+  const whereClause = whereParts.length > 0 ? `WHERE ${whereParts.join(" AND ")}` : "";
+  const orderBy = config.cursor.columns.map((c) => c.column).join(", ");
+  return [
+    `SELECT ${select} FROM ${config.sigmaTable}`,
+    whereClause,
+    `ORDER BY ${orderBy} ASC`,
+    `LIMIT ${config.pageSize}`
+  ].filter(Boolean).join(" ");
+}
+function defaultSigmaRowToEntry(config, row) {
+  const out = { ...row };
+  for (const col of config.cursor.columns) {
+    const raw = row[col.column];
+    if (raw == null) {
+      throw new Error(`Sigma row missing required cursor column: ${col.column}`);
+    }
+    if (col.type === "timestamp") {
+      const normalized = normalizeSigmaTimestampToIso(raw);
+      if (!normalized) {
+        throw new Error(`Sigma row has invalid timestamp for ${col.column}: ${raw}`);
+      }
+      out[col.column] = normalized;
+    } else if (col.type === "string") {
+      const v = raw.trim();
+      if (!v) {
+        throw new Error(`Sigma row has empty string for required cursor column: ${col.column}`);
+      }
+      out[col.column] = v;
+    } else {
+      const v = raw.trim();
+      if (!v) {
+        throw new Error(`Sigma row has empty value for required cursor column: ${col.column}`);
+      }
+      out[col.column] = v;
+    }
+  }
+  return out;
+}
+function sigmaCursorFromEntry(config, entry) {
+  const values = config.cursor.columns.map((c) => {
+    const raw = entry[c.column];
+    if (raw == null) {
+      throw new Error(`Cannot build cursor: entry missing ${c.column}`);
+    }
+    return String(raw);
+  });
+  return encodeSigmaCursor(config.cursor, values);
+}
+
 // src/stripeSync.ts
 function getUniqueIds(entries, key) {
   const set = new Set(
@@ -837,7 +1171,7 @@ function getUniqueIds(entries, key) {
 var StripeSync = class {
   constructor(config) {
     this.config = config;
-    const baseStripe = new Stripe2(config.stripeSecretKey, {
+    const baseStripe = new Stripe3(config.stripeSecretKey, {
       // https://github.com/stripe/stripe-node#configuration
       // @ts-ignore
       apiVersion: config.stripeApiVersion,
@@ -1238,6 +1572,17 @@ var StripeSync = class {
       listFn: (p) => this.stripe.checkout.sessions.list(p),
       upsertFn: (items, id) => this.upsertCheckoutSessions(items, id),
       supportsCreatedFilter: true
+    },
+    // Sigma-backed resources
+    subscription_item_change_events_v2_beta: {
+      order: 18,
+      supportsCreatedFilter: false,
+      sigma: SIGMA_INGESTION_CONFIGS.subscription_item_change_events_v2_beta
+    },
+    exchange_rates_from_usd: {
+      order: 19,
+      supportsCreatedFilter: false,
+      sigma: SIGMA_INGESTION_CONFIGS.exchange_rates_from_usd
     }
   };
   async processEvent(event) {
@@ -1270,7 +1615,13 @@ var StripeSync = class {
    * 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);
+    const all = Object.entries(this.resourceRegistry).sort(([, a], [, b]) => a.order - b.order).map(([key]) => key);
+    if (!this.config.enableSigmaSync) {
+      return all.filter(
+        (o) => o !== "subscription_item_change_events_v2_beta" && o !== "exchange_rates_from_usd"
+      );
+    }
+    return all;
   }
   // Event handler methods
   async handleChargeEvent(event, accountId) {
@@ -1349,7 +1700,7 @@ var StripeSync = class {
       );
       await this.upsertProducts([product], accountId, this.getSyncTimestamp(event, refetched));
     } catch (err) {
-      if (err instanceof Stripe2.errors.StripeAPIError && err.code === "resource_missing") {
+      if (err instanceof Stripe3.errors.StripeAPIError && err.code === "resource_missing") {
         const product = event.data.object;
         await this.deleteProduct(product.id);
       } else {
@@ -1369,7 +1720,7 @@ var StripeSync = class {
       );
       await this.upsertPrices([price], accountId, false, this.getSyncTimestamp(event, refetched));
     } catch (err) {
-      if (err instanceof Stripe2.errors.StripeAPIError && err.code === "resource_missing") {
+      if (err instanceof Stripe3.errors.StripeAPIError && err.code === "resource_missing") {
         const price = event.data.object;
         await this.deletePrice(price.id);
       } else {
@@ -1389,7 +1740,7 @@ var StripeSync = class {
       );
       await this.upsertPlans([plan], accountId, false, this.getSyncTimestamp(event, refetched));
     } catch (err) {
-      if (err instanceof Stripe2.errors.StripeAPIError && err.code === "resource_missing") {
+      if (err instanceof Stripe3.errors.StripeAPIError && err.code === "resource_missing") {
         const plan = event.data.object;
         await this.deletePlan(plan.id);
       } else {
@@ -1636,10 +1987,10 @@ var StripeSync = class {
     let cursor = null;
     if (!params?.created) {
       if (objRun?.cursor) {
-        cursor = parseInt(objRun.cursor);
+        cursor = objRun.cursor;
       } else {
         const lastCursor = await this.postgresClient.getLastCompletedCursor(accountId, resourceName);
-        cursor = lastCursor ? parseInt(lastCursor) : null;
+        cursor = lastCursor ?? null;
       }
     }
     const result = await this.fetchOnePage(
@@ -1694,9 +2045,18 @@ var StripeSync = class {
       throw new Error(`Unsupported object type for processNext: ${object}`);
     }
     try {
+      if (config.sigma) {
+        return await this.fetchOneSigmaPage(
+          accountId,
+          resourceName,
+          runStartedAt,
+          cursor,
+          config.sigma
+        );
+      }
       const listParams = { limit };
       if (config.supportsCreatedFilter) {
-        const created = params?.created ?? (cursor ? { gte: cursor } : void 0);
+        const created = params?.created ?? (cursor && /^\d+$/.test(cursor) ? { gte: Number.parseInt(cursor, 10) } : void 0);
         if (created) {
           listParams.created = created;
         }
@@ -1741,6 +2101,97 @@ var StripeSync = class {
       throw error;
     }
   }
+  async getSigmaFallbackCursorFromDestination(accountId, sigmaConfig) {
+    const cursorCols = sigmaConfig.cursor.columns;
+    const selectCols = cursorCols.map((c) => `"${c.column}"`).join(", ");
+    const orderBy = cursorCols.map((c) => `"${c.column}" DESC`).join(", ");
+    const result = await this.postgresClient.query(
+      `SELECT ${selectCols}
+       FROM "stripe"."${sigmaConfig.destinationTable}"
+       WHERE "_account_id" = $1
+       ORDER BY ${orderBy}
+       LIMIT 1`,
+      [accountId]
+    );
+    if (result.rows.length === 0) return null;
+    const row = result.rows[0];
+    const entryForCursor = {};
+    for (const c of cursorCols) {
+      const v = row[c.column];
+      if (v == null) {
+        throw new Error(
+          `Sigma fallback cursor query returned null for ${sigmaConfig.destinationTable}.${c.column}`
+        );
+      }
+      if (c.type === "timestamp") {
+        const d = v instanceof Date ? v : new Date(String(v));
+        if (Number.isNaN(d.getTime())) {
+          throw new Error(
+            `Sigma fallback cursor query returned invalid timestamp for ${sigmaConfig.destinationTable}.${c.column}: ${String(
+              v
+            )}`
+          );
+        }
+        entryForCursor[c.column] = d.toISOString();
+      } else {
+        entryForCursor[c.column] = String(v);
+      }
+    }
+    return sigmaCursorFromEntry(sigmaConfig, entryForCursor);
+  }
+  async fetchOneSigmaPage(accountId, resourceName, runStartedAt, cursor, sigmaConfig) {
+    if (!this.config.stripeSecretKey) {
+      throw new Error("Sigma sync requested but stripeSecretKey is not configured.");
+    }
+    if (resourceName !== sigmaConfig.destinationTable) {
+      throw new Error(
+        `Sigma sync config mismatch: resourceName=${resourceName} destinationTable=${sigmaConfig.destinationTable}`
+      );
+    }
+    const effectiveCursor = cursor ?? await this.getSigmaFallbackCursorFromDestination(accountId, sigmaConfig);
+    const sigmaSql = buildSigmaQuery(sigmaConfig, effectiveCursor);
+    this.config.logger?.info(
+      { object: resourceName, pageSize: sigmaConfig.pageSize, hasCursor: Boolean(effectiveCursor) },
+      "Sigma sync: running query"
+    );
+    const { queryRunId, fileId, csv } = await runSigmaQueryAndDownloadCsv({
+      apiKey: this.config.stripeSecretKey,
+      sql: sigmaSql,
+      logger: this.config.logger
+    });
+    const rows = parseCsvObjects(csv);
+    if (rows.length === 0) {
+      await this.postgresClient.completeObjectSync(accountId, runStartedAt, resourceName);
+      return { processed: 0, hasMore: false, runStartedAt };
+    }
+    const entries = rows.map(
+      (row) => defaultSigmaRowToEntry(sigmaConfig, row)
+    );
+    this.config.logger?.info(
+      { object: resourceName, rows: entries.length, queryRunId, fileId },
+      "Sigma sync: upserting rows"
+    );
+    await this.postgresClient.upsertManyWithTimestampProtection(
+      entries,
+      resourceName,
+      accountId,
+      void 0,
+      sigmaConfig.upsert
+    );
+    await this.postgresClient.incrementObjectProgress(
+      accountId,
+      runStartedAt,
+      resourceName,
+      entries.length
+    );
+    const newCursor = sigmaCursorFromEntry(sigmaConfig, entries[entries.length - 1]);
+    await this.postgresClient.updateObjectCursor(accountId, runStartedAt, resourceName, newCursor);
+    const hasMore = rows.length === sigmaConfig.pageSize;
+    if (!hasMore) {
+      await this.postgresClient.completeObjectSync(accountId, runStartedAt, resourceName);
+    }
+    return { processed: entries.length, hasMore, runStartedAt };
+  }
   /**
    * Process all pages for all (or specified) object types until complete.
    *
@@ -1869,6 +2320,12 @@ var StripeSync = class {
             case "checkout_sessions":
               results.checkoutSessions = result;
               break;
+            case "subscription_item_change_events_v2_beta":
+              results.subscriptionItemChangeEventsV2Beta = result;
+              break;
+            case "exchange_rates_from_usd":
+              results.exchangeRatesFromUsd = result;
+              break;
           }
         }
       }
@@ -3429,6 +3886,8 @@ var VERSION = package_default.version;
 export {
   PostgresClient,
   hashApiKey,
+  parseCsvObjects,
+  normalizeSigmaTimestampToIso,
   StripeSync,
   runMigrations,
   createStripeWebSocketClient,

package/dist/{chunk-CKWVW2JK.js → chunk-3W3CERIG.js}

@@ -1,7 +1,7 @@
 // package.json
 var package_default = {
   name: "stripe-experiment-sync",
-  version: "1.0.8-beta.1765856228",
+  version: "1.0.9-beta.1765909347",
   private: false,
   description: "Stripe Sync Engine to sync Stripe data to Postgres",
   type: "module",
@@ -41,6 +41,7 @@ var package_default = {
     dotenv: "^16.4.7",
     express: "^4.18.2",
     inquirer: "^12.3.0",
+    papaparse: "5.4.1",
     pg: "^8.16.3",
     "pg-node-migrations": "0.0.8",
     stripe: "^17.7.0",
@@ -52,6 +53,7 @@ var package_default = {
     "@types/express": "^4.17.21",
     "@types/inquirer": "^9.0.7",
     "@types/node": "^24.10.1",
+    "@types/papaparse": "5.3.16",
     "@types/pg": "^8.15.5",
     "@types/ws": "^8.5.13",
     "@types/yesql": "^4.1.4",