stripe-experiment-sync 1.0.0 → 1.0.2

package/dist/index.d.ts

@@ -1,29 +1,17 @@
 import Stripe from 'stripe';
-import { D as DatabaseAdapter } from './adapter-BtXT5w9r.js';
-export { P as PgCompatibleClient } from './adapter-BtXT5w9r.js';
+import pg, { PoolConfig, QueryResult } from 'pg';
+import { ConnectionOptions } from 'node:tls';
 
 type PostgresConfig = {
     schema: string;
-    adapter: DatabaseAdapter;
+    poolConfig: PoolConfig;
 };
 declare class PostgresClient {
     private config;
-    private adapter;
+    pool: pg.Pool;
     constructor(config: PostgresConfig);
-    /**
-     * Get the underlying adapter.
-     * Useful for accessing adapter-specific features.
-     */
-    getAdapter(): DatabaseAdapter;
-    /**
-     * Close all database connections.
-     */
-    end(): Promise<void>;
     delete(table: string, id: string): Promise<boolean>;
-    query<T = any>(text: string, params?: any[]): Promise<{
-        rows: T[];
-        rowCount: number;
-    }>;
+    query(text: string, params?: any[]): Promise<QueryResult>;
     upsertMany<T extends {
         [Key: string]: any;
     }>(entries: T[], table: string): Promise<T[]>;
@@ -80,6 +68,10 @@ declare class PostgresClient {
      * Execute a function while holding an advisory lock.
      * The lock is automatically released after the function completes (success or error).
      *
+     * IMPORTANT: This acquires a dedicated connection from the pool and holds it for the
+     * duration of the function execution. PostgreSQL advisory locks are session-level,
+     * so we must use the same connection for lock acquisition, operations, and release.
+     *
      * @param key - A string key to lock on (will be hashed to an integer)
      * @param fn - The function to execute while holding the lock
      * @returns The result of the function
@@ -112,22 +104,20 @@ declare class PostgresClient {
         runStartedAt: Date;
     } | null>;
     /**
-     * Get full sync run details.
+     * Get sync run config (for concurrency control).
+     * Status is derived from sync_dashboard view.
      */
     getSyncRun(accountId: string, runStartedAt: Date): Promise<{
         accountId: string;
         runStartedAt: Date;
-        status: string;
         maxConcurrent: number;
+        closedAt: Date | null;
     } | null>;
     /**
-     * Mark a sync run as complete.
+     * Close a sync run (mark as done).
+     * Status (complete/error) is derived from object run states.
      */
-    completeSyncRun(accountId: string, runStartedAt: Date): Promise<void>;
-    /**
-     * Mark a sync run as failed.
-     */
-    failSyncRun(accountId: string, runStartedAt: Date, errorMessage: string): Promise<void>;
+    closeSyncRun(accountId: string, runStartedAt: Date): Promise<void>;
     /**
      * Create object run entries for a sync run.
      * All objects start as 'pending'.
@@ -176,12 +166,18 @@ declare class PostgresClient {
     deleteSyncRuns(accountId: string): Promise<void>;
     /**
      * Mark an object sync as complete.
+     * Auto-closes the run when all objects are done.
      */
     completeObjectSync(accountId: string, runStartedAt: Date, object: string): Promise<void>;
     /**
      * Mark an object sync as failed.
+     * Auto-closes the run when all objects are done.
      */
     failObjectSync(accountId: string, runStartedAt: Date, object: string, errorMessage: string): Promise<void>;
+    /**
+     * Check if any object in a run has errored.
+     */
+    hasAnyObjectErrors(accountId: string, runStartedAt: Date): Promise<boolean>;
     /**
      * Count running objects in a run.
      */
@@ -233,11 +229,9 @@ type StripeSyncConfig = {
      * Default: false
      */
     revalidateObjectsViaStripeApi?: Array<RevalidateEntity>;
-    /**
-     * Database adapter for database operations.
-     * Use PgAdapter for Node.js or a custom adapter for other environments (e.g., Deno).
-     */
-    adapter: DatabaseAdapter;
+    /** @deprecated Use `poolConfig` instead. */
+    maxPostgresConnections?: number;
+    poolConfig: PoolConfig;
     logger?: Logger;
     /**
      * Maximum number of retry attempts for 429 rate limit errors.
@@ -579,6 +573,13 @@ declare class StripeSync {
     private fetchMissingEntities;
 }
 
+type MigrationConfig = {
+    databaseUrl: string;
+    ssl?: ConnectionOptions;
+    logger?: Logger;
+};
+declare function runMigrations(config: MigrationConfig): Promise<void>;
+
 /**
  * Hashes a Stripe API key using SHA-256
  * Used to store API key hashes in the database for fast account lookups
@@ -589,14 +590,6 @@ declare class StripeSync {
  */
 declare function hashApiKey(apiKey: string): string;
 
-/**
- * Run database migrations using the provided adapter.
- *
- * @param adapter - Database adapter (PgAdapter or PostgresJsAdapter)
- * @param logger - Optional logger for migration progress
- */
-declare function runMigrations(adapter: DatabaseAdapter, logger?: Logger): Promise<void>;
-
 declare const VERSION: string;
 
-export { DatabaseAdapter, type Logger, PostgresClient, type ProcessNextParams, type ProcessNextResult, type RevalidateEntity, StripeSync, type StripeSyncConfig, type Sync, type SyncBackfill, type SyncEntitlementsParams, type SyncFeaturesParams, type SyncObject, type SyncParams, VERSION, hashApiKey, runMigrations };
+export { type Logger, PostgresClient, type ProcessNextParams, type ProcessNextResult, type RevalidateEntity, StripeSync, type StripeSyncConfig, type Sync, type SyncBackfill, type SyncEntitlementsParams, type SyncFeaturesParams, type SyncObject, type SyncParams, VERSION, hashApiKey, runMigrations };

package/dist/index.js

@@ -1,47 +1,25 @@
 // package.json
 var package_default = {
   name: "stripe-experiment-sync",
-  version: "1.0.0",
+  version: "1.0.2",
   private: false,
   description: "Stripe Sync Engine to sync Stripe data to Postgres",
   type: "module",
   main: "./dist/index.cjs",
   exports: {
-    ".": {
-      import: {
-        types: "./dist/index.d.ts",
-        default: "./dist/index.js"
-      },
-      require: {
-        types: "./dist/index.d.cts",
-        default: "./dist/index.cjs"
-      }
-    },
-    "./pg": {
-      import: {
-        types: "./dist/pg.d.ts",
-        default: "./dist/pg.js"
-      },
-      require: {
-        types: "./dist/pg.d.cts",
-        default: "./dist/pg.cjs"
-      }
+    import: {
+      types: "./dist/index.d.ts",
+      import: "./dist/index.js"
     },
-    "./postgres-js": {
-      import: {
-        types: "./dist/postgres-js.d.ts",
-        default: "./dist/postgres-js.js"
-      },
-      require: {
-        types: "./dist/postgres-js.d.cts",
-        default: "./dist/postgres-js.cjs"
-      }
+    require: {
+      types: "./dist/index.d.cts",
+      require: "./dist/index.cjs"
     }
   },
   scripts: {
     clean: "rimraf dist",
     prebuild: "npm run clean",
-    build: "tsup src/index.ts src/pg.ts src/postgres-js.ts --format esm,cjs --dts --shims && cp -r src/database/migrations dist/migrations",
+    build: "tsup src/index.ts --format esm,cjs --dts --shims && cp -r src/database/migrations dist/migrations",
     lint: "eslint src --ext .ts",
     test: "vitest"
   },
@@ -51,7 +29,6 @@ var package_default = {
   dependencies: {
     pg: "^8.16.3",
     "pg-node-migrations": "0.0.8",
-    postgres: "^3.4.7",
     ws: "^8.18.0",
     yesql: "^7.0.0"
   },
@@ -64,7 +41,6 @@ var package_default = {
     "@types/ws": "^8.5.13",
     "@types/yesql": "^4.1.4",
     "@vitest/ui": "^4.0.9",
-    stripe: "^20.0.0",
     vitest: "^3.2.4"
   },
   repository: {
@@ -93,6 +69,7 @@ import Stripe2 from "stripe";
 import { pg as sql2 } from "yesql";
 
 // src/database/postgres.ts
+import pg from "pg";
 import { pg as sql } from "yesql";
 var ORDERED_STRIPE_TABLES = [
   "subscription_items",
@@ -126,22 +103,9 @@ var TABLES_WITH_ACCOUNT_ID = /* @__PURE__ */ new Set(["_managed_webhooks"]);
 var PostgresClient = class {
   constructor(config) {
     this.config = config;
-    this.adapter = config.adapter;
-  }
-  adapter;
-  /**
-   * Get the underlying adapter.
-   * Useful for accessing adapter-specific features.
-   */
-  getAdapter() {
-    return this.adapter;
-  }
-  /**
-   * Close all database connections.
-   */
-  async end() {
-    await this.adapter.end();
+    this.pool = new pg.Pool(config.poolConfig);
   }
+  pool;
   async delete(table, id) {
     const prepared = sql(`
     delete from "${this.config.schema}"."${table}"
@@ -153,7 +117,7 @@ var PostgresClient = class {
   }
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   async query(text, params) {
-    return this.adapter.query(text, params);
+    return this.pool.query(text, params);
   }
   async upsertMany(entries, table) {
     if (!entries.length) return [];
@@ -172,7 +136,7 @@ var PostgresClient = class {
             "_raw_data" = EXCLUDED."_raw_data"
           RETURNING *
         `;
-        queries.push(this.adapter.query(upsertSql, [rawData]));
+        queries.push(this.pool.query(upsertSql, [rawData]));
       });
       results.push(...await Promise.all(queries));
     }
@@ -211,7 +175,7 @@ var PostgresClient = class {
           cleansed.last_synced_at = timestamp;
           cleansed.account_id = accountId;
           const prepared = sql(upsertSql, { useNullForMissing: true })(cleansed);
-          queries.push(this.adapter.query(prepared.text, prepared.values));
+          queries.push(this.pool.query(prepared.text, prepared.values));
         } else {
           const rawData = JSON.stringify(entry);
           const upsertSql = `
@@ -226,7 +190,7 @@ var PostgresClient = class {
                OR "${table}"."_last_synced_at" < $2
             RETURNING *
           `;
-          queries.push(this.adapter.query(upsertSql, [rawData, timestamp, accountId]));
+          queries.push(this.pool.query(upsertSql, [rawData, timestamp, accountId]));
         }
       });
       results.push(...await Promise.all(queries));
@@ -398,13 +362,27 @@ var PostgresClient = class {
    * Execute a function while holding an advisory lock.
    * The lock is automatically released after the function completes (success or error).
    *
+   * IMPORTANT: This acquires a dedicated connection from the pool and holds it for the
+   * duration of the function execution. PostgreSQL advisory locks are session-level,
+   * so we must use the same connection for lock acquisition, operations, and release.
+   *
    * @param key - A string key to lock on (will be hashed to an integer)
    * @param fn - The function to execute while holding the lock
    * @returns The result of the function
    */
   async withAdvisoryLock(key, fn) {
     const lockId = this.hashToInt32(key);
-    return this.adapter.withAdvisoryLock(lockId, fn);
+    const client = await this.pool.connect();
+    try {
+      await client.query("SELECT pg_advisory_lock($1)", [lockId]);
+      return await fn();
+    } finally {
+      try {
+        await client.query("SELECT pg_advisory_unlock($1)", [lockId]);
+      } finally {
+        client.release();
+      }
+    }
   }
   // =============================================================================
   // Observable Sync System Methods
@@ -420,12 +398,20 @@ var PostgresClient = class {
    */
   async cancelStaleRuns(accountId) {
     await this.query(
-      `UPDATE "${this.config.schema}"."_sync_run" r
+      `UPDATE "${this.config.schema}"."_sync_obj_run" o
        SET status = 'error',
            error_message = 'Auto-cancelled: stale (no update in 5 min)',
            completed_at = now()
+       WHERE o."_account_id" = $1
+         AND o.status = 'running'
+         AND o.updated_at < now() - interval '5 minutes'`,
+      [accountId]
+    );
+    await this.query(
+      `UPDATE "${this.config.schema}"."_sync_run" r
+       SET closed_at = now()
        WHERE r."_account_id" = $1
-         AND r.status = 'running'
+         AND r.closed_at IS NULL
          AND EXISTS (
            SELECT 1 FROM "${this.config.schema}"."_sync_obj_run" o
            WHERE o."_account_id" = r."_account_id"
@@ -435,7 +421,7 @@ var PostgresClient = class {
            SELECT 1 FROM "${this.config.schema}"."_sync_obj_run" o
            WHERE o."_account_id" = r."_account_id"
              AND o.run_started_at = r.started_at
-             AND o.updated_at >= now() - interval '5 minutes'
+             AND o.status IN ('pending', 'running')
          )`,
       [accountId]
     );
@@ -451,7 +437,7 @@ var PostgresClient = class {
     await this.cancelStaleRuns(accountId);
     const existing = await this.query(
       `SELECT "_account_id", started_at FROM "${this.config.schema}"."_sync_run"
-       WHERE "_account_id" = $1 AND status = 'running'`,
+       WHERE "_account_id" = $1 AND closed_at IS NULL`,
       [accountId]
     );
     if (existing.rows.length > 0) {
@@ -480,7 +466,7 @@ var PostgresClient = class {
   async getActiveSyncRun(accountId) {
     const result = await this.query(
       `SELECT "_account_id", started_at FROM "${this.config.schema}"."_sync_run"
-       WHERE "_account_id" = $1 AND status = 'running'`,
+       WHERE "_account_id" = $1 AND closed_at IS NULL`,
       [accountId]
     );
     if (result.rows.length === 0) return null;
@@ -488,11 +474,12 @@ var PostgresClient = class {
     return { accountId: row._account_id, runStartedAt: row.started_at };
   }
   /**
-   * Get full sync run details.
+   * Get sync run config (for concurrency control).
+   * Status is derived from sync_dashboard view.
    */
   async getSyncRun(accountId, runStartedAt) {
     const result = await this.query(
-      `SELECT "_account_id", started_at, status, max_concurrent
+      `SELECT "_account_id", started_at, max_concurrent, closed_at
        FROM "${this.config.schema}"."_sync_run"
        WHERE "_account_id" = $1 AND started_at = $2`,
       [accountId, runStartedAt]
@@ -502,32 +489,22 @@ var PostgresClient = class {
     return {
       accountId: row._account_id,
       runStartedAt: row.started_at,
-      status: row.status,
-      maxConcurrent: row.max_concurrent
+      maxConcurrent: row.max_concurrent,
+      closedAt: row.closed_at
     };
   }
   /**
-   * Mark a sync run as complete.
+   * Close a sync run (mark as done).
+   * Status (complete/error) is derived from object run states.
    */
-  async completeSyncRun(accountId, runStartedAt) {
+  async closeSyncRun(accountId, runStartedAt) {
     await this.query(
       `UPDATE "${this.config.schema}"."_sync_run"
-       SET status = 'complete', completed_at = now()
-       WHERE "_account_id" = $1 AND started_at = $2`,
+       SET closed_at = now()
+       WHERE "_account_id" = $1 AND started_at = $2 AND closed_at IS NULL`,
       [accountId, runStartedAt]
     );
   }
-  /**
-   * Mark a sync run as failed.
-   */
-  async failSyncRun(accountId, runStartedAt, errorMessage) {
-    await this.query(
-      `UPDATE "${this.config.schema}"."_sync_run"
-       SET status = 'error', error_message = $3, completed_at = now()
-       WHERE "_account_id" = $1 AND started_at = $2`,
-      [accountId, runStartedAt, errorMessage]
-    );
-  }
   /**
    * Create object run entries for a sync run.
    * All objects start as 'pending'.
@@ -651,6 +628,7 @@ var PostgresClient = class {
   }
   /**
    * Mark an object sync as complete.
+   * Auto-closes the run when all objects are done.
    */
   async completeObjectSync(accountId, runStartedAt, object) {
     await this.query(
@@ -659,9 +637,14 @@ var PostgresClient = class {
        WHERE "_account_id" = $1 AND run_started_at = $2 AND object = $3`,
       [accountId, runStartedAt, object]
     );
+    const allDone = await this.areAllObjectsComplete(accountId, runStartedAt);
+    if (allDone) {
+      await this.closeSyncRun(accountId, runStartedAt);
+    }
   }
   /**
    * Mark an object sync as failed.
+   * Auto-closes the run when all objects are done.
    */
   async failObjectSync(accountId, runStartedAt, object, errorMessage) {
     await this.query(
@@ -670,6 +653,21 @@ var PostgresClient = class {
        WHERE "_account_id" = $1 AND run_started_at = $2 AND object = $3`,
       [accountId, runStartedAt, object, errorMessage]
     );
+    const allDone = await this.areAllObjectsComplete(accountId, runStartedAt);
+    if (allDone) {
+      await this.closeSyncRun(accountId, runStartedAt);
+    }
+  }
+  /**
+   * Check if any object in a run has errored.
+   */
+  async hasAnyObjectErrors(accountId, runStartedAt) {
+    const result = await this.query(
+      `SELECT COUNT(*) as count FROM "${this.config.schema}"."_sync_obj_run"
+       WHERE "_account_id" = $1 AND run_started_at = $2 AND status = 'error'`,
+      [accountId, runStartedAt]
+    );
+    return parseInt(result.rows[0].count) > 0;
   }
   /**
    * Count running objects in a run.
@@ -908,9 +906,22 @@ var StripeSync = class {
       { autoExpandLists: config.autoExpandLists, stripeApiVersion: config.stripeApiVersion },
       "StripeSync initialized"
     );
+    const poolConfig = config.poolConfig ?? {};
+    if (config.databaseUrl) {
+      poolConfig.connectionString = config.databaseUrl;
+    }
+    if (config.maxPostgresConnections) {
+      poolConfig.max = config.maxPostgresConnections;
+    }
+    if (poolConfig.max === void 0) {
+      poolConfig.max = 10;
+    }
+    if (poolConfig.keepAlive === void 0) {
+      poolConfig.keepAlive = true;
+    }
     this.postgresClient = new PostgresClient({
       schema: "stripe",
-      adapter: config.adapter
+      poolConfig
     });
   }
   stripe;
@@ -1252,8 +1263,8 @@ var StripeSync = class {
       // Depends on invoice
       listFn: (p) => this.stripe.creditNotes.list(p),
       upsertFn: (items, id, bf) => this.upsertCreditNotes(items, id, bf),
-      supportsCreatedFilter: false
-      // credit_notes don't support created filter
+      supportsCreatedFilter: true
+      // credit_notes support created filter
     },
     dispute: {
       order: 14,
@@ -1906,14 +1917,10 @@ var StripeSync = class {
           }
         }
       }
-      await this.postgresClient.completeSyncRun(accountId, runStartedAt);
+      await this.postgresClient.closeSyncRun(accountId, runStartedAt);
       return results;
     } catch (error) {
-      await this.postgresClient.failSyncRun(
-        accountId,
-        runStartedAt,
-        error instanceof Error ? error.message : "Unknown error"
-      );
+      await this.postgresClient.closeSyncRun(accountId, runStartedAt);
       throw error;
     }
   }
@@ -2444,12 +2451,13 @@ var StripeSync = class {
     await this.postgresClient.tryStartObjectSync(accountId, runStartedAt, resourceName);
     try {
       const result = await fn(cursor, runStartedAt);
-      await this.postgresClient.completeSyncRun(accountId, runStartedAt);
+      await this.postgresClient.completeObjectSync(accountId, runStartedAt, resourceName);
       return result;
     } catch (error) {
-      await this.postgresClient.failSyncRun(
+      await this.postgresClient.failObjectSync(
         accountId,
         runStartedAt,
+        resourceName,
         error instanceof Error ? error.message : "Unknown error"
       );
       throw error;
@@ -3207,6 +3215,7 @@ function chunkArray(array, chunkSize) {
 }
 
 // src/database/migrate.ts
+import { Client } from "pg";
 import { migrate } from "pg-node-migrations";
 import fs from "fs";
 import path from "path";
@@ -3214,15 +3223,15 @@ import { fileURLToPath } from "url";
 var __filename2 = fileURLToPath(import.meta.url);
 var __dirname2 = path.dirname(__filename2);
 async function doesTableExist(client, schema, tableName) {
-  const result = await client.query({
-    text: `SELECT EXISTS (
+  const result = await client.query(
+    `SELECT EXISTS (
       SELECT 1
       FROM information_schema.tables
       WHERE table_schema = $1
       AND table_name = $2
     )`,
-    values: [schema, tableName]
-  });
+    [schema, tableName]
+  );
   return result.rows[0]?.exists || false;
 }
 async function renameMigrationsTableIfNeeded(client, schema = "stripe", logger) {
@@ -3240,9 +3249,9 @@ async function cleanupSchema(client, schema, logger) {
   await client.query(`CREATE SCHEMA "${schema}"`);
   logger?.info(`Schema "${schema}" has been reset`);
 }
-async function connectAndMigrate(client, migrationsDirectory, logger, logOnError = false) {
+async function connectAndMigrate(client, migrationsDirectory, config, logOnError = false) {
   if (!fs.existsSync(migrationsDirectory)) {
-    logger?.info(`Migrations directory ${migrationsDirectory} not found, skipping`);
+    config.logger?.info(`Migrations directory ${migrationsDirectory} not found, skipping`);
     return;
   }
   const optionalConfig = {
@@ -3253,18 +3262,23 @@ async function connectAndMigrate(client, migrationsDirectory, logger, logOnError
     await migrate({ client }, migrationsDirectory, optionalConfig);
   } catch (error) {
     if (logOnError && error instanceof Error) {
-      logger?.error(error, "Migration error:");
+      config.logger?.error(error, "Migration error:");
     } else {
       throw error;
     }
   }
 }
-async function runMigrations(adapter, logger) {
-  const client = adapter.toPgClient();
+async function runMigrations(config) {
+  const client = new Client({
+    connectionString: config.databaseUrl,
+    ssl: config.ssl,
+    connectionTimeoutMillis: 1e4
+  });
   const schema = "stripe";
   try {
+    await client.connect();
     await client.query(`CREATE SCHEMA IF NOT EXISTS ${schema};`);
-    await renameMigrationsTableIfNeeded(client, schema, logger);
+    await renameMigrationsTableIfNeeded(client, schema, config.logger);
     const tableExists = await doesTableExist(client, schema, "_migrations");
     if (tableExists) {
       const migrationCount = await client.query(
@@ -3272,16 +3286,17 @@ async function runMigrations(adapter, logger) {
       );
       const isEmpty = migrationCount.rows[0]?.count === "0";
       if (isEmpty) {
-        await cleanupSchema(client, schema, logger);
+        await cleanupSchema(client, schema, config.logger);
       }
     }
-    logger?.info("Running migrations");
-    await connectAndMigrate(client, path.resolve(__dirname2, "./migrations"), logger);
+    config.logger?.info("Running migrations");
+    await connectAndMigrate(client, path.resolve(__dirname2, "./migrations"), config);
   } catch (err) {
-    logger?.error(err, "Error running migrations");
+    config.logger?.error(err, "Error running migrations");
     throw err;
   } finally {
-    logger?.info("Finished migrations");
+    await client.end();
+    config.logger?.info("Finished migrations");
   }
 }