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

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,2 @@
+import type { NormalizedOptions } from "./types.ts";
+export declare function wrapStatement(statement: string, options: NormalizedOptions, noWrapPlaceholders: Set<string>): string;

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

@@ -0,0 +1,165 @@
+import { indentString } from "./format-utils.js";
+import { isWordChar, walkSql } from "./sql-scanner.js";
+/**
+ * Keywords that are preferred break points when wrapping long lines.
+ * The wrapper will prefer to break just before one of these keywords
+ * rather than at an arbitrary whitespace position.
+ */
+const WRAP_PREFERRED_KEYWORDS = new Set([
+    "ADD",
+    "CHECK",
+    "CONNECTION",
+    "CONSTRAINT",
+    "DEFERRABLE",
+    "FOREIGN",
+    "HANDLER",
+    "INCLUDE",
+    "INITIALLY",
+    "INLINE",
+    "MATCH",
+    "NOT",
+    "ON",
+    "OPTIONS",
+    "PUBLICATION",
+    "REFERENCES",
+    "REFERENCING",
+    "SET",
+    "USING",
+    "VALIDATOR",
+    "WHERE",
+    "WITH",
+]);
+export function wrapStatement(statement, options, noWrapPlaceholders) {
+    const lines = statement.split(/\r?\n/);
+    const wrapped = [];
+    for (const line of lines) {
+        if (line.trim().startsWith("--")) {
+            wrapped.push(line);
+            continue;
+        }
+        if (hasNoWrapPlaceholder(line, noWrapPlaceholders)) {
+            wrapped.push(line);
+            continue;
+        }
+        wrapped.push(...wrapLine(line, options));
+    }
+    return wrapped.join("\n");
+}
+function hasNoWrapPlaceholder(line, placeholders) {
+    for (const token of placeholders) {
+        if (line.includes(token))
+            return true;
+    }
+    return false;
+}
+function wrapLine(line, options) {
+    const maxWidth = options.maxWidth;
+    if (maxWidth <= 0 || line.length <= maxWidth) {
+        return [line];
+    }
+    const indentMatch = line.match(/^\s*/);
+    const baseIndent = indentMatch ? indentMatch[0] : "";
+    const continuationIndent = `${baseIndent}${indentString(options.indent)}`;
+    let remaining = line;
+    const output = [];
+    while (remaining.length > maxWidth) {
+        const breakpoint = findWrapPosition(remaining, maxWidth);
+        if (breakpoint <= 0)
+            break;
+        const head = remaining.slice(0, breakpoint).trimEnd();
+        const tail = remaining.slice(breakpoint).trimStart();
+        output.push(head);
+        const next = `${continuationIndent}${tail}`;
+        if (next.length >= remaining.length) {
+            remaining = next;
+            break;
+        }
+        remaining = next;
+    }
+    output.push(remaining);
+    return output;
+}
+/** Words that should not be separated from the previous word when wrapping (e.g. CREATE PUBLICATION, COMMENT ON). */
+const KEEP_WITH_PREVIOUS = new Set([
+    "PUBLICATION",
+    "TABLE",
+    "VIEW",
+    "SCHEMA",
+    "INDEX",
+    "OR", // CREATE OR REPLACE
+    "ON", // COMMENT ON
+]);
+function getPreviousWord(text, beforeIndex) {
+    let end = beforeIndex - 1;
+    while (end >= 0 && (text[end] === " " || text[end] === "\t")) {
+        end -= 1;
+    }
+    if (end < 0 || !isWordChar(text[end]))
+        return null;
+    let start = end;
+    while (start > 0 && isWordChar(text[start - 1])) {
+        start -= 1;
+    }
+    return text.slice(start, end + 1).toUpperCase();
+}
+function findWrapPosition(text, maxWidth) {
+    /** Last whitespace at depth 0 (preferred — avoids splitting parenthesized expressions) */
+    let lastTopLevelWhitespace = -1;
+    /** Last whitespace at any depth (fallback when no depth-0 break exists) */
+    let lastAnyWhitespace = -1;
+    let lastKeywordBoundary = -1;
+    /** First (leftmost) top-level comma within maxWidth — break there so each clause gets its own line */
+    let firstComma = -1;
+    // Never break within the leading indent — that would produce an empty head line
+    const contentStart = text.search(/\S/);
+    if (contentStart < 0)
+        return -1; // all whitespace
+    walkSql(text, (index, char, depth) => {
+        if (index > maxWidth)
+            return false;
+        // Skip positions within leading indent
+        if (index < contentStart)
+            return true;
+        // Prefer breaking after the first top-level comma so comma-separated clauses (e.g. publication tables) each get their own line
+        if (char === "," && depth === 0 && firstComma < 0) {
+            firstComma = index + 1; // position after the comma
+        }
+        if (char === " " || char === "\t") {
+            lastAnyWhitespace = index;
+            if (depth === 0) {
+                lastTopLevelWhitespace = index;
+            }
+            // Check if the next word is a preferred keyword
+            const nextWordStart = index + 1;
+            if (nextWordStart < text.length && isWordChar(text[nextWordStart])) {
+                let wordEnd = nextWordStart + 1;
+                while (wordEnd < text.length && isWordChar(text[wordEnd])) {
+                    wordEnd += 1;
+                }
+                const word = text.slice(nextWordStart, wordEnd).toUpperCase();
+                if (WRAP_PREFERRED_KEYWORDS.has(word)) {
+                    // Don't break between CREATE and object type, COMMENT and ON, or ALL and ON (GRANT/REVOKE ALL ON)
+                    const prev = getPreviousWord(text, index);
+                    if (prev !== null &&
+                        ((prev === "CREATE" && KEEP_WITH_PREVIOUS.has(word)) ||
+                            ((prev === "COMMENT" || prev === "ALL") && word === "ON"))) {
+                        return true;
+                    }
+                    lastKeywordBoundary = index;
+                }
+            }
+        }
+        return true;
+    }, { trackDepth: true });
+    // Prefer: 1) comma, 2) keyword boundary, 3) depth-0 whitespace, 4) any whitespace
+    if (firstComma > 0 && firstComma <= maxWidth) {
+        return firstComma;
+    }
+    if (lastKeywordBoundary > 0 && lastKeywordBoundary <= maxWidth) {
+        return lastKeywordBoundary;
+    }
+    if (lastTopLevelWhitespace > 0) {
+        return lastTopLevelWhitespace;
+    }
+    return lastAnyWhitespace;
+}

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

