@supabase/pg-delta 1.0.0-alpha.0 → 1.0.0-alpha.10

package/src/cli/formatters/tree/tree-renderer.ts

@@ -0,0 +1,372 @@
+/**
+ * Generic tree renderer for hierarchical structures.
+ * Uses dim guides and connectors (├/└) with no trailing rails past last children.
+ * Helper names favor readability over brevity.
+ */
+
+import chalk from "chalk";
+
+const GUIDE_UNIT = "│  ";
+const colorCount = (count: string) => chalk.gray(count);
+const ANSI_PATTERN = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, "g");
+const stripAnsi = (value: string) => value.replace(ANSI_PATTERN, "");
+const visibleWidth = (value: string) => stripAnsi(value).length;
+const splitNameCount = (name: string) => {
+  const m = name.match(/^(.*?)(\s+)(\d+)$/);
+  return m
+    ? { base: m[1], sep: m[2], count: m[3] }
+    : { base: name, sep: "", count: "" };
+};
+const GROUP_NAMES = [
+  "cluster",
+  "database",
+  "schemas",
+  "tables",
+  "views",
+  "materialized views",
+  "functions",
+  "procedures",
+  "aggregates",
+  "sequences",
+  "types",
+  "enums",
+  "composite types",
+  "ranges",
+  "domains",
+  "collations",
+  "foreign tables",
+  "columns",
+  "indexes",
+  "triggers",
+  "rules",
+  "policies",
+  "partitions",
+  "roles",
+  "extensions",
+  "event triggers",
+  "publications",
+  "subscriptions",
+  "foreign data wrappers",
+  "servers",
+  "user mappings",
+];
+
+interface OperationCounts {
+  create: number;
+  alter: number;
+  drop: number;
+}
+
+/**
+ * Increment operation counters based on a prefixed label.
+ */
+function tallyOperation(name: string, counts: OperationCounts): void {
+  if (name.startsWith("+")) counts.create += 1;
+  else if (name.startsWith("~")) counts.alter += 1;
+  else if (name.startsWith("-")) counts.drop += 1;
+}
+
+/**
+ * Count operations for a single level (no recursion).
+ */
+function summarizeShallow(
+  groups?: TreeGroup[],
+  items?: TreeItem[],
+): OperationCounts {
+  const counts: OperationCounts = { create: 0, alter: 0, drop: 0 };
+
+  if (items) {
+    for (const item of items) {
+      tallyOperation(item.name, counts);
+    }
+  }
+  if (groups) {
+    for (const group of groups) {
+      tallyOperation(group.name, counts);
+    }
+  }
+
+  return counts;
+}
+
+/**
+ * A single item in the tree (leaf node).
+ */
+export interface TreeItem {
+  /** The display name/label */
+  name: string;
+}
+
+/**
+ * A group in the tree (branch node with children).
+ */
+export interface TreeGroup {
+  /** The display name/label */
+  name: string;
+  /** Child items (leaves) */
+  items?: TreeItem[];
+  /** Child groups (branches) */
+  groups?: TreeGroup[];
+}
+
+/**
+ * Render a tree structure using plain lines style.
+ *
+ * @example
+ * ```ts
+ * const tree: TreeGroup = {
+ *   name: "root",
+ *   groups: [
+ *     { name: "src", items: [{ name: "index.ts" }] },
+ *     { name: "tests", items: [{ name: "test.ts" }] },
+ *   ],
+ * };
+ * const output = renderTree(tree);
+ * // Output:
+ * // root
+ * // ├─ src
+ * // │  └─ index.ts
+ * // └─ tests
+ * //    └─ test.ts
+ * ```
+ */
+export function renderTree(root: TreeGroup): string {
+  interface TreeRow {
+    left: string;
+    counts?: OperationCounts;
+  }
+  const rows: TreeRow[] = [];
+  if (root.name) {
+    rows.push({ left: chalk.bold(root.name) });
+  }
+
+  const rootItems = root.items ?? [];
+  const rootGroups = root.groups ?? [];
+
+  // Render root groups at top level (no extra wrapper indentation)
+  const clusterEntries: TreeGroup[] = [];
+  const otherGroups: TreeGroup[] = [];
+  let schemasGroup: TreeGroup | undefined;
+
+  for (const group of rootGroups) {
+    const { base: label } = splitNameCount(group.name);
+    if (label === "cluster") {
+      if (group.items) {
+        clusterEntries.push(...group.items.map((it) => ({ name: it.name })));
+      }
+      if (group.groups) {
+        clusterEntries.push(...group.groups);
+      }
+    } else if (label === "schemas") {
+      schemasGroup = group;
+    } else {
+      otherGroups.push(group);
+    }
+  }
+
+  const orderedRoot: TreeGroup[] = [
+    ...sortGroups(clusterEntries),
+    ...(schemasGroup ? [schemasGroup] : []),
+    ...sortGroups(otherGroups),
+  ];
+
+  const combinedRoot = [
+    ...sortItems(rootItems).map((it) => ({
+      kind: "item" as const,
+      name: it.name,
+    })),
+    ...orderedRoot.map((g) => ({ kind: "group" as const, group: g })),
+  ];
+
+  for (let i = 0; i < combinedRoot.length; i++) {
+    const node = combinedRoot[i];
+    const isLast = i === combinedRoot.length - 1;
+    if (node.kind === "item") {
+      renderItem(node.name, [], isLast, rows);
+    } else {
+      renderGroup(node.group, [], isLast, rows);
+    }
+  }
+
+  const maxLeftWidth = rows.reduce(
+    (max, row) => Math.max(max, visibleWidth(row.left)),
+    0,
+  );
+
+  const lines = rows.map(({ left, counts }) => {
+    if (!counts) return left;
+
+    const parts: string[] = [];
+    if (counts.create) parts.push(chalk.green.dim(`+${counts.create}`));
+    if (counts.alter) parts.push(chalk.yellow.dim(`~${counts.alter}`));
+    if (counts.drop) parts.push(chalk.red.dim(`-${counts.drop}`));
+
+    if (parts.length === 0) return left;
+
+    const summary = parts.join(" ");
+    const gap = Math.max(
+      1,
+      maxLeftWidth - visibleWidth(left) - visibleWidth(summary) - 1,
+    );
+    const filler = gap > 0 ? " ".repeat(gap) : "";
+
+    return `${left}${filler} ${summary}`;
+  });
+
+  return lines.join("\n");
+}
+
+function sortItems(items: TreeItem[]): TreeItem[] {
+  return [...items].sort((firstItem, secondItem) => {
+    const operationOrder = (name: string) =>
+      name.startsWith("+")
+        ? 0
+        : name.startsWith("~")
+          ? 1
+          : name.startsWith("-")
+            ? 2
+            : 3;
+    const firstOrder = operationOrder(firstItem.name);
+    const secondOrder = operationOrder(secondItem.name);
+    if (firstOrder !== secondOrder) return firstOrder - secondOrder;
+    const firstLabel = firstItem.name.replace(/^[+~-]\s*/, "").toLowerCase();
+    const secondLabel = secondItem.name.replace(/^[+~-]\s*/, "").toLowerCase();
+    if (firstLabel < secondLabel) return -1;
+    if (firstLabel > secondLabel) return 1;
+    return 0;
+  });
+}
+
+function sortGroups(groups: TreeGroup[]): TreeGroup[] {
+  return [...groups].sort((firstGroup, secondGroup) => {
+    const operationOrder = (name: string) =>
+      name.startsWith("+")
+        ? 0
+        : name.startsWith("~")
+          ? 1
+          : name.startsWith("-")
+            ? 2
+            : 3;
+    const firstOrder = operationOrder(firstGroup.name);
+    const secondOrder = operationOrder(secondGroup.name);
+    if (firstOrder !== secondOrder) return firstOrder - secondOrder;
+    const firstLabel = firstGroup.name.replace(/^[+~-]\s*/, "").toLowerCase();
+    const secondLabel = secondGroup.name.replace(/^[+~-]\s*/, "").toLowerCase();
+    if (firstLabel < secondLabel) return -1;
+    if (firstLabel > secondLabel) return 1;
+    return 0;
+  });
+}
+
+/**
+ * Colorize a label; pads non-op labels to align with op-labeled rows.
+ */
+function colorizeName(name: string, isGroup = false): string {
+  const { base: rawBase, sep, count } = splitNameCount(name);
+  const hasOperationSymbol = /^[+~-]\s/.test(rawBase);
+  const baseName = rawBase.trim();
+
+  // Colorize items/entities with operation symbols (e.g., "+ customer", "+ customer_email_domain_idx")
+  if (hasOperationSymbol) {
+    const symbol = rawBase[0];
+    const rest = rawBase.slice(2).trimStart();
+    const coloredBase =
+      symbol === "+"
+        ? `${chalk.green(symbol)} ${rest}`
+        : symbol === "~"
+          ? `${chalk.yellow(symbol)} ${rest}`
+          : `${chalk.red(symbol)} ${rest}`;
+    return count ? `${coloredBase}${sep}${colorCount(count)}` : coloredBase;
+  }
+
+  // Group names (like "tables", "schemas") - dim gray
+  const baseNameStripped = baseName.replace(/\s*\(\d+\)$/, "");
+
+  if (GROUP_NAMES.includes(baseNameStripped)) {
+    const coloredBase = chalk.gray(baseNameStripped);
+    return count ? `${coloredBase}${sep}${colorCount(count)}` : coloredBase;
+  }
+
+  const padded = isGroup ? baseName : `  ${baseName}`;
+  return count ? `${padded}${sep}${colorCount(count)}` : padded;
+}
+
+/**
+ * Render a group with bullet-style indentation.
+ */
+function buildPrefix(ancestors: boolean[]): string {
+  return ancestors
+    .map((hasSibling) =>
+      hasSibling ? chalk.hex("#4a4a4a")(GUIDE_UNIT) : "   ",
+    )
+    .join("");
+}
+
+/**
+ * Render a group node (may have child groups/items). Avoids drawing guides past the last child.
+ */
+function renderGroup(
+  group: TreeGroup,
+  ancestors: boolean[],
+  isLast: boolean,
+  rows: { left: string; counts?: OperationCounts }[],
+): void {
+  const { base } = splitNameCount(group.name);
+  const hasOperationSymbol = /^[+~-]\s/.test(base);
+  const baseNormalized = base
+    .replace(/^[+~-]\s*/, "")
+    .replace(/\s*\(\d+\)$/, "");
+  const summary =
+    GROUP_NAMES.includes(base) &&
+    baseNormalized !== "types" &&
+    (group.items || group.groups)
+      ? summarizeShallow(group.groups, group.items)
+      : undefined;
+  const childItems = sortItems(group.items ?? []);
+  const childGroups = sortGroups(group.groups ?? []);
+  const children = [
+    ...childItems.map((item) => ({ kind: "item" as const, name: item.name })),
+    ...childGroups.map((childGroup) => ({
+      kind: "group" as const,
+      group: childGroup,
+    })),
+  ];
+
+  const prefix = buildPrefix(ancestors);
+  const connector = chalk.hex("#4a4a4a")(isLast ? "└ " : "├ ");
+  const extraGuide = hasOperationSymbol ? "" : connector;
+  const coloredName = colorizeName(base, true);
+  rows.push({
+    left: `${prefix}${extraGuide}${coloredName}`,
+    counts: summary,
+  });
+
+  for (let i = 0; i < children.length; i++) {
+    const child = children[i];
+    const childIsLast = i === children.length - 1;
+    const childAncestors = [...ancestors, !isLast];
+    if (child.kind === "item") {
+      renderItem(child.name, childAncestors, childIsLast, rows);
+    } else {
+      renderGroup(child.group, childAncestors, childIsLast, rows);
+    }
+  }
+}
+
+/**
+ * Render a leaf item. Non-op rows get a dim connector; op rows start at the prefix.
+ */
+function renderItem(
+  name: string,
+  ancestors: boolean[],
+  isLast: boolean,
+  rows: { left: string; counts?: OperationCounts }[],
+): void {
+  const prefix = buildPrefix(ancestors);
+  const hasOperationSymbol = /^[+~-]\s/.test(name);
+  const connector = hasOperationSymbol
+    ? ""
+    : chalk.hex("#4a4a4a")(isLast ? "└ " : "├ ");
+  const coloredName = colorizeName(name);
+  rows.push({ left: `${prefix}${connector}${coloredName}` });
+}

