@supabase/pg-delta 1.0.0-alpha.7 → 1.0.0-alpha.9

package/dist/cli/commands/declarative-apply.js

@@ -27,7 +27,7 @@ export const declarativeApplyCommand = buildCommand({
                 parse: Number,
                 optional: true,
             },
-            "no-validate-functions": {
+            "skip-function-validation": {
                 kind: "boolean",
                 brief: "Skip final function body validation pass",
                 optional: true,
@@ -110,7 +110,7 @@ Tip: Use DEBUG=pg-delta:declarative-apply for detailed defer/skip/fail logs (whi
                 content,
                 targetUrl: flags.target,
                 maxRounds: flags["max-rounds"],
-                validateFunctionBodies: !flags["no-validate-functions"],
+                validateFunctionBodies: !flags["skip-function-validation"],
                 onRoundComplete,
             });
         }

package/dist/core/plan/create.d.ts

@@ -2,7 +2,7 @@
  * Plan creation - the main entry point for creating migration plans.
  */
 import type { Pool } from "pg";
-import { Catalog } from "../catalog.model.ts";
+import type { Catalog } from "../catalog.model.ts";
 import type { Change } from "../change.types.ts";
 import type { DiffContext } from "../context.ts";
 import type { CreatePlanOptions, Plan } from "./types.ts";

package/dist/core/plan/create.js

@@ -3,13 +3,29 @@
  */
 import { escapeIdentifier } from "pg";
 import { diffCatalogs } from "../catalog.diff.js";
-import { Catalog, createEmptyCatalog, extractCatalog, } from "../catalog.model.js";
+import { createEmptyCatalog, extractCatalog } from "../catalog.model.js";
 import { buildPlanScopeFingerprint, hashStableIds } from "../fingerprint.js";
 import { compileFilterDSL, } from "../integrations/filter/dsl.js";
 import { compileSerializeDSL, } from "../integrations/serialize/dsl.js";
 import { createManagedPool, endPool } from "../postgres-config.js";
 import { sortChanges } from "../sort/sort-changes.js";
 import { classifyChangesRisk } from "./risk.js";
+/**
+ * Bundle-safe catalog detection: treat input as a resolved Catalog when it has
+ * the catalog shape and is not a pg Pool. Deserialized or cross-bundle Catalog
+ * instances may fail `instanceof Catalog` but pass this guard.
+ */
+function isResolvedCatalog(input) {
+    return (typeof input === "object" &&
+        input !== null &&
+        typeof input.query !== "function" &&
+        "version" in input &&
+        "currentUser" in input &&
+        "depends" in input &&
+        "schemas" in input &&
+        "tables" in input &&
+        "views" in input);
+}
 /**
  * Create a migration plan by comparing two catalog states.
  *
@@ -42,7 +58,7 @@ export async function createPlan(source, target, options = {}) {
      * Resolve a CatalogInput to a Catalog, tracking pools that need cleanup.
      */
     const resolveCatalog = async (input, label, pools) => {
-        if (input instanceof Catalog) {
+        if (isResolvedCatalog(input)) {
             return input;
         }
         const resolved = await resolvePool(input, label);

package/dist/core/postgres-config.js

@@ -107,8 +107,49 @@ export function createPool(connectionString, options) {
         connectionTimeoutMillis: DEFAULT_CONNECTION_TIMEOUT_MS,
         ...config,
     });
-    if (onConnect)
-        pool.on("connect", onConnect);
+    if (onConnect) {
+        const pendingClientSetup = new WeakMap();
+        const waitForClientSetup = async (client) => {
+            const setup = pendingClientSetup.get(client);
+            if (setup) {
+                await setup;
+                return;
+            }
+            throw new Error("Internal error: pool client was acquired before async onConnect setup was registered. This indicates a bug in the pool wrapper logic; please report it with reproduction steps.");
+        };
+        const originalConnect = pool.connect.bind(pool);
+        pool.on("connect", (client) => {
+            pendingClientSetup.set(client, Promise.resolve().then(() => onConnect(client)));
+        });
+        pool.connect = ((callback) => {
+            if (!callback) {
+                return originalConnect().then(async (client) => {
+                    try {
+                        await waitForClientSetup(client);
+                        return client;
+                    }
+                    catch (setupError) {
+                        client.release?.(setupError);
+                        throw setupError;
+                    }
+                });
+            }
+            return originalConnect(async (err, client, release) => {
+                if (err || !client) {
+                    callback(err, client, release);
+                    return;
+                }
+                try {
+                    await waitForClientSetup(client);
+                    callback(err, client, release);
+                }
+                catch (setupError) {
+                    release(setupError);
+                    callback(setupError, undefined, () => { });
+                }
+            });
+        });
+    }
     if (onError)
         pool.on("error", onError);
     if (onAcquire)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@supabase/pg-delta",
-  "version": "1.0.0-alpha.7",
+  "version": "1.0.0-alpha.9",
   "description": "PostgreSQL migrations made easy",
   "type": "module",
   "sideEffects": false,

package/src/cli/commands/declarative-apply.ts

@@ -42,7 +42,7 @@ export const declarativeApplyCommand = buildCommand({
         parse: Number,
         optional: true,
       },
-      "no-validate-functions": {
+      "skip-function-validation": {
         kind: "boolean",
         brief: "Skip final function body validation pass",
         optional: true,
@@ -93,7 +93,7 @@ Tip: Use DEBUG=pg-delta:declarative-apply for detailed defer/skip/fail logs (whi
       path: string;
       target: string;
       "max-rounds"?: number;
-      "no-validate-functions"?: boolean;
+      "skip-function-validation"?: boolean;
       verbose?: boolean;
       "ungroup-diagnostics"?: boolean;
     },
@@ -144,7 +144,7 @@ Tip: Use DEBUG=pg-delta:declarative-apply for detailed defer/skip/fail logs (whi
         content,
         targetUrl: flags.target,
         maxRounds: flags["max-rounds"],
-        validateFunctionBodies: !flags["no-validate-functions"],
+        validateFunctionBodies: !flags["skip-function-validation"],
         onRoundComplete,
       });
     } catch (error) {

package/src/core/catalog.snapshot.test.ts

@@ -289,6 +289,19 @@ describe("catalog snapshot serde", () => {
     expect(result).toBeNull();
   });
 
+  test("createPlan accepts catalog-shaped plain object (bundle-boundary regression)", async () => {
+    const { createPlan } = await import("./plan/create.ts");
+
+    const sourceCatalog = await createEmptyCatalog(160000, "postgres");
+    const targetCatalog = await createEmptyCatalog(160000, "postgres");
+    const source = { ...sourceCatalog };
+
+    expect(source instanceof Catalog).toBe(false);
+
+    const result = await createPlan(source as Catalog, targetCatalog);
+    expect(result).toBeNull();
+  });
+
   test("createPlan with null source produces plan when target has objects", async () => {
     const { createPlan } = await import("./plan/create.ts");
 

package/src/core/plan/create.ts

@@ -5,11 +5,8 @@
 import type { Pool } from "pg";
 import { escapeIdentifier } from "pg";
 import { diffCatalogs } from "../catalog.diff.ts";
-import {
-  Catalog,
-  createEmptyCatalog,
-  extractCatalog,
-} from "../catalog.model.ts";
+import type { Catalog } from "../catalog.model.ts";
+import { createEmptyCatalog, extractCatalog } from "../catalog.model.ts";
 import type { Change } from "../change.types.ts";
 import type { DiffContext } from "../context.ts";
 import { buildPlanScopeFingerprint, hashStableIds } from "../fingerprint.ts";
@@ -38,6 +35,25 @@ import type { CreatePlanOptions, Plan } from "./types.ts";
  */
 export type CatalogInput = string | Pool | Catalog;
 
+/**
+ * Bundle-safe catalog detection: treat input as a resolved Catalog when it has
+ * the catalog shape and is not a pg Pool. Deserialized or cross-bundle Catalog
+ * instances may fail `instanceof Catalog` but pass this guard.
+ */
+function isResolvedCatalog(input: CatalogInput): input is Catalog {
+  return (
+    typeof input === "object" &&
+    input !== null &&
+    typeof (input as { query?: unknown }).query !== "function" &&
+    "version" in input &&
+    "currentUser" in input &&
+    "depends" in input &&
+    "schemas" in input &&
+    "tables" in input &&
+    "views" in input
+  );
+}
+
 /**
  * Create a migration plan by comparing two catalog states.
  *
@@ -82,7 +98,7 @@ export async function createPlan(
     label: "source" | "target",
     pools: Array<{ pool: Pool; shouldClose: boolean }>,
   ): Promise<Catalog> => {
-    if (input instanceof Catalog) {
+    if (isResolvedCatalog(input)) {
       return input;
     }
     const resolved = await resolvePool(input, label);

package/src/core/postgres-config.ts

@@ -139,7 +139,62 @@ export function createPool(
     ...config,
   });
 
-  if (onConnect) pool.on("connect", onConnect);
+  if (onConnect) {
+    const pendingClientSetup = new WeakMap<PoolClient, Promise<void>>();
+    const waitForClientSetup = async (client: PoolClient) => {
+      const setup = pendingClientSetup.get(client);
+      if (setup) {
+        await setup;
+        return;
+      }
+      throw new Error(
+        "Internal error: pool client was acquired before async onConnect setup was registered. This indicates a bug in the pool wrapper logic; please report it with reproduction steps.",
+      );
+    };
+    const originalConnect = pool.connect.bind(pool);
+
+    pool.on("connect", (client) => {
+      pendingClientSetup.set(
+        client,
+        Promise.resolve().then(() => onConnect(client)),
+      );
+    });
+
+    pool.connect = ((
+      callback?: (
+        err: Error | undefined,
+        client: PoolClient | undefined,
+        release: (err?: Error | boolean) => void,
+      ) => void,
+    ) => {
+      if (!callback) {
+        return originalConnect().then(async (client) => {
+          try {
+            await waitForClientSetup(client);
+            return client;
+          } catch (setupError) {
+            (client as PoolClient).release?.(setupError as Error);
+            throw setupError;
+          }
+        });
+      }
+
+      return originalConnect(async (err, client, release) => {
+        if (err || !client) {
+          callback(err, client, release);
+          return;
+        }
+
+        try {
+          await waitForClientSetup(client);
+          callback(err, client, release);
+        } catch (setupError) {
+          release(setupError as Error);
+          callback(setupError as Error, undefined, () => {});
+        }
+      });
+    }) as Pool["connect"];
+  }
   if (onError) pool.on("error", onError);
   if (onAcquire) pool.on("acquire", onAcquire);
   if (onRemove) pool.on("remove", onRemove);