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

package/dist/cli/utils/apply-display.js

@@ -0,0 +1,183 @@
+/**
+ * Display utilities for the declarative-apply command.
+ *
+ * Pure formatting and location-resolution functions — no CLI framework dependency.
+ * Used to:
+ * - Map pg-topo diagnostics into display items (optionally grouped by message/code).
+ * - Resolve statement IDs to file paths and line/column for error output.
+ * - Format StatementErrors in a pgAdmin-style multi-line block.
+ */
+import { readFile, stat } from "node:fs/promises";
+import path from "node:path";
+/**
+ * Convert a 1-based character offset in a string to 1-based line and column.
+ * Used when mapping PostgreSQL error positions (in SQL) to file locations.
+ */
+export function positionToLineColumn(sql, position) {
+    const lines = sql.split("\n");
+    let offset = 0;
+    for (let i = 0; i < lines.length; i++) {
+        const lineLen = lines[i].length + (i < lines.length - 1 ? 1 : 0);
+        if (position <= offset + lineLen) {
+            return { line: i + 1, column: position - offset };
+        }
+        offset += lineLen;
+    }
+    const last = lines.length;
+    const lastLineLen = lines[last - 1]?.length ?? 0;
+    return { line: last, column: lastLineLen + 1 };
+}
+/**
+ * Parse a statement id in the form "filePath:statementIndex" into components.
+ * The last colon separates path from index (paths may contain colons).
+ * Returns null if the format is invalid.
+ */
+function parseStatementId(id) {
+    const lastColon = id.lastIndexOf(":");
+    if (lastColon === -1)
+        return null;
+    const filePath = id.slice(0, lastColon);
+    const n = Number.parseInt(id.slice(lastColon + 1), 10);
+    if (!Number.isInteger(n) || n < 0)
+        return null;
+    return { filePath, statementIndex: n };
+}
+/** Extract requiredObjectKey from a pg-topo diagnostic if present and non-empty. */
+export const requiredObjectKeyFromDiagnostic = (diagnostic) => {
+    const value = diagnostic.details?.requiredObjectKey;
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+};
+/** Build a stable key for grouping diagnostics with the same code, message, and suggested fix. */
+const diagnosticDisplayGroupKey = (entry) => [
+    entry.diagnostic.code,
+    entry.diagnostic.message,
+    entry.diagnostic.suggestedFix ?? "",
+    entry.requiredObjectKey ?? "",
+].join("\u0000");
+/**
+ * Turn diagnostic entries into display items. If grouped is true, entries with
+ * the same code/message/suggestedFix are merged into one item with multiple locations.
+ */
+export const buildDiagnosticDisplayItems = (entries, grouped) => {
+    if (!grouped) {
+        return entries.map((entry) => ({
+            code: entry.diagnostic.code,
+            message: entry.diagnostic.message,
+            suggestedFix: entry.diagnostic.suggestedFix,
+            requiredObjectKey: entry.requiredObjectKey,
+            locations: entry.location ? [entry.location] : [],
+        }));
+    }
+    const groupedItems = new Map();
+    for (const entry of entries) {
+        const key = diagnosticDisplayGroupKey(entry);
+        const existing = groupedItems.get(key);
+        if (!existing) {
+            groupedItems.set(key, {
+                code: entry.diagnostic.code,
+                message: entry.diagnostic.message,
+                suggestedFix: entry.diagnostic.suggestedFix,
+                requiredObjectKey: entry.requiredObjectKey,
+                locations: entry.location ? [entry.location] : [],
+            });
+            continue;
+        }
+        if (entry.location && !existing.locations.includes(entry.location)) {
+            existing.locations.push(entry.location);
+        }
+    }
+    return [...groupedItems.values()];
+};
+/**
+ * Resolve the full path to a .sql file from the schema path (directory or single file)
+ * and a relative file path (e.g. from a statement id). If schemaPath is a file, its
+ * directory is used as the base.
+ */
+export async function resolveSqlFilePath(schemaPath, relativeFilePath) {
+    try {
+        const statResult = await stat(schemaPath);
+        const baseDir = statResult.isFile() ? path.dirname(schemaPath) : schemaPath;
+        return path.join(baseDir, relativeFilePath);
+    }
+    catch {
+        return path.join(schemaPath, relativeFilePath);
+    }
+}
+/**
+ * Find the 0-based start offset of statementSql in fileContent.
+ * Tries exact match first, then trimmed match. Returns -1 if not found.
+ */
+function findStatementStartInFile(fileContent, statementSql) {
+    const exact = fileContent.indexOf(statementSql);
+    if (exact !== -1)
+        return exact;
+    const trimmedStmt = statementSql.trim();
+    if (!trimmedStmt)
+        return -1;
+    const trimmed = fileContent.indexOf(trimmedStmt);
+    if (trimmed !== -1)
+        return trimmed;
+    return -1;
+}
+/**
+ * Format a StatementError in pgAdmin-style: ERROR, Detail, SQL state, optional
+ * Context, Hint, and Location (resolving the .sql file and line/column when possible).
+ */
+export async function formatStatementError(err, schemaPath) {
+    const lines = [];
+    lines.push(`ERROR:  ${err.message}`);
+    if (err.detail) {
+        lines.push(`Detail: ${err.detail}`);
+    }
+    lines.push(`SQL state: ${err.code}`);
+    if (err.position !== undefined && err.statement.sql.length > 0) {
+        lines.push(`Character: ${err.position}`);
+        const pos = Math.max(0, Math.min(err.position - 1, err.statement.sql.length));
+        const contextStart = Math.max(0, pos - 40);
+        const contextEnd = Math.min(err.statement.sql.length, pos + 40);
+        const snippet = err.statement.sql.slice(contextStart, contextEnd);
+        const oneLine = snippet.replace(/\s+/g, " ").trim();
+        lines.push(`Context: ${oneLine || "(empty)"}`);
+    }
+    if (err.hint) {
+        lines.push(`Hint: ${err.hint}`);
+    }
+    const parsed = parseStatementId(err.statement.id);
+    if (parsed) {
+        let locationLine;
+        try {
+            const fullPath = await resolveSqlFilePath(schemaPath, parsed.filePath);
+            const fileContent = await readFile(fullPath, "utf-8");
+            const statementStart = findStatementStartInFile(fileContent, err.statement.sql);
+            if (statementStart !== -1) {
+                if (err.position !== undefined && err.statement.sql.length > 0) {
+                    const fileErrorOffset = statementStart + (err.position - 1);
+                    const fileErrorPosition = Math.min(fileErrorOffset + 1, fileContent.length);
+                    const { line, column } = positionToLineColumn(fileContent, Math.max(1, fileErrorPosition));
+                    locationLine = `Location: ${parsed.filePath}:${line}:${column}`;
+                }
+                else {
+                    const { line } = positionToLineColumn(fileContent, statementStart + 1);
+                    locationLine = `Location: ${parsed.filePath}:${line}`;
+                }
+            }
+            else {
+                locationLine = `Location: ${parsed.filePath} (statement ${parsed.statementIndex})`;
+            }
+        }
+        catch {
+            if (err.position !== undefined && err.statement.sql.length > 0) {
+                const { line, column } = positionToLineColumn(err.statement.sql, err.position);
+                locationLine = `Location: ${parsed.filePath} (statement ${parsed.statementIndex}, line ${line}, column ${column})`;
+            }
+            else {
+                locationLine = `Location: ${parsed.filePath} (statement ${parsed.statementIndex})`;
+            }
+        }
+        lines.push(locationLine);
+    }
+    else {
+        lines.push(`Location: ${err.statement.id}`);
+    }
+    return lines.map((l) => `  ${l}`).join("\n");
+}

