@supabase/pg-delta 1.0.0-alpha.2 → 1.0.0-alpha.20

package/src/cli/commands/plan.ts

@@ -0,0 +1,210 @@
+/**
+ * Plan command - compute schema diff and preview changes.
+ */
+
+import { writeFile } from "node:fs/promises";
+import { buildCommand, type CommandContext } from "@stricli/core";
+import { deserializeCatalog } from "../../core/catalog.snapshot.ts";
+import type { FilterDSL } from "../../core/integrations/filter/dsl.ts";
+import type { SerializeDSL } from "../../core/integrations/serialize/dsl.ts";
+import { createPlan } from "../../core/plan/index.ts";
+import type { SqlFormatOptions } from "../../core/plan/sql-format.ts";
+import { setCommandExitCode } from "../exit-code.ts";
+import { resolveIntegrationOptions } from "../utils/integrations.ts";
+import { isPostgresUrl, loadCatalogFromFile } from "../utils/resolve-input.ts";
+import { formatPlanForDisplay } from "../utils.ts";
+
+export const planCommand = buildCommand({
+  parameters: {
+    flags: {
+      source: {
+        kind: "parsed",
+        brief:
+          "Source (current state): postgres URL or catalog snapshot file path. Omit for empty baseline.",
+        parse: String,
+        optional: true,
+      },
+      target: {
+        kind: "parsed",
+        brief:
+          "Target (desired state): postgres URL or catalog snapshot file path",
+        parse: String,
+      },
+      format: {
+        kind: "enum",
+        brief: "Output format override: json (plan) or sql (script).",
+        values: ["json", "sql"] as const,
+        optional: true,
+      },
+      output: {
+        kind: "parsed",
+        brief:
+          "Write output to file (stdout by default). If format is not set: .sql infers sql, .json infers json, otherwise uses human output.",
+        parse: String,
+        optional: true,
+      },
+      role: {
+        kind: "parsed",
+        brief:
+          "Role to use when executing the migration (SET ROLE will be added to statements).",
+        parse: String,
+        optional: true,
+      },
+      filter: {
+        kind: "parsed",
+        brief:
+          'Filter DSL as inline JSON to filter changes (e.g., \'{"schema":"public"}\').',
+        parse: (value: string): FilterDSL => {
+          try {
+            return JSON.parse(value) as FilterDSL;
+          } catch (error) {
+            throw new Error(
+              `Invalid filter JSON: ${error instanceof Error ? error.message : String(error)}`,
+            );
+          }
+        },
+        optional: true,
+      },
+      serialize: {
+        kind: "parsed",
+        brief:
+          'Serialize DSL as inline JSON array (e.g., \'[{"when":{"type":"schema"},"options":{"skipAuthorization":true}}]\').',
+        parse: (value: string): SerializeDSL => {
+          try {
+            return JSON.parse(value) as SerializeDSL;
+          } catch (error) {
+            throw new Error(
+              `Invalid serialize JSON: ${error instanceof Error ? error.message : String(error)}`,
+            );
+          }
+        },
+        optional: true,
+      },
+      integration: {
+        kind: "parsed",
+        brief:
+          "Integration name (e.g., 'supabase') or path to integration JSON file (must end with .json). Loads from core/integrations/ or file path.",
+        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: string): SqlFormatOptions => {
+          try {
+            return JSON.parse(value) as SqlFormatOptions;
+          } catch (error) {
+            throw new Error(
+              `Invalid SQL format JSON: ${error instanceof Error ? error.message : String(error)}`,
+            );
+          }
+        },
+        optional: true,
+      },
+    },
+    aliases: {
+      s: "source",
+      t: "target",
+      o: "output",
+    },
+  },
+  docs: {
+    brief: "Compute schema diff and preview changes",
+    fullDescription: `
+Compute the schema diff between two PostgreSQL databases (source → target),
+and preview it for review or scripting. Defaults to tree display;
+json/sql outputs are available for artifacts or piping.
+    `.trim(),
+  },
+  async func(
+    this: CommandContext,
+    flags: {
+      source?: string;
+      target: string;
+      format?: "json" | "sql";
+      output?: string;
+      role?: string;
+      filter?: FilterDSL;
+      serialize?: SerializeDSL;
+      integration?: string;
+      "sql-format"?: boolean;
+      "sql-format-options"?: SqlFormatOptions;
+    },
+  ) {
+    const {
+      filter,
+      serialize,
+      emptyCatalog: integrationEmptyCatalog,
+    } = await resolveIntegrationOptions({
+      filter: flags.filter,
+      serialize: flags.serialize,
+      integration: flags.integration,
+    });
+
+    const resolvedSource = flags.source
+      ? isPostgresUrl(flags.source)
+        ? flags.source
+        : await loadCatalogFromFile(flags.source)
+      : integrationEmptyCatalog
+        ? deserializeCatalog(integrationEmptyCatalog)
+        : null;
+
+    const resolvedTarget = isPostgresUrl(flags.target)
+      ? flags.target
+      : await loadCatalogFromFile(flags.target);
+
+    const planResult = await createPlan(resolvedSource, resolvedTarget, {
+      role: flags.role,
+      filter,
+      serialize,
+    });
+    if (!planResult) {
+      this.process.stdout.write("No changes detected.\n");
+      return;
+    }
+
+    const outputPath = flags.output;
+    let effectiveFormat: "tree" | "json" | "sql";
+    if (flags.format) {
+      effectiveFormat = flags.format;
+    } else if (outputPath?.endsWith(".sql")) {
+      effectiveFormat = "sql";
+    } else if (outputPath?.endsWith(".json")) {
+      effectiveFormat = "json";
+    } else {
+      effectiveFormat = "tree";
+    }
+
+    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");
+      this.process.stdout.write(`${label} written to ${outputPath}\n`);
+    } else {
+      this.process.stdout.write(content);
+      if (!content.endsWith("\n")) {
+        this.process.stdout.write("\n");
+      }
+    }
+
+    // Exit code 2 indicates changes were detected
+    setCommandExitCode(2);
+  },
+});

