@supabase/pg-delta 1.0.0-alpha.1 → 1.0.0-alpha.3

package/dist/core/plan/create.js

@@ -2,13 +2,13 @@
  * Plan creation - the main entry point for creating migration plans.
  */
 import { readFile } from "node:fs/promises";
-import postgres from "postgres";
+import { escapeIdentifier } from "pg";
 import { diffCatalogs } from "../catalog.diff.js";
 import { 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 { postgresConfig } from "../postgres-config.js";
+import { createPool } from "../postgres-config.js";
 import { sortChanges } from "../sort/sort-changes.js";
 import { classifyChangesRisk } from "./risk.js";
 /**
@@ -39,10 +39,6 @@ async function parseSslConfig(url, connectionType) {
         sslmode === "prefer" ||
         sslmode === "verify-ca" ||
         sslmode === "verify-full") {
-        const rejectUnauthorized = sslmode === "verify-ca" || sslmode === "verify-full";
-        const ssl = {
-            rejectUnauthorized,
-        };
         // Helper function to get certificate value: query param (file path) takes precedence over env var (content)
         const getCertValue = async (queryParam, envVarName) => {
             // Prefer query parameter (file path)
@@ -58,15 +54,35 @@ async function parseSslConfig(url, connectionType) {
             const envValue = process.env[envVarName];
             return envValue || undefined;
         };
-        // Get CA certificate (required for verify-ca/verify-full)
-        if (rejectUnauthorized) {
-            const caEnvVar = connectionType === "source"
-                ? "PGDELTA_SOURCE_SSLROOTCERT"
-                : "PGDELTA_TARGET_SSLROOTCERT";
-            const caValue = await getCertValue(sslrootcert, caEnvVar);
-            if (caValue) {
-                ssl.ca = caValue;
-            }
+        // Get CA certificate value (needed for verify-ca, verify-full, and libpq compatibility with require/prefer)
+        const caEnvVar = connectionType === "source"
+            ? "PGDELTA_SOURCE_SSLROOTCERT"
+            : "PGDELTA_TARGET_SSLROOTCERT";
+        const caValue = await getCertValue(sslrootcert, caEnvVar);
+        // Determine if we should verify the CA chain
+        // - verify-ca and verify-full: always verify CA
+        // - require/prefer with CA cert provided: verify CA (libpq backward compatibility)
+        //   From PostgreSQL docs: "if a root CA file exists, the behavior of sslmode=require
+        //   will be the same as that of verify-ca"
+        const hasExplicitVerification = sslmode === "verify-ca" || sslmode === "verify-full";
+        const hasLibpqCompatibility = (sslmode === "require" || sslmode === "prefer") && caValue !== undefined;
+        const shouldVerifyCa = hasExplicitVerification || hasLibpqCompatibility;
+        // Determine if we should verify hostname
+        // - verify-full: verify both CA and hostname
+        // - verify-ca: verify CA only (skip hostname)
+        // - require/prefer with CA (libpq compat): behaves like verify-ca (skip hostname)
+        const shouldVerifyHostname = sslmode === "verify-full";
+        const ssl = {
+            rejectUnauthorized: shouldVerifyCa,
+        };
+        // Add CA certificate if verifying
+        if (shouldVerifyCa && caValue) {
+            ssl.ca = caValue;
+        }
+        // For verify-ca and libpq compatibility mode: skip hostname verification
+        // This matches PostgreSQL semantics where verify-ca only checks the CA chain
+        if (shouldVerifyCa && !shouldVerifyHostname) {
+            ssl.checkServerIdentity = () => undefined;
         }
         // Get client certificate (optional, for mutual TLS)
         const certEnvVar = connectionType === "source"
@@ -94,35 +110,65 @@ async function parseSslConfig(url, connectionType) {
     return { cleanedUrl };
 }
 export async function createPlan(source, target, options = {}) {
-    const sourceSslConfig = typeof source === "string" ? await parseSslConfig(source, "source") : null;
-    const targetSslConfig = typeof target === "string" ? await parseSslConfig(target, "target") : null;
-    const sourceSql = typeof source === "string" && sourceSslConfig
-        ? postgres(sourceSslConfig.cleanedUrl, {
-            ...postgresConfig,
-            ...(sourceSslConfig.ssl ? { ssl: sourceSslConfig.ssl } : {}),
-        })
-        : source;
-    const targetSql = typeof target === "string" && targetSslConfig
-        ? postgres(targetSslConfig.cleanedUrl, {
-            ...postgresConfig,
-            ...(targetSslConfig.ssl ? { ssl: targetSslConfig.ssl } : {}),
-        })
-        : target;
-    const shouldCloseFrom = typeof source === "string";
-    const shouldCloseTo = typeof target === "string";
+    let sourcePool;
+    let targetPool;
+    let shouldCloseSource = false;
+    let shouldCloseTarget = false;
+    // Suppress expected shutdown errors from idle pool connections (57P01 = admin_shutdown)
+    const onError = (err) => {
+        if (err.code !== "57P01") {
+            console.error("Pool error:", err);
+        }
+    };
+    if (typeof source === "string") {
+        const sslConfig = await parseSslConfig(source, "source");
+        sourcePool = createPool(sslConfig.cleanedUrl, {
+            ...(sslConfig.ssl ? { ssl: sslConfig.ssl } : {}),
+            onError,
+            onConnect: async (client) => {
+                // Force fully qualified names in catalog queries
+                await client.query("SET search_path = ''");
+                if (options.role) {
+                    await client.query(`SET ROLE ${escapeIdentifier(options.role)}`);
+                }
+            },
+        });
+        shouldCloseSource = true;
+    }
+    else {
+        sourcePool = source;
+    }
+    if (typeof target === "string") {
+        const sslConfig = await parseSslConfig(target, "target");
+        targetPool = createPool(sslConfig.cleanedUrl, {
+            ...(sslConfig.ssl ? { ssl: sslConfig.ssl } : {}),
+            onError,
+            onConnect: async (client) => {
+                // Force fully qualified names in catalog queries
+                await client.query("SET search_path = ''");
+                if (options.role) {
+                    await client.query(`SET ROLE ${escapeIdentifier(options.role)}`);
+                }
+            },
+        });
+        shouldCloseTarget = true;
+    }
+    else {
+        targetPool = target;
+    }
     try {
         const [fromCatalog, toCatalog] = await Promise.all([
-            extractCatalog(sourceSql),
-            extractCatalog(targetSql),
+            extractCatalog(sourcePool),
+            extractCatalog(targetPool),
         ]);
         return buildPlanForCatalogs(fromCatalog, toCatalog, options);
     }
     finally {
         const closers = [];
-        if (shouldCloseFrom)
-            closers.push(sourceSql.end());
-        if (shouldCloseTo)
-            closers.push(targetSql.end());
+        if (shouldCloseSource)
+            closers.push(sourcePool.end());
+        if (shouldCloseTarget)
+            closers.push(targetPool.end());
         if (closers.length) {
             await Promise.all(closers);
         }
@@ -208,7 +254,7 @@ function buildPlan(ctx, changes, options, filterDSL, serializeDSL, integration)
 function generateStatements(changes, options) {
     const statements = [];
     if (options?.role) {
-        statements.push(`SET ROLE "${options.role}"`);
+        statements.push(`SET ROLE ${escapeIdentifier(options.role)}`);
     }
     if (hasRoutineChanges(changes)) {
         statements.push("SET check_function_bodies = false");

package/dist/core/postgres-config.d.ts

@@ -1,8 +1,23 @@
 /**
  * PostgreSQL connection configuration with custom type handlers.
  */
-import type postgres from "postgres";
+import type { PoolClient, PoolConfig } from "pg";
+import { Pool } from "pg";
 /**
- * Custom type handler for specific corner cases.
+ * Options for creating a Pool with event listeners.
  */
-export declare const postgresConfig: postgres.Options<Record<string, postgres.PostgresType>>;
+interface CreatePoolOptions extends Partial<PoolConfig> {
+    /** Called when a new client connects to the pool */
+    onConnect?: (client: PoolClient) => void | Promise<void>;
+    /** Called when an idle client emits an error */
+    onError?: (err: Error, client: PoolClient) => void;
+    /** Called when a client is acquired from the pool */
+    onAcquire?: (client: PoolClient) => void;
+    /** Called when a client is removed from the pool */
+    onRemove?: (client: PoolClient) => void;
+}
+/**
+ * Create a Pool with custom type handlers and optional event listeners.
+ */
+export declare function createPool(connectionString: string, options?: CreatePoolOptions): Pool;
+export {};

package/dist/core/postgres-config.js

@@ -1,46 +1,110 @@
 /**
  * PostgreSQL connection configuration with custom type handlers.
  */
+import { Pool, types } from "pg";
+// ============================================================================
+// Array Parser
+// ============================================================================
 /**
- * Custom type handler for specific corner cases.
+ * Parse PostgreSQL array string into JavaScript array.
+ * Handles: {val1,val2}, {NULL,val}, {"quoted,val"}, nested arrays.
  */
-export const postgresConfig = {
-    types: {
-        int2vector: {
-            // The pg_types oid for int2vector (22 is the OID for int2vector)
-            to: 22,
-            // Array of pg_types oids to handle when parsing values coming from the db
-            from: [22],
-            // Parse int2vector from string format "1 2 3" to array [1, 2, 3]
-            parse: (value) => {
-                if (!value || value === "")
-                    return [];
-                return value
-                    .split(" ")
-                    .map(Number)
-                    .filter((n) => !Number.isNaN(n));
-            },
-            // Serialize array back to int2vector format if needed
-            serialize: (value) => {
-                if (!Array.isArray(value))
-                    return "";
-                return value.join(" ");
-            },
-        },
-        // Handle bigint values from PostgreSQL
-        bigint: {
-            // The pg_types oid for bigint (20 is the OID for int8/bigint)
-            to: 20,
-            // Array of pg_types oids to handle when parsing values coming from the db
-            from: [20],
-            // Parse bigint string to JavaScript BigInt
-            parse: (value) => {
-                return BigInt(value);
-            },
-            // Serialize BigInt back to string for PostgreSQL
-            serialize: (value) => {
-                return value.toString();
-            },
-        },
-    },
-};
+function parseArray(value, parseElement = (v) => v) {
+    if (!value || value === "{}")
+        return [];
+    // Remove outer braces
+    const inner = value.slice(1, -1);
+    if (inner === "")
+        return [];
+    const result = [];
+    let current = "";
+    let inQuotes = false;
+    let depth = 0;
+    for (let i = 0; i < inner.length; i++) {
+        const char = inner[i];
+        if (char === '"' && inner[i - 1] !== "\\") {
+            inQuotes = !inQuotes;
+            current += char;
+        }
+        else if (char === "{" && !inQuotes) {
+            depth++;
+            current += char;
+        }
+        else if (char === "}" && !inQuotes) {
+            depth--;
+            current += char;
+        }
+        else if (char === "," && !inQuotes && depth === 0) {
+            result.push(parseElement(current));
+            current = "";
+        }
+        else {
+            current += char;
+        }
+    }
+    if (current !== "") {
+        result.push(parseElement(current));
+    }
+    return result;
+}
+/**
+ * Parse element, handling NULL, quoted strings, and unquoted values.
+ */
+function parseStringElement(val) {
+    if (val === "NULL")
+        return null;
+    if (val.startsWith('"') && val.endsWith('"')) {
+        // Unescape quoted string
+        return val.slice(1, -1).replace(/\\(.)/g, "$1");
+    }
+    return val;
+}
+function parseIntElement(val) {
+    if (val === "NULL")
+        return null;
+    return Number.parseInt(val, 10);
+}
+// ============================================================================
+// Type Parsers
+// ============================================================================
+// int2vector: "1 2 3" -> [1, 2, 3]
+// @ts-expect-error - pg types expects TypeId but raw OID numbers work fine
+types.setTypeParser(22, (val) => {
+    if (!val || val === "")
+        return [];
+    return val
+        .split(" ")
+        .map(Number)
+        .filter((n) => !Number.isNaN(n));
+});
+// bigint: string -> BigInt
+types.setTypeParser(20, (val) => BigInt(val));
+// PostgreSQL array types
+// @ts-expect-error - pg types expects TypeId but raw OID numbers work fine
+types.setTypeParser(1002, (val) => parseArray(val, parseStringElement)); // "char"[]
+// @ts-expect-error - pg types expects TypeId but raw OID numbers work fine
+types.setTypeParser(1009, (val) => parseArray(val, parseStringElement)); // text[]
+// @ts-expect-error - pg types expects TypeId but raw OID numbers work fine
+types.setTypeParser(1015, (val) => parseArray(val, parseStringElement)); // varchar[]
+// @ts-expect-error - pg types expects TypeId but raw OID numbers work fine
+types.setTypeParser(1005, (val) => parseArray(val, parseIntElement)); // int2[]
+// @ts-expect-error - pg types expects TypeId but raw OID numbers work fine
+types.setTypeParser(1007, (val) => parseArray(val, parseIntElement)); // int4[]
+// @ts-expect-error - pg types expects TypeId but raw OID numbers work fine
+types.setTypeParser(1016, (val) => parseArray(val, parseIntElement)); // int8[]
+/**
+ * Create a Pool with custom type handlers and optional event listeners.
+ */
+export function createPool(connectionString, options) {
+    const { onConnect, onError, onAcquire, onRemove, ...config } = options ?? {};
+    const pool = new Pool({ connectionString, ...config });
+    if (onConnect)
+        pool.on("connect", onConnect);
+    if (onError)
+        pool.on("error", onError);
+    if (onAcquire)
+        pool.on("acquire", onAcquire);
+    if (onRemove)
+        pool.on("remove", onRemove);
+    return pool;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@supabase/pg-delta",
-  "version": "1.0.0-alpha.1",
+  "version": "1.0.0-alpha.3",
   "description": "PostgreSQL migrations made easy",
   "type": "module",
   "sideEffects": false,
@@ -37,13 +37,15 @@
   },
   "dependencies": {
     "@stricli/core": "^1.2.4",
+    "@ts-safeql/sql-tag": "^0.2.0",
     "chalk": "^5.6.2",
     "debug": "^4.3.7",
-    "postgres": "^3.4.7",
+    "pg": "^8.17.2",
     "zod": "^4.2.1"
   },
   "devDependencies": {
     "@biomejs/biome": "2.3.10",
+    "@types/pg": "^8.11.10",
     "@changesets/cli": "^2.29.8",
     "@tsconfig/node-ts": "^23.6.2",
     "@tsconfig/node24": "^24.0.3",