package/dist/cli/utils/export-display.d.ts

@@ -0,0 +1,43 @@
+/**
+ * CLI helpers for declarative export: file tree, diff, and summary formatting.
+ */
+import type { FileEntry } from "../../core/export/types.ts";
+/**
+ * Ensure a relative file path does not escape the output directory.
+ * Uses Node.js path.resolve + startsWith as the canonical traversal check.
+ */
+export declare function assertSafePath(filePath: string, outputDir: string): void;
+interface FileDiffResult {
+    created: string[];
+    updated: string[];
+    deleted: string[];
+    unchanged: string[];
+}
+interface BuildFileTreeOptions {
+    /** When provided, leaf paths are prefixed with + / ~ / - and colorized (created / updated / deleted). */
+    diff?: FileDiffResult;
+    /** When true, only paths that are created, updated, or deleted are shown; unchanged are omitted. Includes diff.deleted in the tree. */
+    diffFocus?: boolean;
+}
+/**
+ * Build a directory tree string from file paths.
+ * Groups by directory, shows files as leaves with indentation.
+ * When options.diff is provided, leaf names are prefixed with + (created), ~ (updated), - (deleted) and colorized.
+ * When options.diffFocus is true, only changed paths (and their ancestors) are shown; unchanged files are omitted.
+ *
+ * @param files - Array of relative file paths (e.g. ["schemas/public/schema.sql", "schemas/public/tables/users.sql"])
+ * @param outputDir - Display name for the root (e.g. "declarative-schemas")
+ * @param options - Optional diff and diffFocus for symbols and filtering
+ */
+export declare function buildFileTree(files: string[], outputDir: string, options?: BuildFileTreeOptions): string;
+/**
+ * Compare existing output directory with new file set.
+ * Returns created, updated, deleted, and unchanged paths.
+ */
+export declare function computeFileDiff(outputDir: string, newFiles: FileEntry[]): Promise<FileDiffResult>;
+/**
+ * Format the created/deleted/updated summary with colors.
+ * In dry-run mode, uses "would create/delete/update" phrasing.
+ */
+export declare function formatExportSummary(diff: FileDiffResult, dryRun: boolean): string;
+export {};