package/src/cli/commands/sync.ts

@@ -0,0 +1,178 @@
+/**
+ * Sync command - plan and apply changes in one go with confirmation prompt.
+ */
+
+import { buildCommand, type CommandContext } from "@stricli/core";
+import type { FilterDSL } from "../../core/integrations/filter/dsl.ts";
+import type { SerializeDSL } from "../../core/integrations/serialize/dsl.ts";
+import { applyPlan } from "../../core/plan/apply.ts";
+import { createPlan } from "../../core/plan/index.ts";
+import { resolveIntegrationOptions } from "../utils/integrations.ts";
+import {
+  formatPlanForDisplay,
+  handleApplyResult,
+  promptConfirmation,
+  validatePlanRisk,
+} from "../utils.ts";
+
+export const syncCommand = buildCommand({
+  parameters: {
+    flags: {
+      source: {
+        kind: "parsed",
+        brief: "Source database connection URL (current state)",
+        parse: String,
+      },
+      target: {
+        kind: "parsed",
+        brief: "Target database connection URL (desired state)",
+        parse: String,
+      },
+      yes: {
+        kind: "boolean",
+        brief: "Skip confirmation prompt and apply changes automatically",
+        optional: true,
+      },
+      unsafe: {
+        kind: "boolean",
+        brief: "Allow data-loss operations (unsafe mode)",
+        optional: true,
+      },
+      role: {
+        kind: "parsed",
+        brief:
+          "Role to use when executing the migration (SET ROLE will be added to statements).",
+        parse: String,
+        optional: true,
+      },
+      filter: {
+        kind: "parsed",
+        brief:
+          'Filter DSL as inline JSON to filter changes (e.g., \'{"schema":"public"}\').',
+        parse: (value: string): FilterDSL => {
+          try {
+            return JSON.parse(value) as FilterDSL;
+          } catch (error) {
+            throw new Error(
+              `Invalid filter JSON: ${error instanceof Error ? error.message : String(error)}`,
+            );
+          }
+        },
+        optional: true,
+      },
+      serialize: {
+        kind: "parsed",
+        brief:
+          'Serialize DSL as inline JSON array (e.g., \'[{"when":{"type":"schema"},"options":{"skipAuthorization":true}}]\').',
+        parse: (value: string): SerializeDSL => {
+          try {
+            return JSON.parse(value) as SerializeDSL;
+          } catch (error) {
+            throw new Error(
+              `Invalid serialize JSON: ${error instanceof Error ? error.message : String(error)}`,
+            );
+          }
+        },
+        optional: true,
+      },
+      integration: {
+        kind: "parsed",
+        brief:
+          "Integration name (e.g., 'supabase') or path to integration JSON file (must end with .json). Loads from core/integrations/ or file path.",
+        parse: String,
+        optional: true,
+      },
+    },
+    aliases: {
+      s: "source",
+      t: "target",
+      y: "yes",
+      u: "unsafe",
+    },
+  },
+  docs: {
+    brief: "Plan and apply schema changes in one go",
+    fullDescription: `
+Compute the schema diff between two PostgreSQL databases (source → target),
+display the plan, prompt for confirmation, and apply changes if confirmed.
+
+Use --yes to skip the confirmation prompt and apply changes automatically.
+Safe by default: refuses data-loss changes unless --unsafe is set.
+
+Exit codes:
+  0 - Success (changes applied or no changes detected)
+  1 - Error occurred
+  2 - User cancelled or changes detected but not applied
+    `.trim(),
+  },
+  async func(
+    this: CommandContext,
+    flags: {
+      source: string;
+      target: string;
+      yes?: boolean;
+      unsafe?: boolean;
+      role?: string;
+      filter?: FilterDSL;
+      serialize?: SerializeDSL;
+      integration?: string;
+    },
+  ) {
+    const { filter, serialize } = await resolveIntegrationOptions({
+      filter: flags.filter,
+      serialize: flags.serialize,
+      integration: flags.integration,
+    });
+
+    // 1. Create the plan
+    const planResult = await createPlan(flags.source, flags.target, {
+      role: flags.role,
+      filter,
+      serialize,
+    });
+    if (!planResult) {
+      this.process.stdout.write("No changes detected.\n");
+      process.exitCode = 0;
+      return;
+    }
+
+    // 2. Display the plan
+    const { content } = formatPlanForDisplay(planResult, "tree");
+    this.process.stdout.write(content);
+
+    // 3. Validate risk (suppress warning since it's already shown in the plan)
+    const validation = validatePlanRisk(planResult.plan, !!flags.unsafe, this, {
+      suppressWarning: true,
+    });
+    if (!validation.valid) {
+      process.exitCode = validation.exitCode ?? 1;
+      return;
+    }
+
+    // 4. Prompt for confirmation (unless --yes)
+    if (!flags.yes) {
+      const confirmed = await promptConfirmation(
+        "Apply these changes? (y/N) ",
+        this,
+      );
+      if (!confirmed) {
+        process.exitCode = 2;
+        return;
+      }
+    }
+
+    // 5. Apply the plan
+    const result = await applyPlan(
+      planResult.plan,
+      flags.source,
+      flags.target,
+      {
+        verifyPostApply: true,
+      },
+    );
+
+    // 6. Handle apply result
+    const { exitCode } = handleApplyResult(result, this);
+    process.exitCode = exitCode;
+  },
+});

package/src/cli/exit-code.test.ts

@@ -0,0 +1,19 @@
+import { describe, expect, test } from "bun:test";
+import { getCommandExitCode, setCommandExitCode } from "./exit-code.ts";
+
+describe("exit-code", () => {
+  test("getCommandExitCode returns undefined when never set", () => {
+    expect(getCommandExitCode()).toBeUndefined();
+  });
+
+  test("setCommandExitCode then getCommandExitCode returns the value", () => {
+    setCommandExitCode(2);
+    expect(getCommandExitCode()).toBe(2);
+  });
+
+  test("setCommandExitCode overwrites previous value", () => {
+    setCommandExitCode(2);
+    setCommandExitCode(0);
+    expect(getCommandExitCode()).toBe(0);
+  });
+});

package/src/cli/exit-code.ts

@@ -0,0 +1,7 @@
+let _exitCode: number | undefined;
+export function setCommandExitCode(code: number) {
+  _exitCode = code;
+}
+export function getCommandExitCode() {
+  return _exitCode;
+}

package/src/cli/formatters/index.ts

@@ -0,0 +1,5 @@
+/**
+ * Formatters for displaying plans in various formats.
+ */
+
+export { formatTree } from "./tree/tree.ts";