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

package/src/cli/utils/apply-display.test.ts

@@ -0,0 +1,348 @@
+import { describe, expect, test } from "bun:test";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import type { Diagnostic, DiagnosticCode } from "@supabase/pg-topo";
+import type { StatementError } from "../../core/declarative-apply/round-apply.ts";
+import {
+  buildDiagnosticDisplayItems,
+  type DiagnosticDisplayEntry,
+  formatStatementError,
+  positionToLineColumn,
+  requiredObjectKeyFromDiagnostic,
+  resolveSqlFilePath,
+} from "./apply-display.ts";
+
+describe("positionToLineColumn", () => {
+  test("single line, position at start", () => {
+    expect(positionToLineColumn("hello", 1)).toEqual({ line: 1, column: 1 });
+  });
+
+  test("single line, position in the middle", () => {
+    expect(positionToLineColumn("hello", 3)).toEqual({ line: 1, column: 3 });
+  });
+
+  test("single line, position at end", () => {
+    expect(positionToLineColumn("hello", 5)).toEqual({ line: 1, column: 5 });
+  });
+
+  test("multi-line, first line", () => {
+    expect(positionToLineColumn("ab\ncd\nef", 2)).toEqual({
+      line: 1,
+      column: 2,
+    });
+  });
+
+  test("multi-line, second line start", () => {
+    expect(positionToLineColumn("ab\ncd\nef", 4)).toEqual({
+      line: 2,
+      column: 1,
+    });
+  });
+
+  test("multi-line, third line", () => {
+    expect(positionToLineColumn("ab\ncd\nef", 7)).toEqual({
+      line: 3,
+      column: 1,
+    });
+  });
+
+  test("position past end falls back to last line", () => {
+    expect(positionToLineColumn("ab\ncd", 100)).toEqual({
+      line: 2,
+      column: 3,
+    });
+  });
+
+  test("empty string", () => {
+    expect(positionToLineColumn("", 1)).toEqual({ line: 1, column: 1 });
+  });
+});
+
+describe("requiredObjectKeyFromDiagnostic", () => {
+  test("returns value when present and non-empty", () => {
+    const diag: Diagnostic = {
+      code: "UNRESOLVED_DEPENDENCY",
+      message: "warning",
+      details: { requiredObjectKey: "public.users" },
+    };
+    expect(requiredObjectKeyFromDiagnostic(diag)).toBe("public.users");
+  });
+
+  test("returns undefined for empty string", () => {
+    const diag: Diagnostic = {
+      code: "UNRESOLVED_DEPENDENCY",
+      message: "warning",
+      details: { requiredObjectKey: "" },
+    };
+    expect(requiredObjectKeyFromDiagnostic(diag)).toBeUndefined();
+  });
+
+  test("returns undefined when details is undefined", () => {
+    const diag: Diagnostic = {
+      code: "UNRESOLVED_DEPENDENCY",
+      message: "warning",
+    };
+    expect(requiredObjectKeyFromDiagnostic(diag)).toBeUndefined();
+  });
+
+  test("returns undefined for non-string value", () => {
+    const diag: Diagnostic = {
+      code: "UNRESOLVED_DEPENDENCY",
+      message: "warning",
+      details: { requiredObjectKey: 42 },
+    };
+    expect(requiredObjectKeyFromDiagnostic(diag)).toBeUndefined();
+  });
+});
+
+describe("buildDiagnosticDisplayItems", () => {
+  const makeDiag = (
+    code: DiagnosticCode,
+    message: string,
+    suggestedFix?: string,
+  ): Diagnostic => ({ code, message, suggestedFix });
+
+  test("ungrouped mode returns one item per entry", () => {
+    const entries: DiagnosticDisplayEntry[] = [
+      {
+        diagnostic: makeDiag("PARSE_ERROR", "err1"),
+        location: "file1.sql:1",
+      },
+      {
+        diagnostic: makeDiag("PARSE_ERROR", "err1"),
+        location: "file2.sql:5",
+      },
+    ];
+    const items = buildDiagnosticDisplayItems(entries, false);
+    expect(items).toHaveLength(2);
+    expect(items[0].locations).toEqual(["file1.sql:1"]);
+    expect(items[1].locations).toEqual(["file2.sql:5"]);
+  });
+
+  test("ungrouped mode: entry without location gets empty locations array", () => {
+    const entries: DiagnosticDisplayEntry[] = [
+      { diagnostic: makeDiag("PARSE_ERROR", "err1") },
+    ];
+    const items = buildDiagnosticDisplayItems(entries, false);
+    expect(items[0].locations).toEqual([]);
+  });
+
+  test("grouped mode merges same code/message entries", () => {
+    const entries: DiagnosticDisplayEntry[] = [
+      { diagnostic: makeDiag("PARSE_ERROR", "err1"), location: "a.sql:1" },
+      { diagnostic: makeDiag("PARSE_ERROR", "err1"), location: "b.sql:2" },
+      {
+        diagnostic: makeDiag("UNRESOLVED_DEPENDENCY", "err2", "fix it"),
+        location: "c.sql:3",
+      },
+    ];
+    const items = buildDiagnosticDisplayItems(entries, true);
+    expect(items).toHaveLength(2);
+    expect(items[0].locations).toEqual(["a.sql:1", "b.sql:2"]);
+    expect(items[1].code).toBe("UNRESOLVED_DEPENDENCY");
+    expect(items[1].suggestedFix).toBe("fix it");
+  });
+
+  test("grouped mode: entry without location gets empty locations", () => {
+    const entries: DiagnosticDisplayEntry[] = [
+      { diagnostic: makeDiag("PARSE_ERROR", "err1") },
+    ];
+    const items = buildDiagnosticDisplayItems(entries, true);
+    expect(items[0].locations).toEqual([]);
+  });
+
+  test("grouped mode deduplicates identical locations", () => {
+    const entries: DiagnosticDisplayEntry[] = [
+      { diagnostic: makeDiag("PARSE_ERROR", "err1"), location: "a.sql:1" },
+      { diagnostic: makeDiag("PARSE_ERROR", "err1"), location: "a.sql:1" },
+    ];
+    const items = buildDiagnosticDisplayItems(entries, true);
+    expect(items[0].locations).toEqual(["a.sql:1"]);
+  });
+
+  test("grouped mode preserves requiredObjectKey in group key", () => {
+    const entries: DiagnosticDisplayEntry[] = [
+      {
+        diagnostic: makeDiag("PARSE_ERROR", "err1"),
+        location: "a.sql:1",
+        requiredObjectKey: "key1",
+      },
+      {
+        diagnostic: makeDiag("PARSE_ERROR", "err1"),
+        location: "b.sql:2",
+        requiredObjectKey: "key2",
+      },
+    ];
+    const items = buildDiagnosticDisplayItems(entries, true);
+    expect(items).toHaveLength(2);
+    expect(items[0].requiredObjectKey).toBe("key1");
+    expect(items[1].requiredObjectKey).toBe("key2");
+  });
+});
+
+describe("resolveSqlFilePath", () => {
+  test("schemaPath is a directory", async () => {
+    const dir = await mkdtemp(path.join(tmpdir(), "pgd-apply-test-"));
+    try {
+      const result = await resolveSqlFilePath(dir, "schemas/table.sql");
+      expect(result).toBe(path.join(dir, "schemas/table.sql"));
+    } finally {
+      await rm(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("schemaPath is a file uses dirname", async () => {
+    const dir = await mkdtemp(path.join(tmpdir(), "pgd-apply-test-"));
+    try {
+      const filePath = path.join(dir, "schema.sql");
+      await writeFile(filePath, "");
+      const result = await resolveSqlFilePath(filePath, "schemas/table.sql");
+      expect(result).toBe(path.join(dir, "schemas/table.sql"));
+    } finally {
+      await rm(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("stat throws falls back to joining schemaPath as dir", async () => {
+    const result = await resolveSqlFilePath("/nonexistent/path", "table.sql");
+    expect(result).toBe(path.join("/nonexistent/path", "table.sql"));
+  });
+});
+
+describe("formatStatementError", () => {
+  function makeErr(
+    overrides: Partial<StatementError> & {
+      id?: string;
+      sql?: string;
+    } = {},
+  ): StatementError {
+    const { id, sql, ...rest } = overrides;
+    return {
+      message: "something failed",
+      code: "42601",
+      isDependencyError: false,
+      statement: { id: id ?? "raw-statement", sql: sql ?? "" },
+      ...rest,
+    };
+  }
+
+  test("minimal error with unparseable id", async () => {
+    const result = await formatStatementError(
+      makeErr({ id: "no-colon-here" }),
+      "/tmp",
+    );
+    expect(result).toContain("ERROR:  something failed");
+    expect(result).toContain("SQL state: 42601");
+    expect(result).toContain("Location: no-colon-here");
+    expect(result).not.toContain("Detail:");
+    expect(result).not.toContain("Hint:");
+    expect(result).not.toContain("Character:");
+  });
+
+  test("includes detail and hint when present", async () => {
+    const result = await formatStatementError(
+      makeErr({ detail: "some detail", hint: "try this" }),
+      "/tmp",
+    );
+    expect(result).toContain("Detail: some detail");
+    expect(result).toContain("Hint: try this");
+  });
+
+  test("includes Character and Context when position is set", async () => {
+    const sql = "SELECT * FROM missing_table WHERE id = 1";
+    const result = await formatStatementError(
+      makeErr({ position: 15, sql, id: "raw-id" }),
+      "/tmp",
+    );
+    expect(result).toContain("Character: 15");
+    expect(result).toContain("Context:");
+  });
+
+  test("parseable id with file containing the SQL resolves line:col", async () => {
+    const dir = await mkdtemp(path.join(tmpdir(), "pgd-apply-test-"));
+    try {
+      const sql = "CREATE TABLE foo (id int);";
+      const fileContent = `-- header\n\n${sql}\n`;
+      await writeFile(path.join(dir, "tables.sql"), fileContent);
+
+      const result = await formatStatementError(
+        makeErr({ id: "tables.sql:0", sql, position: 14 }),
+        dir,
+      );
+      expect(result).toMatch(/Location: tables\.sql:\d+:\d+/);
+    } finally {
+      await rm(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("parseable id with file containing SQL but no position resolves line only", async () => {
+    const dir = await mkdtemp(path.join(tmpdir(), "pgd-apply-test-"));
+    try {
+      const sql = "CREATE TABLE bar (id int);";
+      const fileContent = `-- header\n${sql}\n`;
+      await writeFile(path.join(dir, "tables.sql"), fileContent);
+
+      const result = await formatStatementError(
+        makeErr({ id: "tables.sql:0", sql }),
+        dir,
+      );
+      expect(result).toMatch(/Location: tables\.sql:\d+$/m);
+      expect(result).not.toMatch(/Location: tables\.sql:\d+:\d+/);
+    } finally {
+      await rm(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("parseable id with file but SQL not found falls back to statement index", async () => {
+    const dir = await mkdtemp(path.join(tmpdir(), "pgd-apply-test-"));
+    try {
+      await writeFile(
+        path.join(dir, "tables.sql"),
+        "-- completely different content",
+      );
+
+      const result = await formatStatementError(
+        makeErr({
+          id: "tables.sql:2",
+          sql: "DROP TABLE nonexistent;",
+        }),
+        dir,
+      );
+      expect(result).toContain("Location: tables.sql (statement 2)");
+    } finally {
+      await rm(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("parseable id with position but file read fails uses SQL-based line/col", async () => {
+    const sql = "SELECT\n  1\n  + bad_col";
+    const result = await formatStatementError(
+      makeErr({ id: "missing/file.sql:0", sql, position: 14 }),
+      "/nonexistent",
+    );
+    expect(result).toMatch(
+      /Location: missing\/file\.sql \(statement 0, line \d+, column \d+\)/,
+    );
+  });
+
+  test("parseable id without position and file read fails shows statement index only", async () => {
+    const result = await formatStatementError(
+      makeErr({ id: "missing/file.sql:1" }),
+      "/nonexistent",
+    );
+    expect(result).toContain("Location: missing/file.sql (statement 1)");
+    expect(result).not.toContain("line");
+    expect(result).not.toContain("column");
+  });
+
+  test("all output lines are indented with two spaces", async () => {
+    const result = await formatStatementError(
+      makeErr({ detail: "d", hint: "h", position: 1, sql: "SELECT 1" }),
+      "/tmp",
+    );
+    for (const line of result.split("\n")) {
+      expect(line).toMatch(/^ {2}/);
+    }
+  });
+});

package/src/cli/utils/apply-display.ts

@@ -0,0 +1,238 @@
+/**
+ * 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";
+import type { Diagnostic } from "@supabase/pg-topo";
+import type { StatementError } from "../../core/declarative-apply/round-apply.ts";
+
+/**
+ * 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: string,
+  position: number,
+): { line: number; column: number } {
+  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: string,
+): { filePath: string; statementIndex: number } | null {
+  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 };
+}
+
+/** Input to buildDiagnosticDisplayItems: a pg-topo diagnostic plus optional location and object key. */
+export type DiagnosticDisplayEntry = {
+  diagnostic: Diagnostic;
+  location?: string;
+  requiredObjectKey?: string;
+};
+
+/** One display row for a diagnostic (or a group of same-code diagnostics with multiple locations). */
+type DiagnosticDisplayItem = {
+  code: string;
+  message: string;
+  suggestedFix?: string;
+  requiredObjectKey?: string;
+  locations: string[];
+};
+
+/** Extract requiredObjectKey from a pg-topo diagnostic if present and non-empty. */
+export const requiredObjectKeyFromDiagnostic = (
+  diagnostic: Diagnostic,
+): string | undefined => {
+  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: DiagnosticDisplayEntry): string =>
+  [
+    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: DiagnosticDisplayEntry[],
+  grouped: boolean,
+): DiagnosticDisplayItem[] => {
+  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<string, DiagnosticDisplayItem>();
+  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: string,
+  relativeFilePath: string,
+): Promise<string> {
+  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: string,
+  statementSql: string,
+): number {
+  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: StatementError,
+  schemaPath: string,
+): Promise<string> {
+  const lines: string[] = [];
+  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: string;
+    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/src/cli/utils/export-display.test.ts

@@ -0,0 +1,103 @@
+import { describe, expect, test } from "bun:test";
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import type { FileEntry } from "../../core/export/types.ts";
+import { assertSafePath, computeFileDiff } from "./export-display.ts";
+
+// ============================================================================
+// assertSafePath
+// ============================================================================
+
+describe("assertSafePath", () => {
+  test("allows normal relative paths", () => {
+    expect(() =>
+      assertSafePath("schemas/public/tables/users.sql", "/tmp/out"),
+    ).not.toThrow();
+  });
+
+  test("allows nested paths", () => {
+    expect(() =>
+      assertSafePath("cluster/extensions/pgcrypto.sql", "/tmp/out"),
+    ).not.toThrow();
+  });
+
+  test("rejects path traversal with ..", () => {
+    expect(() => assertSafePath("../../etc/passwd", "/tmp/out")).toThrow(
+      "traversal",
+    );
+  });
+
+  test("rejects path traversal embedded in path", () => {
+    expect(() =>
+      assertSafePath("schemas/../../../etc/passwd", "/tmp/out"),
+    ).toThrow("traversal");
+  });
+
+  test("rejects absolute paths", () => {
+    expect(() => assertSafePath("/etc/passwd", "/tmp/out")).toThrow(
+      "traversal",
+    );
+  });
+});
+
+// ============================================================================
+// computeFileDiff – SQL-only filtering
+// ============================================================================
+
+describe("computeFileDiff", () => {
+  function makeFileEntry(relPath: string, sql = "-- content"): FileEntry {
+    return {
+      path: relPath,
+      order: 0,
+      statements: 1,
+      sql,
+      metadata: { objectType: "table" },
+    };
+  }
+
+  test("non-SQL files in output dir are not marked as deleted", async () => {
+    const dir = await mkdtemp(path.join(tmpdir(), "pgd-export-test-"));
+    try {
+      await mkdir(path.join(dir, "schemas/public/tables"), { recursive: true });
+      await writeFile(
+        path.join(dir, "schemas/public/tables/users.sql"),
+        "-- users",
+      );
+      await writeFile(path.join(dir, "README.md"), "# readme");
+      await writeFile(path.join(dir, ".gitkeep"), "");
+
+      const newFiles = [makeFileEntry("schemas/public/tables/users.sql")];
+      const diff = await computeFileDiff(dir, newFiles);
+
+      expect(diff.deleted).not.toContain("README.md");
+      expect(diff.deleted).not.toContain(".gitkeep");
+      expect(diff.deleted).toHaveLength(0);
+    } finally {
+      await rm(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("stale SQL files are still marked as deleted", async () => {
+    const dir = await mkdtemp(path.join(tmpdir(), "pgd-export-test-"));
+    try {
+      await mkdir(path.join(dir, "schemas/public/tables"), { recursive: true });
+      await writeFile(
+        path.join(dir, "schemas/public/tables/users.sql"),
+        "-- users",
+      );
+      await writeFile(
+        path.join(dir, "schemas/public/tables/old_table.sql"),
+        "-- old",
+      );
+
+      const newFiles = [makeFileEntry("schemas/public/tables/users.sql")];
+      const diff = await computeFileDiff(dir, newFiles);
+
+      expect(diff.deleted).toContain("schemas/public/tables/old_table.sql");
+      expect(diff.deleted).toHaveLength(1);
+    } finally {
+      await rm(dir, { recursive: true, force: true });
+    }
+  });
+});