package/dist/cli/utils/export-display.js

@@ -0,0 +1,202 @@
+/**
+ * CLI helpers for declarative export: file tree, diff, and summary formatting.
+ */
+import { readdir, readFile } from "node:fs/promises";
+import path from "node:path";
+import chalk from "chalk";
+// ============================================================================
+// Path safety
+// ============================================================================
+/**
+ * Ensure a relative file path does not escape the output directory.
+ * Uses Node.js path.resolve + startsWith as the canonical traversal check.
+ */
+export function assertSafePath(filePath, outputDir) {
+    const resolvedOutput = path.resolve(outputDir);
+    const resolvedFile = path.resolve(outputDir, filePath);
+    if (resolvedFile !== resolvedOutput &&
+        !resolvedFile.startsWith(resolvedOutput + path.sep)) {
+        throw new Error(`Export path traversal detected: '${filePath}' resolves outside output directory`);
+    }
+}
+function getFileStatus(path, diff) {
+    if (diff.created.includes(path))
+        return "created";
+    if (diff.updated.includes(path))
+        return "updated";
+    if (diff.deleted.includes(path))
+        return "deleted";
+    return "unchanged";
+}
+function formatLeafSegment(segment, status) {
+    switch (status) {
+        case "created":
+            return chalk.green(`+ ${segment}`);
+        case "updated":
+            return chalk.yellow(`~ ${segment}`);
+        case "deleted":
+            return chalk.red(`- ${segment}`);
+        default:
+            return chalk.dim(segment);
+    }
+}
+/**
+ * Build a directory tree string from file paths.
+ * Groups by directory, shows files as leaves with indentation.
+ * When options.diff is provided, leaf names are prefixed with + (created), ~ (updated), - (deleted) and colorized.
+ * When options.diffFocus is true, only changed paths (and their ancestors) are shown; unchanged files are omitted.
+ *
+ * @param files - Array of relative file paths (e.g. ["schemas/public/schema.sql", "schemas/public/tables/users.sql"])
+ * @param outputDir - Display name for the root (e.g. "declarative-schemas")
+ * @param options - Optional diff and diffFocus for symbols and filtering
+ */
+export function buildFileTree(files, outputDir, options) {
+    const { diff, diffFocus } = options ?? {};
+    let pathsToShow = files;
+    if (diffFocus && diff) {
+        const changed = new Set([
+            ...diff.created,
+            ...diff.updated,
+            ...diff.deleted,
+        ]);
+        pathsToShow = [...changed];
+        if (pathsToShow.length === 0) {
+            return chalk.dim("(no file changes)");
+        }
+    }
+    const tree = new Map();
+    for (const filePath of pathsToShow) {
+        const segments = filePath.split("/");
+        let parent = "";
+        for (let i = 0; i < segments.length; i++) {
+            const segment = segments[i];
+            const fullPath = parent ? `${parent}/${segment}` : segment;
+            let children = tree.get(parent);
+            if (!children) {
+                children = new Set();
+                tree.set(parent, children);
+            }
+            children.add(fullPath);
+            parent = fullPath;
+        }
+    }
+    const lines = [];
+    function emit(relPath, indent, isLast) {
+        const segment = relPath ? path.basename(relPath) : outputDir;
+        const prefix = indent === 0 ? "" : "  ".repeat(indent) + (isLast ? "└── " : "├── ");
+        const isLeaf = !tree.has(relPath);
+        const displaySegment = diff && isLeaf
+            ? formatLeafSegment(segment, getFileStatus(relPath, diff))
+            : segment;
+        lines.push(prefix + displaySegment);
+        const children = tree.get(relPath);
+        if (children) {
+            const sorted = [...children].sort((a, b) => path.basename(a).localeCompare(path.basename(b)));
+            for (let i = 0; i < sorted.length; i++) {
+                emit(sorted[i], indent + 1, i === sorted.length - 1);
+            }
+        }
+    }
+    emit("", 0, false);
+    return lines.join("\n");
+}
+// ============================================================================
+// File diff
+// ============================================================================
+/**
+ * Recursively collect relative paths of managed (.sql) files under a directory.
+ * Non-SQL files (README, .gitkeep, etc.) are intentionally excluded so they
+ * are never flagged as "deleted" during diff.
+ */
+async function collectExistingFiles(dir, base = "") {
+    const entries = await readdir(path.join(dir, base), { withFileTypes: true });
+    const files = [];
+    for (const e of entries) {
+        const rel = base ? `${base}/${e.name}` : e.name;
+        if (e.isFile() && e.name.endsWith(".sql")) {
+            files.push(rel);
+        }
+        else if (e.isDirectory()) {
+            files.push(...(await collectExistingFiles(dir, rel)));
+        }
+    }
+    return files;
+}
+/**
+ * Compare existing output directory with new file set.
+ * Returns created, updated, deleted, and unchanged paths.
+ */
+export async function computeFileDiff(outputDir, newFiles) {
+    const newPaths = new Set(newFiles.map((f) => f.path));
+    const newByPath = new Map(newFiles.map((f) => [f.path, f]));
+    let existingPaths = [];
+    try {
+        existingPaths = await collectExistingFiles(outputDir);
+    }
+    catch {
+        // Directory doesn't exist or not readable
+        return {
+            created: [...newPaths],
+            updated: [],
+            deleted: [],
+            unchanged: [],
+        };
+    }
+    const existingSet = new Set(existingPaths);
+    const created = [];
+    const updated = [];
+    const deleted = [];
+    const unchanged = [];
+    for (const p of newPaths) {
+        if (!existingSet.has(p)) {
+            created.push(p);
+        }
+        else {
+            const entry = newByPath.get(p);
+            if (!entry)
+                continue;
+            try {
+                const existingContent = await readFile(path.join(outputDir, p), "utf-8");
+                if (existingContent.trim() !== entry.sql.trim()) {
+                    updated.push(p);
+                }
+                else {
+                    unchanged.push(p);
+                }
+            }
+            catch {
+                updated.push(p);
+            }
+        }
+    }
+    for (const p of existingPaths) {
+        if (!newPaths.has(p)) {
+            deleted.push(p);
+        }
+    }
+    return { created, updated, deleted, unchanged };
+}
+// ============================================================================
+// Summary formatting
+// ============================================================================
+/**
+ * Format the created/deleted/updated summary with colors.
+ * In dry-run mode, uses "would create/delete/update" phrasing.
+ */
+export function formatExportSummary(diff, dryRun) {
+    const lines = [];
+    const verb = dryRun ? "Would" : "";
+    if (diff.created.length > 0) {
+        lines.push(chalk.green(`${verb ? `${verb} create` : "Created"}: ${diff.created.length} file(s)`));
+    }
+    if (diff.updated.length > 0) {
+        lines.push(chalk.yellow(`${verb ? `${verb} update` : "Updated"}: ${diff.updated.length} file(s)`));
+    }
+    if (diff.deleted.length > 0) {
+        lines.push(chalk.red(`${verb ? `${verb} delete` : "Deleted"}: ${diff.deleted.length} file(s)`));
+    }
+    if (diff.unchanged.length > 0 && !dryRun) {
+        lines.push(chalk.dim(`Unchanged: ${diff.unchanged.length} file(s)`));
+    }
+    return lines.length > 0 ? lines.join("\n") : "";
+}

