@supabase/pg-delta 0.0.0 → 1.0.0-alpha.1

package/dist/cli/formatters/tree/tree-builder.js

@@ -0,0 +1,333 @@
+/**
+ * Builds a generic tree structure from a HierarchicalPlan.
+ * Shows only structural changes (scope === "object"), grouped for readability.
+ */
+import { AlterTableAddColumn, AlterTableAlterColumnDropDefault, AlterTableAlterColumnDropNotNull, AlterTableAlterColumnSetDefault, AlterTableAlterColumnSetNotNull, AlterTableAlterColumnType, AlterTableDropColumn, } from "../../../core/objects/table/changes/table.alter.js";
+import { getObjectName } from "../../../core/plan/serialize.js";
+function withCount(name, count) {
+    return count > 0 ? `${name} ${count}` : name;
+}
+function structural(group) {
+    const onlyStructural = (entry) => entry.original.scope === "object";
+    return {
+        create: group.create.filter(onlyStructural),
+        alter: group.alter.filter(onlyStructural),
+        drop: group.drop.filter(onlyStructural),
+    };
+}
+function hasStructural(group) {
+    const structuralGroup = structural(group);
+    return (structuralGroup.create.length +
+        structuralGroup.alter.length +
+        structuralGroup.drop.length >
+        0);
+}
+function symbol(group) {
+    const g = structural(group);
+    if (g.create.length > 0)
+        return "+";
+    if (g.alter.length > 0)
+        return "~";
+    if (g.drop.length > 0)
+        return "-";
+    return "";
+}
+function displayName(entry) {
+    const { original } = entry;
+    if (original instanceof AlterTableAddColumn ||
+        original instanceof AlterTableDropColumn ||
+        original instanceof AlterTableAlterColumnType ||
+        original instanceof AlterTableAlterColumnSetDefault ||
+        original instanceof AlterTableAlterColumnDropDefault ||
+        original instanceof AlterTableAlterColumnSetNotNull ||
+        original instanceof AlterTableAlterColumnDropNotNull) {
+        return original.column.name;
+    }
+    return getObjectName(original);
+}
+function toItems(group) {
+    const items = [];
+    const s = structural(group);
+    for (const entry of s.create) {
+        items.push({ name: `+ ${displayName(entry)}` });
+    }
+    for (const entry of s.alter) {
+        items.push({ name: `~ ${displayName(entry)}` });
+    }
+    for (const entry of s.drop) {
+        items.push({ name: `- ${displayName(entry)}` });
+    }
+    return items;
+}
+function tableChildren(table) {
+    const groups = [];
+    const pushGroup = (name, changeGroup) => {
+        if (hasStructural(changeGroup)) {
+            const items = toItems(changeGroup);
+            const label = items.length > 0 ? `${name} ${items.length}` : name;
+            groups.push({ name: label, items });
+        }
+    };
+    pushGroup("columns", table.columns);
+    pushGroup("indexes", table.indexes);
+    pushGroup("triggers", table.triggers);
+    pushGroup("rules", table.rules);
+    pushGroup("policies", table.policies);
+    const partitionNames = Object.keys(table.partitions).sort();
+    if (partitionNames.length > 0) {
+        const partitionGroups = partitionNames
+            .map((name) => {
+            const part = table.partitions[name];
+            const sym = tableSymbol(part);
+            const childGroups = tableChildren(part);
+            if (!hasStructural(part.changes) && childGroups.length === 0) {
+                return null;
+            }
+            return {
+                name: sym ? `${sym} ${name}` : name,
+                groups: childGroups,
+            };
+        })
+            .filter(Boolean);
+        if (partitionGroups.length > 0) {
+            groups.push({
+                name: withCount("partitions", partitionGroups.length),
+                groups: partitionGroups,
+            });
+        }
+    }
+    return groups;
+}
+function tableSymbol(table) {
+    const own = symbol(table.changes);
+    if (own)
+        return own;
+    const childSymbols = [
+        symbol(table.columns),
+        symbol(table.indexes),
+        symbol(table.triggers),
+        symbol(table.rules),
+        symbol(table.policies),
+    ];
+    if (childSymbols.includes("+"))
+        return "+";
+    if (childSymbols.includes("~"))
+        return "~";
+    if (childSymbols.includes("-"))
+        return "-";
+    for (const part of Object.values(table.partitions)) {
+        const s = tableSymbol(part);
+        if (s)
+            return s;
+    }
+    return "";
+}
+function matviewSymbol(mv) {
+    const own = symbol(mv.changes);
+    if (own)
+        return own;
+    const child = symbol(mv.indexes);
+    return child;
+}
+function matviewChildren(mv) {
+    const groups = [];
+    if (hasStructural(mv.indexes)) {
+        const items = toItems(mv.indexes);
+        groups.push({
+            name: items.length > 0 ? `indexes (${items.length})` : "indexes",
+            items,
+        });
+    }
+    return groups;
+}
+function buildCluster(cluster) {
+    const groups = [
+        ["roles", cluster.roles],
+        ["extensions", cluster.extensions],
+        ["event triggers", cluster.eventTriggers],
+        ["publications", cluster.publications],
+        ["subscriptions", cluster.subscriptions],
+        ["foreign-data-wrappers", cluster.foreignDataWrappers],
+        ["servers", cluster.servers],
+        ["user-mappings", cluster.userMappings],
+    ];
+    return groups
+        .filter(([, grp]) => hasStructural(grp))
+        .map(([name, grp]) => {
+        const items = toItems(grp);
+        return { name: withCount(name, items.length), items };
+    });
+}
+function buildSchema(schema) {
+    const groups = [];
+    const pushItems = (name, changeGroup) => {
+        if (hasStructural(changeGroup)) {
+            const items = toItems(changeGroup);
+            const label = items.length > 0 ? `${name} ${items.length}` : name;
+            groups.push({ name: label, items });
+        }
+    };
+    const tableNames = Object.keys(schema.tables).sort();
+    if (tableNames.length > 0) {
+        const tableGroups = tableNames
+            .map((name) => {
+            const table = schema.tables[name];
+            const changeSymbol = tableSymbol(table);
+            const children = tableChildren(table);
+            if (!hasStructural(table.changes) && children.length === 0)
+                return null;
+            return {
+                name: changeSymbol ? `${changeSymbol} ${name}` : name,
+                groups: children,
+            };
+        })
+            .filter(Boolean);
+        if (tableGroups.length > 0) {
+            groups.push({
+                name: withCount("tables", tableGroups.length),
+                groups: tableGroups,
+            });
+        }
+    }
+    const viewNames = Object.keys(schema.views).sort();
+    if (viewNames.length > 0) {
+        const viewGroups = viewNames
+            .map((name) => {
+            const view = schema.views[name];
+            const changeSymbol = tableSymbol(view);
+            const children = tableChildren(view);
+            if (!hasStructural(view.changes) && children.length === 0)
+                return null;
+            return {
+                name: changeSymbol ? `${changeSymbol} ${name}` : name,
+                groups: children,
+            };
+        })
+            .filter(Boolean);
+        if (viewGroups.length > 0) {
+            groups.push({
+                name: withCount("views", viewGroups.length),
+                groups: viewGroups,
+            });
+        }
+    }
+    const mvNames = Object.keys(schema.materializedViews).sort();
+    if (mvNames.length > 0) {
+        const mvGroups = mvNames
+            .map((name) => {
+            const mv = schema.materializedViews[name];
+            const changeSymbol = matviewSymbol(mv);
+            const children = matviewChildren(mv);
+            if (!hasStructural(mv.changes) && children.length === 0)
+                return null;
+            return {
+                name: changeSymbol ? `${changeSymbol} ${name}` : name,
+                groups: children,
+            };
+        })
+            .filter(Boolean);
+        if (mvGroups.length > 0) {
+            groups.push({
+                name: withCount("materialized views", mvGroups.length),
+                groups: mvGroups,
+            });
+        }
+    }
+    pushItems("functions", schema.functions);
+    pushItems("procedures", schema.procedures);
+    pushItems("aggregates", schema.aggregates);
+    pushItems("sequences", schema.sequences);
+    const typeGroups = [];
+    if (hasStructural(schema.types.enums)) {
+        const items = toItems(schema.types.enums);
+        typeGroups.push({
+            name: items.length > 0 ? `enums ${items.length}` : "enums",
+            items,
+        });
+    }
+    if (hasStructural(schema.types.composites)) {
+        const items = toItems(schema.types.composites);
+        typeGroups.push({
+            name: items.length > 0
+                ? `composite types ${items.length}`
+                : "composite types",
+            items,
+        });
+    }
+    if (hasStructural(schema.types.ranges)) {
+        const items = toItems(schema.types.ranges);
+        typeGroups.push({
+            name: items.length > 0 ? `ranges ${items.length}` : "ranges",
+            items,
+        });
+    }
+    if (hasStructural(schema.types.domains)) {
+        const items = toItems(schema.types.domains);
+        typeGroups.push({
+            name: items.length > 0 ? `domains ${items.length}` : "domains",
+            items,
+        });
+    }
+    if (typeGroups.length > 0) {
+        groups.push({ name: `types ${typeGroups.length}`, groups: typeGroups });
+    }
+    pushItems("collations", schema.collations);
+    const ftNames = Object.keys(schema.foreignTables).sort();
+    if (ftNames.length > 0) {
+        const ftGroups = ftNames
+            .map((name) => {
+            const ft = schema.foreignTables[name];
+            const changeSymbol = tableSymbol(ft);
+            const children = tableChildren(ft);
+            if (!hasStructural(ft.changes) && children.length === 0)
+                return null;
+            return {
+                name: changeSymbol ? `${changeSymbol} ${name}` : name,
+                groups: children,
+            };
+        })
+            .filter(Boolean);
+        if (ftGroups.length > 0) {
+            groups.push({
+                name: withCount("foreign tables", ftGroups.length),
+                groups: ftGroups,
+            });
+        }
+    }
+    return groups;
+}
+/**
+ * Build a generic tree structure from a HierarchicalPlan.
+ */
+export function buildPlanTree(plan) {
+    const rootGroups = [];
+    const clusterGroups = buildCluster(plan.cluster);
+    if (clusterGroups.length > 0) {
+        rootGroups.push({
+            name: withCount("cluster", clusterGroups.length),
+            groups: clusterGroups,
+        });
+    }
+    const schemaNames = Object.keys(plan.schemas).sort();
+    if (schemaNames.length > 0) {
+        const schemaGroups = schemaNames
+            .map((schemaName) => {
+            const schema = plan.schemas[schemaName];
+            const sym = symbol(schema.changes);
+            const children = buildSchema(schema);
+            if (!hasStructural(schema.changes) && children.length === 0) {
+                return null;
+            }
+            const label = sym ? `${sym} ${schemaName}` : schemaName;
+            return { name: label, groups: children };
+        })
+            .filter(Boolean);
+        if (schemaGroups.length > 0) {
+            rootGroups.push({
+                name: withCount("schemas", schemaGroups.length),
+                groups: schemaGroups,
+            });
+        }
+    }
+    return { name: "Plan", groups: rootGroups };
+}