@@ -0,0 +1,2 @@
+export { formatSqlStatements } from "./sql-format/index.ts";
+export type { SqlFormatOptions } from "./sql-format/types.ts";

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

@@ -0,0 +1 @@
+export { formatSqlStatements } from "./sql-format/index.js";

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

@@ -1,8 +1,9 @@
 /**
  * SQL script formatting utilities.
  */
+import { type SqlFormatOptions } from "./sql-format.ts";
 /**
  * Format an array of SQL statements into a single script string.
  * Statements are joined with double newlines and the script ends with a semicolon.
  */
-export declare function formatSqlScript(statements: string[]): string;
+export declare function formatSqlScript(statements: string[], options?: SqlFormatOptions): string;

package/dist/core/plan/statements.js

@@ -1,13 +1,17 @@
 /**
  * SQL script formatting utilities.
  */
+import { formatSqlStatements } from "./sql-format.js";
 const STATEMENT_DELIMITER = ";\n\n";
 /**
  * Format an array of SQL statements into a single script string.
  * Statements are joined with double newlines and the script ends with a semicolon.
  */
-export function formatSqlScript(statements) {
+export function formatSqlScript(statements, options) {
     if (statements.length === 0)
         return "";
-    return `${statements.join(STATEMENT_DELIMITER)};`;
+    const formatted = options
+        ? formatSqlStatements(statements, options)
+        : statements;
+    return `${formatted.join(STATEMENT_DELIMITER)};`;
 }

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

@@ -20,4 +20,19 @@ interface CreatePoolOptions extends Partial<PoolConfig> {
  * Create a Pool with custom type handlers and optional event listeners.
  */
 export declare function createPool(connectionString: string, options?: CreatePoolOptions): Pool;
+/**
+ * End a pool and wait for all client sockets to fully close.
+ *
+ * pg-pool's `pool.end()` resolves once clients are removed from its
+ * internal bookkeeping, but the underlying `client.end()` calls (which
+ * close the TCP/TLS sockets) are fired asynchronously *after* that.
+ * If the server (e.g. a test container) is stopped right after
+ * `pool.end()` resolves, the still-open sockets receive an unexpected
+ * RST and emit unhandled "Connection terminated unexpectedly" errors.
+ *
+ * This helper waits for every `remove` event — which pg-pool emits
+ * inside each `client.end()` callback — ensuring all sockets are
+ * truly closed before it resolves.
+ */
+export declare function endPool(pool: Pool): Promise<void>;
 export {};

package/dist/core/postgres-config.js

@@ -108,3 +108,33 @@ export function createPool(connectionString, options) {
         pool.on("remove", onRemove);
     return pool;
 }
+/**
+ * End a pool and wait for all client sockets to fully close.
+ *
+ * pg-pool's `pool.end()` resolves once clients are removed from its
+ * internal bookkeeping, but the underlying `client.end()` calls (which
+ * close the TCP/TLS sockets) are fired asynchronously *after* that.
+ * If the server (e.g. a test container) is stopped right after
+ * `pool.end()` resolves, the still-open sockets receive an unexpected
+ * RST and emit unhandled "Connection terminated unexpectedly" errors.
+ *
+ * This helper waits for every `remove` event — which pg-pool emits
+ * inside each `client.end()` callback — ensuring all sockets are
+ * truly closed before it resolves.
+ */
+export function endPool(pool) {
+    const clientCount = pool.totalCount;
+    if (clientCount === 0) {
+        return pool.end();
+    }
+    return new Promise((resolve, reject) => {
+        let removed = 0;
+        pool.on("remove", function onRemove() {
+            if (++removed >= clientCount) {
+                pool.removeListener("remove", onRemove);
+                resolve();
+            }
+        });
+        pool.end().catch(reject);
+    });
+}

package/dist/index.d.ts

@@ -6,4 +6,6 @@
 export type { IntegrationDSL } from "./core/integrations/integration-dsl.ts";
 export { applyPlan } from "./core/plan/apply.ts";
 export { createPlan } from "./core/plan/create.ts";
+export type { SqlFormatOptions } from "./core/plan/sql-format.ts";
+export { formatSqlStatements } from "./core/plan/sql-format.ts";
 export type { CreatePlanOptions, Plan } from "./core/plan/types.ts";

package/dist/index.js

@@ -6,3 +6,4 @@
 export { applyPlan } from "./core/plan/apply.js";
 // Core operations
 export { createPlan } from "./core/plan/create.js";
+export { formatSqlStatements } from "./core/plan/sql-format.js";

package/package.json

@@ -1,18 +1,33 @@
 {
   "name": "@supabase/pg-delta",
-  "version": "1.0.0-alpha.3",
+  "version": "1.0.0-alpha.4",
   "description": "PostgreSQL migrations made easy",
   "type": "module",
   "sideEffects": false,
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "exports": {
-    ".": "./dist/index.js",
-    "./integrations/supabase": "./dist/core/integrations/supabase.js"
+    ".": {
+      "bun": "./src/index.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./integrations/supabase": {
+      "bun": "./src/core/integrations/supabase.ts",
+      "import": "./dist/core/integrations/supabase.js",
+      "require": "./dist/core/integrations/supabase.js",
+      "types": "./dist/core/integrations/supabase.d.ts",
+      "default": "./dist/core/integrations/supabase.js"
+    }
   },
   "bin": {
     "pgdelta": "./dist/cli/bin/cli.js"
   },
   "files": [
     "dist",
+    "src",
     "README.md",
     "LICENSE"
   ],
@@ -26,15 +41,27 @@
   ],
   "author": "Supabase",
   "license": "MIT",
-  "homepage": "https://github.com/supabase/pg-delta",
+  "homepage": "https://github.com/supabase/pg-toolbelt",
   "repository": {
     "type": "git",
-    "url": "https://github.com/supabase/pg-delta.git"
+    "url": "https://github.com/supabase/pg-toolbelt.git",
+    "directory": "packages/pg-delta"
   },
-  "bugs": "https://github.com/supabase/pg-delta/issues",
+  "bugs": "https://github.com/supabase/pg-toolbelt/issues",
   "engines": {
     "node": ">=20.0.0"
   },
+  "scripts": {
+    "build": "tsc --project tsconfig.build.json",
+    "check-types": "tsc --noEmit",
+    "format-and-lint": "biome check . --error-on-warnings",
+    "knip": "knip",
+    "pgdelta": "bun src/cli/bin/cli.ts",
+    "test": "bun test --concurrent --timeout 15000 --preload ./tests/global-setup.ts",
+    "test:unit": "bun test --concurrent src/",
+    "test:integration": "bun test --concurrent --timeout 15000 --preload ./tests/global-setup.ts --max-concurrency=4 tests/",
+    "version": "changeset version && bun install --no-frozen-lockfile && bun run format-and-lint --write"
+  },
   "dependencies": {
     "@stricli/core": "^1.2.4",
     "@ts-safeql/sql-tag": "^0.2.0",
@@ -44,27 +71,15 @@
     "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",
+    "@types/bun": "^1.3.9",
     "@types/debug": "^4.1.12",
     "@types/node": "^24.10.4",
-    "@vitest/coverage-v8": "4.0.16",
+    "@types/pg": "^8.11.10",
     "dedent": "^1.7.1",
     "knip": "^5.75.2",
     "testcontainers": "^11.10.0",
-    "typescript": "^5.9.3",
-    "vitest": "^4.0.16"
-  },
-  "scripts": {
-    "build": "tsc --project tsconfig.build.json",
-    "check-types": "tsc --noEmit",
-    "format-and-lint": "biome check . --error-on-warnings",
-    "knip": "knip",
-    "pgdelta": "node src/cli/bin/cli.ts",
-    "test": "vitest",
-    "version": "changeset version && pnpm install --no-frozen-lockfile && pnpm format-and-lint --write"
+    "typescript": "^5.9.3"
   }
-}
+}

package/src/cli/app.ts

@@ -0,0 +1,28 @@
+import { buildApplication, buildRouteMap } from "@stricli/core";
+import { applyCommand } from "./commands/apply.ts";
+import { planCommand } from "./commands/plan.ts";
+import { syncCommand } from "./commands/sync.ts";
+
+const root = buildRouteMap({
+  routes: {
+    plan: planCommand,
+    apply: applyCommand,
+    sync: syncCommand,
+  },
+  defaultCommand: "sync",
+  docs: {
+    brief: "PostgreSQL migrations made easy",
+    fullDescription: `
+pgdelta generates migration scripts by comparing two PostgreSQL databases.
+
+Commands:
+  plan   - Compute schema diff and preview changes
+  apply  - Apply a plan's migration script to a database
+  sync   - Plan and apply changes in one go
+    `.trim(),
+  },
+});
+
+export const app = buildApplication(root, {
+  name: "pgdelta",
+});

package/src/cli/bin/cli.ts

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+
+import { run } from "@stricli/core";
+import { app } from "../app.ts";
+
+await run(app, process.argv.slice(2), { process }).catch((error) => {
+  console.error(error);
+  process.exit(1);
+});

package/src/cli/commands/apply.ts

@@ -0,0 +1,101 @@
+/**
+ * Apply command - apply a plan's migration script to a target database.
+ */
+
+import { readFile } from "node:fs/promises";
+import { buildCommand, type CommandContext } from "@stricli/core";
+import { applyPlan } from "../../core/plan/apply.ts";
+import { deserializePlan, type Plan } from "../../core/plan/index.ts";
+import { handleApplyResult, validatePlanRisk } from "../utils.ts";
+
+export const applyCommand = buildCommand({
+  parameters: {
+    flags: {
+      plan: {
+        kind: "parsed",
+        brief: "Path to plan file (JSON format)",
+        parse: String,
+      },
+      source: {
+        kind: "parsed",
+        brief: "Source database connection URL (current state)",
+        parse: String,
+      },
+      target: {
+        kind: "parsed",
+        brief: "Target database connection URL (desired state)",
+        parse: String,
+      },
+      unsafe: {
+        kind: "boolean",
+        brief: "Allow data-loss operations (unsafe mode)",
+        optional: true,
+      },
+    },
+    aliases: {
+      p: "plan",
+      s: "source",
+      t: "target",
+      u: "unsafe",
+    },
+  },
+  docs: {
+    brief: "Apply a plan's migration script to a database",
+    fullDescription: `
+Apply changes from a plan file to a target database.
+
+The plan file should be a JSON file created with "pgdelta plan --output <file>.plan.json" (or any .plan/.json path).
+
+Safe by default: will refuse plans containing data-loss unless --unsafe is set.
+
+Exit codes:
+  0 - Success (changes applied)
+  1 - Error occurred
+    `.trim(),
+  },
+  async func(
+    this: CommandContext,
+    flags: {
+      plan: string;
+      source: string;
+      target: string;
+      unsafe?: boolean;
+    },
+  ) {
+    // Read and parse plan file
+    let planJson: string;
+    try {
+      planJson = await readFile(flags.plan, "utf-8");
+    } catch (error) {
+      this.process.stderr.write(
+        `Error reading plan file: ${error instanceof Error ? error.message : String(error)}\n`,
+      );
+      process.exitCode = 1;
+      return;
+    }
+
+    let plan: Plan;
+    try {
+      plan = deserializePlan(planJson);
+    } catch (error) {
+      this.process.stderr.write(
+        `Error parsing plan file: ${error instanceof Error ? error.message : String(error)}\n`,
+      );
+      process.exitCode = 1;
+      return;
+    }
+
+    const validation = validatePlanRisk(plan, !!flags.unsafe, this);
+    if (!validation.valid) {
+      process.exitCode = validation.exitCode ?? 1;
+      return;
+    }
+
+    const result = await applyPlan(plan, flags.source, flags.target, {
+      verifyPostApply: true,
+    });
+
+    const { exitCode } = handleApplyResult(result, this);
+    process.exitCode = exitCode;
+  },
+});