package/dist/cli/utils/integrations.d.ts

@@ -1,14 +1,38 @@
 /**
  * Utilities for loading integrations from files.
  */
+import type { CatalogSnapshot } from "../../core/catalog.snapshot.ts";
+import type { FilterDSL } from "../../core/integrations/filter/dsl.ts";
 import type { IntegrationDSL } from "../../core/integrations/integration-dsl.ts";
+import type { SerializeDSL } from "../../core/integrations/serialize/dsl.ts";
 /**
- * Load an integration DSL from a file or core integration.
- * If the path ends with .json, treats it as a JSON file path directly.
- * Otherwise, tries to load from core integrations (TypeScript) first,
- * then falls back to treating as a JSON file path.
+ * Load an integration DSL, recursively resolving `extends` chains.
  *
- * @param nameOrPath - Integration name (e.g., "supabase") or file path (e.g., "./my-integration.json")
- * @returns The loaded IntegrationDSL
+ * When an integration has `extends`, the referenced integration(s) are loaded
+ * and merged: filters are AND-combined, serialize rules concatenated (base first),
+ * and emptyCatalog uses the most-specific value.
+ *
+ * Circular extends are detected and rejected with a descriptive error.
+ *
+ * @param nameOrPath - Integration name (e.g., "supabase") or file path
+ * @returns The fully resolved IntegrationDSL
  */
 export declare function loadIntegrationDSL(nameOrPath: string): Promise<IntegrationDSL>;