package/dist/cli/formatters/tree/tree-renderer.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Generic tree renderer for hierarchical structures.
+ * Uses dim guides and connectors (├/└) with no trailing rails past last children.
+ * Helper names favor readability over brevity.
+ */
+/**
+ * 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 declare function renderTree(root: TreeGroup): string;

package/dist/cli/formatters/tree/tree-renderer.js

@@ -0,0 +1,303 @@
+/**
+ * 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) => chalk.gray(count);
+const ANSI_PATTERN = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, "g");
+const stripAnsi = (value) => value.replace(ANSI_PATTERN, "");
+const visibleWidth = (value) => stripAnsi(value).length;
+const splitNameCount = (name) => {
+    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",
+];
+/**
+ * Increment operation counters based on a prefixed label.
+ */
+function tallyOperation(name, counts) {
+    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, items) {
+    const counts = { 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;
+}
+/**
+ * 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) {
+    const rows = [];
+    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 = [];
+    const otherGroups = [];
+    let schemasGroup;
+    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 = [
+        ...sortGroups(clusterEntries),
+        ...(schemasGroup ? [schemasGroup] : []),
+        ...sortGroups(otherGroups),
+    ];
+    const combinedRoot = [
+        ...sortItems(rootItems).map((it) => ({
+            kind: "item",
+            name: it.name,
+        })),
+        ...orderedRoot.map((g) => ({ kind: "group", 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 = [];
+        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) {
+    return [...items].sort((firstItem, secondItem) => {
+        const operationOrder = (name) => 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) {
+    return [...groups].sort((firstGroup, secondGroup) => {
+        const operationOrder = (name) => 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, isGroup = false) {
+    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) {
+    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, ancestors, isLast, rows) {
+    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", name: item.name })),
+        ...childGroups.map((childGroup) => ({
+            kind: "group",
+            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, ancestors, isLast, rows) {
+    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/dist/cli/formatters/tree/tree.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Tree formatter for displaying plans hierarchically (compact mode).
+ */
+import type { HierarchicalPlan } from "../../../core/plan/index.ts";
+/**
+ * Format a plan as a tree structure (compact mode).
+ */
+export declare function formatTree(plan: HierarchicalPlan): string;