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

package/README.md

@@ -47,6 +47,28 @@ pg-delta plan \
   --output plan.json
 ```
 
+**Plan (SQL output with formatting)** - Opt-in post-formatting for SQL scripts:
+
+```bash
+pg-delta plan \
+  --source postgresql://user:pass@localhost:5432/source_db \
+  --target postgresql://user:pass@localhost:5432/target_db \
+  --format sql \
+  --sql-format \
+  --sql-format-options '{"keywordCase":"upper","maxWidth":100}'
+```
+
+Available SQL format options (JSON):
+- `keywordCase`: `upper` | `lower` | `preserve`
+- `indent`: number of spaces per level
+- `maxWidth`: line width for wrapping
+- `commaStyle`: `trailing` | `leading`
+- `alignColumns`: boolean
+- `alignKeyValues`: boolean
+- `preserveRoutineBodies`: boolean
+- `preserveViewBodies`: boolean
+- `preserveRuleBodies`: boolean
+
 **Apply** - Apply a previously created plan:
 
 ```bash

package/dist/cli/commands/plan.js

@@ -69,6 +69,24 @@ export const planCommand = buildCommand({
                 parse: String,
                 optional: true,
             },
+            "sql-format": {
+                kind: "boolean",
+                brief: "Format SQL output (opt-in for --format sql or .sql output).",
+                optional: true,
+            },
+            "sql-format-options": {
+                kind: "parsed",
+                brief: 'SQL format options as inline JSON (e.g., \'{"keywordCase":"upper","maxWidth":100}\').',
+                parse: (value) => {
+                    try {
+                        return JSON.parse(value);
+                    }
+                    catch (error) {
+                        throw new Error(`Invalid SQL format JSON: ${error instanceof Error ? error.message : String(error)}`);
+                    }
+                },
+                optional: true,
+            },
         },
         aliases: {
             s: "source",
@@ -120,6 +138,9 @@ json/sql outputs are available for artifacts or piping.
         const { content, label } = formatPlanForDisplay(planResult, effectiveFormat, {
             disableColors: !!outputPath,
             showUnsafeFlagSuggestion: false,
+            sqlFormatOptions: flags["sql-format"] || flags["sql-format-options"]
+                ? (flags["sql-format-options"] ?? {})
+                : undefined,
         });
         if (outputPath) {
             await writeFile(outputPath, content, "utf-8");

package/dist/cli/utils.d.ts

@@ -5,6 +5,7 @@ import type { CommandContext } from "@stricli/core";
 import type { Change } from "../core/change.types.ts";
 import type { DiffContext } from "../core/context.ts";
 import { type Plan } from "../core/plan/index.ts";
+import type { SqlFormatOptions } from "../core/plan/sql-format.ts";
 type ApplyPlanResult = {
     status: "invalid_plan";
     message: string;
@@ -31,6 +32,7 @@ type PlanResult = {
 interface FormatPlanOptions {
     disableColors?: boolean;
     showUnsafeFlagSuggestion?: boolean;
+    sqlFormatOptions?: SqlFormatOptions;
 }
 /**
  * Formats a plan result for display in various formats.

package/dist/cli/utils.js

@@ -19,7 +19,7 @@ export function formatPlanForDisplay(planResult, format, options = {}) {
         case "sql": {
             const content = [
                 `-- Risk: ${risk.level === "data_loss" ? `data-loss (${risk.statements.length})` : "safe"}`,
-                formatSqlScript(plan.statements),
+                formatSqlScript(plan.statements, options.sqlFormatOptions),
             ].join("\n");
             return { content, label: "Migration script" };
         }

package/dist/core/objects/table/table.model.d.ts

@@ -13,6 +13,7 @@ declare const tableConstraintPropsSchema: z.ZodObject<{
     constraint_type: z.ZodEnum<{
         f: "f";
         u: "u";
+        t: "t";
         p: "p";
         c: "c";
         x: "x";
@@ -114,6 +115,7 @@ declare const tablePropsSchema: z.ZodObject<{
         constraint_type: z.ZodEnum<{
             f: "f";
             u: "u";
+            t: "t";
             p: "p";
             c: "c";
             x: "x";
@@ -231,7 +233,7 @@ export declare class Table extends BasePgModel implements TableLikeObject {
         }[];
         constraints: {
             name: string;
-            constraint_type: "f" | "u" | "p" | "c" | "x";
+            constraint_type: "f" | "u" | "t" | "p" | "c" | "x";
             deferrable: boolean;
             initially_deferred: boolean;
             validated: boolean;
@@ -292,7 +294,7 @@ export declare class Table extends BasePgModel implements TableLikeObject {
             options: string[] | null;
             constraints: {
                 name: string;
-                constraint_type: "f" | "u" | "p" | "c" | "x";
+                constraint_type: "f" | "u" | "t" | "p" | "c" | "x";
                 deferrable: boolean;
                 initially_deferred: boolean;
                 validated: boolean;

package/dist/core/objects/table/table.model.js

@@ -33,6 +33,7 @@ const tableConstraintPropsSchema = z.object({
         "c", // CHECK constraint
         "f", // FOREIGN KEY constraint
         "p", // PRIMARY KEY constraint
+        "t", // TRIGGER constraint
         "u", // UNIQUE constraint
         "x", // EXCLUDE constraint
     ]),
@@ -338,6 +339,8 @@ select
       and de.refclassid = 'pg_extension'::regclass
 
       where c.conrelid = t.oid
+        -- Skip constraint triggers; they are modeled as triggers, not table constraints
+        and c.contype <> 't'
         and not c.connamespace::regnamespace::text like any(array['pg\\_%', 'information\\_schema'])
         and de.objid is null
     ),

package/dist/core/objects/trigger/changes/trigger.alter.js

@@ -1,5 +1,7 @@
+import { quoteLiteral } from "../../base.change.js";
 import { AlterTriggerChange } from "./trigger.base.js";
 import { CreateTrigger } from "./trigger.create.js";
+import { DropTrigger } from "./trigger.drop.js";
 /**
  * Replace a trigger by dropping and recreating it.
  * This is used when properties that cannot be altered via ALTER TRIGGER change.
@@ -17,6 +19,27 @@ export class ReplaceTrigger extends AlterTriggerChange {
         return [this.trigger.stableId];
     }
     serialize() {
+        if (this.trigger.isConstraintTrigger) {
+            const dropChange = new DropTrigger({ trigger: this.trigger });
+            const createChange = new CreateTrigger({
+                trigger: this.trigger,
+                indexableObject: this.indexableObject,
+                orReplace: false,
+            });
+            const commentSql = this.trigger.comment !== null
+                ? [
+                    "COMMENT ON TRIGGER",
+                    this.trigger.name,
+                    "ON",
+                    `${this.trigger.schema}.${this.trigger.table_name}`,
+                    "IS",
+                    quoteLiteral(this.trigger.comment),
+                ].join(" ")
+                : null;
+            return [dropChange.serialize(), createChange.serialize(), commentSql]
+                .filter(Boolean)
+                .join(";\n");
+        }
         const createChange = new CreateTrigger({
             trigger: this.trigger,
             indexableObject: this.indexableObject,

package/dist/core/objects/trigger/changes/trigger.create.js

@@ -55,7 +55,8 @@ export class CreateTrigger extends CreateTriggerChange {
     }
     serialize() {
         let definition = this.trigger.definition.trim();
-        definition = definition.replace(/^CREATE\s+(?:OR\s+REPLACE\s+)?/i, `CREATE ${this.orReplace ? "OR REPLACE " : ""}`);
+        const isConstraintTrigger = this.trigger.isConstraintTrigger;
+        definition = definition.replace(/^CREATE\s+(?:OR\s+REPLACE\s+)?/i, `CREATE ${this.orReplace && !isConstraintTrigger ? "OR REPLACE " : ""}`);
         return definition;
     }
 }

package/dist/core/objects/trigger/trigger.model.d.ts

@@ -59,6 +59,7 @@ export declare class Trigger extends BasePgModel {
     readonly definition: TriggerProps["definition"];
     readonly comment: TriggerProps["comment"];
     constructor(props: TriggerProps);
+    get isConstraintTrigger(): boolean;
     get stableId(): `trigger:${string}`;
     get identityFields(): {
         schema: string;

package/dist/core/objects/trigger/trigger.model.js

@@ -87,6 +87,9 @@ export class Trigger extends BasePgModel {
         this.definition = props.definition;
         this.comment = props.comment;
     }
+    get isConstraintTrigger() {
+        return /^CREATE\s+CONSTRAINT\s+TRIGGER/i.test(this.definition.trim());
+    }
     get stableId() {
         return `trigger:${this.schema}.${this.table_name}.${this.name}`;
     }

package/dist/core/plan/apply.js

@@ -6,7 +6,7 @@ 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 { createPool } from "../postgres-config.js";
+import { createPool, endPool } from "../postgres-config.js";
 import { sortChanges } from "../sort/sort-changes.js";
 /**
  * Check if a statement is a session configuration statement (standalone SET statements).
@@ -136,9 +136,9 @@ export async function applyPlan(plan, source, target, options = {}) {
     finally {
         const closers = [];
         if (shouldCloseCurrent)
-            closers.push(currentPool.end());
+            closers.push(endPool(currentPool));
         if (shouldCloseDesired)
-            closers.push(desiredPool.end());
+            closers.push(endPool(desiredPool));
         if (closers.length) {
             await Promise.all(closers);
         }

package/dist/core/plan/create.js

@@ -8,7 +8,7 @@ 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 { createPool } from "../postgres-config.js";
+import { createPool, endPool } from "../postgres-config.js";
 import { sortChanges } from "../sort/sort-changes.js";
 import { classifyChangesRisk } from "./risk.js";
 /**
@@ -33,7 +33,7 @@ async function parseSslConfig(url, connectionType) {
     const cleanedUrl = urlObj.toString();
     // Handle different SSL modes
     if (sslmode === "disable") {
-        return { cleanedUrl };
+        return { cleanedUrl, ssl: false };
     }
     if (sslmode === "require" ||
         sslmode === "prefer" ||
@@ -54,17 +54,27 @@ async function parseSslConfig(url, connectionType) {
             const envValue = process.env[envVarName];
             return envValue || undefined;
         };
-        // Get CA certificate value (needed for verify-ca, verify-full, and libpq compatibility with require/prefer)
+        const hasExplicitVerification = sslmode === "verify-ca" || sslmode === "verify-full";
+        // Get CA certificate value.
+        // - verify-ca/verify-full: check query param first, then env var
+        // - require/prefer: only check query param (libpq backward compatibility
+        //   requires an explicit root CA *file*, not a global env var)
         const caEnvVar = connectionType === "source"
             ? "PGDELTA_SOURCE_SSLROOTCERT"
             : "PGDELTA_TARGET_SSLROOTCERT";
-        const caValue = await getCertValue(sslrootcert, caEnvVar);
+        let caValue;
+        if (sslrootcert) {
+            // Explicit file path in query param — always honour it
+            caValue = await getCertValue(sslrootcert, caEnvVar);
+        }
+        else if (hasExplicitVerification) {
+            // verify-ca / verify-full without file path — fall back to env var
+            caValue = await getCertValue(null, caEnvVar);
+        }
+        // require/prefer without sslrootcert: no CA cert, no verification
         // 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
@@ -106,8 +116,8 @@ async function parseSslConfig(url, connectionType) {
         }
         return { ssl, cleanedUrl };
     }
-    // No sslmode specified or invalid value - no SSL configuration
-    return { cleanedUrl };
+    // No sslmode specified or invalid value - explicitly disable SSL
+    return { cleanedUrl, ssl: false };
 }
 export async function createPlan(source, target, options = {}) {
     let sourcePool;
@@ -123,7 +133,7 @@ export async function createPlan(source, target, options = {}) {
     if (typeof source === "string") {
         const sslConfig = await parseSslConfig(source, "source");
         sourcePool = createPool(sslConfig.cleanedUrl, {
-            ...(sslConfig.ssl ? { ssl: sslConfig.ssl } : {}),
+            ...(sslConfig.ssl !== undefined ? { ssl: sslConfig.ssl } : {}),
             onError,
             onConnect: async (client) => {
                 // Force fully qualified names in catalog queries
@@ -141,7 +151,7 @@ export async function createPlan(source, target, options = {}) {
     if (typeof target === "string") {
         const sslConfig = await parseSslConfig(target, "target");
         targetPool = createPool(sslConfig.cleanedUrl, {
-            ...(sslConfig.ssl ? { ssl: sslConfig.ssl } : {}),
+            ...(sslConfig.ssl !== undefined ? { ssl: sslConfig.ssl } : {}),
             onError,
             onConnect: async (client) => {
                 // Force fully qualified names in catalog queries
@@ -156,19 +166,28 @@ export async function createPlan(source, target, options = {}) {
     else {
         targetPool = target;
     }
+    const sourceExtraction = extractCatalog(sourcePool);
+    const targetExtraction = extractCatalog(targetPool);
     try {
         const [fromCatalog, toCatalog] = await Promise.all([
-            extractCatalog(sourcePool),
-            extractCatalog(targetPool),
+            sourceExtraction,
+            targetExtraction,
         ]);
         return buildPlanForCatalogs(fromCatalog, toCatalog, options);
     }
+    catch (error) {
+        // When one extraction fails, the other may still have in-flight queries.
+        // Wait for both to settle before pool cleanup to prevent unhandled
+        // rejections from connections being terminated mid-flight.
+        await Promise.allSettled([sourceExtraction, targetExtraction]);
+        throw error;
+    }
     finally {
         const closers = [];
         if (shouldCloseSource)
-            closers.push(sourcePool.end());
+            closers.push(endPool(sourcePool));
         if (shouldCloseTarget)
-            closers.push(targetPool.end());
+            closers.push(endPool(targetPool));
         if (closers.length) {
             await Promise.all(closers);
         }

package/dist/core/plan/sql-format/constants.d.ts

@@ -0,0 +1,2 @@
+import type { NormalizedOptions } from "./types.ts";
+export declare const DEFAULT_OPTIONS: NormalizedOptions;

package/dist/core/plan/sql-format/constants.js

@@ -0,0 +1,11 @@
+export const DEFAULT_OPTIONS = {
+    keywordCase: "preserve",
+    indent: 2,
+    maxWidth: 100,
+    commaStyle: "trailing",
+    alignColumns: true,
+    alignKeyValues: true,
+    preserveRoutineBodies: true,
+    preserveViewBodies: true,
+    preserveRuleBodies: true,
+};

package/dist/core/plan/sql-format/fixtures.d.ts

@@ -0,0 +1,2 @@
+import type { SqlFormatOptions } from "../sql-format.ts";
+export declare function renderScript(options?: SqlFormatOptions): string;