+interface ResolvedIntegrationOptions {
+    filter?: FilterDSL;
+    serialize?: SerializeDSL;
+    emptyCatalog?: CatalogSnapshot;
+}
+/**
+ * Load an integration (if provided) and merge its filter/serialize with CLI flags.
+ *
+ * - Filters are AND-combined (integration ∧ CLI flag)
+ * - Serialize rules are concatenated (integration first = higher priority)
+ * - emptyCatalog is extracted from the integration
+ */
+export declare function resolveIntegrationOptions(options: {
+    filter?: FilterDSL;
+    serialize?: SerializeDSL;
+    integration?: string;
+}): Promise<ResolvedIntegrationOptions>;
+export {};

package/dist/cli/utils/integrations.js

@@ -10,16 +10,14 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
     return path;
 };
 import { readFile } from "node:fs/promises";
+import { mergeIntegrations } from "../../core/integrations/merge.js";
 /**
- * Load an integration DSL from a file or core integration.
- * If the path ends with .json, treats it as a JSON file path directly.
- * Otherwise, tries to load from core integrations (TypeScript) first,
- * then falls back to treating as a JSON file path.
+ * Load a raw integration DSL from a file or core integration (without resolving extends).
  *
  * @param nameOrPath - Integration name (e.g., "supabase") or file path (e.g., "./my-integration.json")
- * @returns The loaded IntegrationDSL
+ * @returns The loaded IntegrationDSL (unresolved)
  */