package/src/cli/formatters/tree/tree.ts

@@ -0,0 +1,238 @@
+/**
+ * Tree formatter for displaying plans hierarchically (compact mode).
+ */
+
+import chalk from "chalk";
+import type { HierarchicalPlan } from "../../../core/plan/index.ts";
+import { buildPlanTree } from "./tree-builder.ts";
+import { renderTree } from "./tree-renderer.ts";
+
+/**
+ * Format a plan as a tree structure (compact mode).
+ */
+export function formatTree(plan: HierarchicalPlan): string {
+  const lines: string[] = [];
+
+  // Summary
+  const total = countTotalChanges(plan);
+  lines.push(
+    chalk.bold(`📋 Migration Plan: ${total} change${total !== 1 ? "s" : ""}`),
+  );
+  const summary = buildPlanSummaryTable(plan);
+  if (summary) {
+    lines.push("");
+    lines.push(summary);
+  }
+  lines.push("");
+
+  // Build generic tree structure and render it
+  const tree = buildPlanTree(plan);
+  const treeOutput = renderTree(tree);
+  lines.push(treeOutput);
+
+  // Legend
+  lines.push("");
+  lines.push(
+    `${chalk.green("+")} create   ${chalk.yellow("~")} alter   ${chalk.red("-")} drop`,
+  );
+
+  return lines.join("\n");
+}
+
+function countTotalChanges(plan: HierarchicalPlan): number {
+  const byType: Record<
+    string,
+    { create: number; alter: number; drop: number }
+  > = {};
+  countFromHierarchy(plan, byType);
+  let total = 0;
+  for (const counts of Object.values(byType)) {
+    total += counts.create + counts.alter + counts.drop;
+  }
+  return total;
+}
+
+/**
+ * Build summary as a table showing counts by entity type and operation.
+ * Exported for use by declarative-export to show the same summary style.
+ */
+function buildPlanSummaryTable(plan: HierarchicalPlan): string {
+  // Count by object type
+  const byType: Record<
+    string,
+    { create: number; alter: number; drop: number }
+  > = {};
+  countFromHierarchy(plan, byType);
+
+  // Filter to only types with changes
+  const entries = Object.entries(byType).filter(
+    ([, counts]) => counts.create + counts.alter + counts.drop > 0,
+  );
+
+  if (entries.length === 0) {
+    return "";
+  }
+
+  // Calculate column widths
+  let maxNameWidth = 0;
+  let maxCreateWidth = 0;
+  let maxAlterWidth = 0;
+  let maxDropWidth = 0;
+
+  for (const [type, counts] of entries) {
+    const typeStr = type.replace(/_/g, "-");
+    maxNameWidth = Math.max(maxNameWidth, typeStr.length);
+    // For width calculation, use "1" instead of "0" since we'll show "-" for zeros
+    maxCreateWidth = Math.max(
+      maxCreateWidth,
+      counts.create > 0 ? counts.create.toString().length : 1,
+    );
+    maxAlterWidth = Math.max(
+      maxAlterWidth,
+      counts.alter > 0 ? counts.alter.toString().length : 1,
+    );
+    maxDropWidth = Math.max(
+      maxDropWidth,
+      counts.drop > 0 ? counts.drop.toString().length : 1,
+    );
+  }
+
+  // Ensure minimum widths for headers
+  maxNameWidth = Math.max(maxNameWidth, "Entity".length);
+  maxCreateWidth = Math.max(maxCreateWidth, "Create".length);
+  maxAlterWidth = Math.max(maxAlterWidth, "Alter".length);
+  maxDropWidth = Math.max(maxDropWidth, "Drop".length);
+
+  const lines: string[] = [];
+
+  // Header
+  lines.push(
+    `${chalk.bold("Entity".padEnd(maxNameWidth))}  ${chalk.bold("Create".padStart(maxCreateWidth))}  ${chalk.bold("Alter".padStart(maxAlterWidth))}  ${chalk.bold("Drop".padStart(maxDropWidth))}`,
+  );
+  lines.push(
+    `${chalk.dim("-".repeat(maxNameWidth))}  ${chalk.dim("-".repeat(maxCreateWidth))}  ${chalk.dim("-".repeat(maxAlterWidth))}  ${chalk.dim("-".repeat(maxDropWidth))}`,
+  );
+
+  // Rows
+  for (const [type, counts] of entries.sort(([a], [b]) => a.localeCompare(b))) {
+    const typeStr = type.replace(/_/g, "-");
+    // Format numbers: show "-" for 0, pad and colorize
+    const createDisplay = counts.create > 0 ? counts.create.toString() : "-";
+    const alterDisplay = counts.alter > 0 ? counts.alter.toString() : "-";
+    const dropDisplay = counts.drop > 0 ? counts.drop.toString() : "-";
+
+    const createStr =
+      counts.create > 0
+        ? chalk.green(createDisplay.padStart(maxCreateWidth))
+        : chalk.dim(createDisplay.padStart(maxCreateWidth));
+    const alterStr =
+      counts.alter > 0
+        ? chalk.yellow(alterDisplay.padStart(maxAlterWidth))
+        : chalk.dim(alterDisplay.padStart(maxAlterWidth));
+    const dropStr =
+      counts.drop > 0
+        ? chalk.red(dropDisplay.padStart(maxDropWidth))
+        : chalk.dim(dropDisplay.padStart(maxDropWidth));
+
+    lines.push(
+      `${typeStr.padEnd(maxNameWidth)}  ${createStr}  ${alterStr}  ${dropStr}`,
+    );
+  }
+
+  return lines.join("\n");
+}
+
+/**
+ * Count changes by type from hierarchy.
+ */
+function countFromHierarchy(
+  plan: HierarchicalPlan,
+  byType: Record<string, { create: number; alter: number; drop: number }>,
+): void {
+  const addCounts = (
+    target: { create: number; alter: number; drop: number },
+    source: { create: number; alter: number; drop: number },
+  ) => {
+    target.create += source.create;
+    target.alter += source.alter;
+    target.drop += source.drop;
+  };
+
+  function countGroup(
+    group: {
+      create: ChangeEntry[];
+      alter: ChangeEntry[];
+      drop: ChangeEntry[];
+    },
+    type: string,
+  ) {
+    if (!byType[type]) {
+      byType[type] = { create: 0, alter: 0, drop: 0 };
+    }
+    byType[type].create += group.create.length;
+    byType[type].alter += group.alter.length;
+    byType[type].drop += group.drop.length;
+  }
+
+  // Cluster
+  countGroup(plan.cluster.roles, "role");
+  countGroup(plan.cluster.extensions, "extension");
+  countGroup(plan.cluster.eventTriggers, "event-trigger");
+  countGroup(plan.cluster.publications, "publication");
+  countGroup(plan.cluster.subscriptions, "subscription");
+
+  // Schemas
+  for (const schema of Object.values(plan.schemas)) {
+    countGroup(schema.changes, "schema");
+    countGroup(schema.functions, "function");
+    countGroup(schema.procedures, "procedure");
+    countGroup(schema.aggregates, "aggregate");
+    countGroup(schema.sequences, "sequence");
+    countGroup(schema.collations, "collation");
+
+    // Tables
+    for (const table of Object.values(schema.tables)) {
+      const tableCounts = {
+        create: table.changes.create.length,
+        alter: table.changes.alter.length,
+        drop: table.changes.drop.length,
+      };
+
+      // Roll column counts into table totals (no separate column row)
+      addCounts(tableCounts, {
+        create: table.columns.create.length,
+        alter: table.columns.alter.length,
+        drop: table.columns.drop.length,
+      });
+
+      // Apply rolled-up counts to table totals
+      if (!byType.table) {
+        byType.table = { create: 0, alter: 0, drop: 0 };
+      }
+      addCounts(byType.table, tableCounts);
+
+      countGroup(table.indexes, "index");
+      countGroup(table.triggers, "trigger");
+      countGroup(table.rules, "rule");
+      countGroup(table.policies, "policy");
+    }
+
+    // Views
+    for (const view of Object.values(schema.views)) {
+      countGroup(view.changes, "view");
+    }
+
+    // Materialized views
+    for (const matview of Object.values(schema.materializedViews)) {
+      countGroup(matview.changes, "materialized-view");
+    }
+
+    // Types
+    countGroup(schema.types.enums, "enum");
+    countGroup(schema.types.composites, "composite-type");
+    countGroup(schema.types.ranges, "range");
+    countGroup(schema.types.domains, "domain");
+  }
+}
+
+import type { ChangeEntry } from "../../../core/plan/index.ts";