-export async function loadIntegrationDSL(nameOrPath) {
+async function loadRawIntegrationDSL(nameOrPath) {
     // If path ends with .json, treat it as a JSON file path directly
     if (nameOrPath.endsWith(".json")) {
         const content = await readFile(nameOrPath, "utf-8");
@@ -42,3 +40,97 @@ export async function loadIntegrationDSL(nameOrPath) {
     const content = await readFile(nameOrPath, "utf-8");
     return JSON.parse(content);
 }
+/**
+ * Load a core integration DSL by name only (no file path fallback).
+ *
+ * Used for resolving `extends` chains, which only support core integration names
+ * (e.g., "supabase"), not file paths.
+ *
+ * @param name - Core integration name (e.g., "supabase")
+ * @returns The loaded IntegrationDSL (unresolved)
+ */
+async function loadCoreIntegrationDSL(name) {
+    try {
+        const module = await import(__rewriteRelativeImportExtension(`../../core/integrations/${name}.ts`));
+        if (name in module) {
+            return module[name];
+        }
+    }
+    catch {
+        // Module not found
+    }
+    throw new Error(`Unknown core integration: "${name}". extends only supports core integration names (e.g., "supabase").`);
+}
+/**
+ * Load an integration DSL, recursively resolving `extends` chains.
+ *
+ * When an integration has `extends`, the referenced integration(s) are loaded
+ * and merged: filters are AND-combined, serialize rules concatenated (base first),
+ * and emptyCatalog uses the most-specific value.
+ *
+ * Circular extends are detected and rejected with a descriptive error.
+ *
+ * @param nameOrPath - Integration name (e.g., "supabase") or file path
+ * @returns The fully resolved IntegrationDSL
+ */
+export async function loadIntegrationDSL(nameOrPath) {
+    return resolveIntegration(nameOrPath, new Set());
+}
+async function resolveIntegration(nameOrPath, visited, preloadedRaw) {
+    if (visited.has(nameOrPath)) {
+        throw new Error(`Circular extends detected: ${[...visited, nameOrPath].join(" → ")}`);
+    }
+    visited.add(nameOrPath);
+    const raw = preloadedRaw ?? (await loadRawIntegrationDSL(nameOrPath));
+    if (!raw.extends) {
+        return raw;
+    }
+    // Resolve base integrations (extends only supports core integration names)
+    const extendsArray = Array.isArray(raw.extends) ? raw.extends : [raw.extends];
+    const baseIntegrations = [];
+    for (const baseName of extendsArray) {
+        const baseRaw = await loadCoreIntegrationDSL(baseName);
+        baseIntegrations.push(await resolveIntegration(baseName, new Set(visited), baseRaw));
+    }
+    // Remove extends from the current integration before merging
+    const { extends: _, ...current } = raw;
+    // Merge: bases first (higher priority serialize), then current (most-specific)
+    return mergeIntegrations([...baseIntegrations, current]);
+}
+/**
+ * Load an integration (if provided) and merge its filter/serialize with CLI flags.
+ *
+ * - Filters are AND-combined (integration ∧ CLI flag)
+ * - Serialize rules are concatenated (integration first = higher priority)
+ * - emptyCatalog is extracted from the integration
+ */
+export async function resolveIntegrationOptions(options) {
+    if (!options.integration) {
+        return {
+            filter: options.filter,
+            serialize: options.serialize,
+        };
+    }
+    const integrationDSL = await loadIntegrationDSL(options.integration);
+    // AND-combine integration filter with CLI --filter
+    let filter;
+    if (integrationDSL.filter && options.filter) {
+        filter = { and: [integrationDSL.filter, options.filter] };
+    }
+    else {
+        filter = options.filter ?? integrationDSL.filter;
+    }
+    // Concatenate serialize rules (integration first = higher priority)
+    let serialize;
+    if (integrationDSL.serialize && options.serialize) {
+        serialize = [...integrationDSL.serialize, ...options.serialize];
+    }
+    else {
+        serialize = options.serialize ?? integrationDSL.serialize;
+    }
+    return {
+        filter,
+        serialize,
+        emptyCatalog: integrationDSL.emptyCatalog,
+    };
+}

package/dist/cli/utils/resolve-input.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Shared utilities for resolving CLI --source/--target inputs that
+ * can be either a PostgreSQL connection URL or a catalog snapshot file path.
+ */
+import type { Catalog } from "../../core/catalog.model.ts";
+export declare function isPostgresUrl(input: string): boolean;
+export declare function loadCatalogFromFile(path: string): Promise<Catalog>;

package/dist/cli/utils/resolve-input.js

@@ -0,0 +1,13 @@
+/**
+ * Shared utilities for resolving CLI --source/--target inputs that
+ * can be either a PostgreSQL connection URL or a catalog snapshot file path.
+ */
+import { readFile } from "node:fs/promises";
+import { deserializeCatalog } from "../../core/catalog.snapshot.js";
+export function isPostgresUrl(input) {
+    return input.startsWith("postgres://") || input.startsWith("postgresql://");
+}
+export async function loadCatalogFromFile(path) {
+    const json = await readFile(path, "utf-8");
+    return deserializeCatalog(JSON.parse(json));
+}

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;
@@ -17,11 +18,14 @@ type ApplyPlanResult = {
 } | {
     status: "applied";
     statements: number;
+    units: number;
     warnings?: string[];
 } | {
     status: "failed";
     error: unknown;
     script: string;
+    failedUnitIndex?: number;
+    completedUnits: number;
 };
 type PlanResult = {
     plan: Plan;
@@ -31,6 +35,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

@@ -5,8 +5,8 @@ import { createInterface } from "node:readline";
 import chalk from "chalk";
 import { groupChangesHierarchically } from "../core/plan/hierarchy.js";
 import { serializePlan } from "../core/plan/index.js";
+import { renderPlanSql } from "../core/plan/render.js";
 import { classifyChangesRisk } from "../core/plan/risk.js";
-import { formatSqlScript } from "../core/plan/statements.js";
 import { formatTree } from "./formatters/index.js";
 /**
  * Formats a plan result for display in various formats.
@@ -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),
+                renderPlanSql(plan, { sqlFormatOptions: options.sqlFormatOptions }),
             ].join("\n");
             return { content, label: "Migration script" };
         }
@@ -123,11 +123,14 @@ export function handleApplyResult(result, context) {
             return { exitCode: 0 };
         case "failed": {
             context.process.stderr.write(`Failed to apply changes: ${result.error instanceof Error ? result.error.message : String(result.error)}\n`);
+            if (result.failedUnitIndex !== undefined) {
+                context.process.stderr.write(`Failed in migration unit ${result.failedUnitIndex + 1} (${result.completedUnits} unit${result.completedUnits === 1 ? "" : "s"} already committed).\n`);
+            }
             context.process.stderr.write(`Migration script:\n${result.script}\n`);
             return { exitCode: 1 };
         }
         case "applied": {
-            context.process.stdout.write(`Applying ${result.statements} changes to database...\n`);
+            context.process.stdout.write(`Applied ${result.statements} change${result.statements === 1 ? "" : "s"} across ${result.units} migration unit${result.units === 1 ? "" : "s"}.\n`);
             context.process.stdout.write("Successfully applied all changes.\n");
             if (result.warnings?.length) {
                 for (const warning of result.warnings) {