@coldge.com/gitbase 1.0.2 → 1.0.3

package/dist/utils/sqlDiff.js

@@ -0,0 +1,245 @@
+/**
+ * sqlDiff.ts — Smart schema diffing utilities
+ *
+ * Generates the minimal set of ALTER statements needed to transition a schema
+ * object from one state to another, avoiding destructive DROP+CREATE whenever
+ * possible. This preserves existing data in tables and avoids any unnecessary
+ * downtime on enum types.
+ *
+ * The parsers here are intentionally simple: they understand our canonical DDL
+ * format as generated by extractor.ts, not arbitrary user-written SQL.
+ */
+// ---------------------------------------------------------------------------
+// Table parsing
+// ---------------------------------------------------------------------------
+/**
+ * Splits the body of a CREATE TABLE statement into lines, handling nested
+ * parentheses (e.g. FOREIGN KEY (...) REFERENCES foo(id)) correctly.
+ */
+function splitTableBody(body) {
+    const parts = [];
+    let current = '';
+    let depth = 0;
+    for (const ch of body) {
+        if (ch === '(')
+            depth++;
+        else if (ch === ')')
+            depth--;
+        if (ch === ',' && depth === 0) {
+            const trimmed = current.trim();
+            if (trimmed)
+                parts.push(trimmed);
+            current = '';
+        }
+        else {
+            current += ch;
+        }
+    }
+    const trimmed = current.trim();
+    if (trimmed)
+        parts.push(trimmed);
+    return parts;
+}
+/**
+ * Parses the canonical CREATE TABLE SQL generated by extractor.ts into its
+ * constituent parts: columns, table constraints, indexes, and RLS status.
+ */
+export function extractTableParts(sql) {
+    const columns = new Map();
+    const constraints = new Map();
+    const indexes = new Map();
+    // Extract the body between the outer ( ... );
+    const bodyMatch = sql.match(/CREATE TABLE [^(]+\((\n[\s\S]*?\n)\);/);
+    if (bodyMatch) {
+        const bodyLines = splitTableBody(bodyMatch[1]);
+        for (const line of bodyLines) {
+            if (!line)
+                continue;
+            if (line.startsWith('CONSTRAINT ')) {
+                // e.g. CONSTRAINT "pk_name" PRIMARY KEY (col)
+                const m = line.match(/^CONSTRAINT "([^"]+)"\s+([\s\S]+)$/);
+                if (m)
+                    constraints.set(m[1], m[2].trim());
+            }
+            else if (line.startsWith('"')) {
+                // e.g. "colname" integer NOT NULL DEFAULT 42
+                // Our format is always: "name" type [NOT NULL] [DEFAULT val]
+                const m = line.match(/^"([^"]+)"\s+([^\s]+)(.*)/);
+                if (m) {
+                    const [, name, type, rest] = m;
+                    const notNull = /\bNOT NULL\b/i.test(rest);
+                    // DEFAULT is always last in our format
+                    const defaultMatch = rest.match(/\bDEFAULT\s+(.+)$/i);
+                    columns.set(name, {
+                        name,
+                        type,
+                        notNull,
+                        default: defaultMatch ? defaultMatch[1].trim() : null,
+                    });
+                }
+            }
+        }
+    }
+    // Extract standalone CREATE INDEX statements (after the closing ");")
+    const indexRegex = /CREATE (?:UNIQUE )?INDEX "([^"]+)" ON [^\n]+/gi;
+    let im;
+    while ((im = indexRegex.exec(sql)) !== null) {
+        indexes.set(im[1], im[0]);
+    }
+    const rlsEnabled = /ENABLE ROW LEVEL SECURITY/i.test(sql);
+    return { columns, constraints, indexes, rlsEnabled };
+}
+// ---------------------------------------------------------------------------
+// Table ALTER generation
+// ---------------------------------------------------------------------------
+/**
+ * Generates the minimal `ALTER TABLE` statements to transition a table's
+ * schema from `oldSql` to `newSql`, preserving all existing rows.
+ *
+ * Returns an empty array if the schemas are identical.
+ * Always succeeds — the caller should never need to fall back to DROP+CREATE
+ * for an existing table (unless the table is being renamed or schema-moved,
+ * which is out of scope).
+ */
+export function generateTableAlter(tableName, oldSql, newSql) {
+    const alters = [];
+    const q = `public."${tableName}"`;
+    const oldParts = extractTableParts(oldSql);
+    const newParts = extractTableParts(newSql);
+    // 1. DROP removed constraints first — they may reference columns we'll drop
+    for (const [name] of oldParts.constraints) {
+        if (!newParts.constraints.has(name)) {
+            alters.push(`ALTER TABLE ${q} DROP CONSTRAINT IF EXISTS "${name}";`);
+        }
+        else if (oldParts.constraints.get(name) !== newParts.constraints.get(name)) {
+            // Constraint definition changed — drop + re-add below
+            alters.push(`ALTER TABLE ${q} DROP CONSTRAINT IF EXISTS "${name}";`);
+        }
+    }
+    // 2. DROP removed indexes
+    for (const [name] of oldParts.indexes) {
+        if (!newParts.indexes.has(name)) {
+            alters.push(`DROP INDEX IF EXISTS "${name}";`);
+        }
+        else if (oldParts.indexes.get(name) !== newParts.indexes.get(name)) {
+            alters.push(`DROP INDEX IF EXISTS "${name}";`);
+        }
+    }
+    // 3. DROP removed columns
+    for (const [name] of oldParts.columns) {
+        if (!newParts.columns.has(name)) {
+            alters.push(`ALTER TABLE ${q} DROP COLUMN IF EXISTS "${name}";`);
+        }
+    }
+    // 4. ADD new columns
+    for (const [name, col] of newParts.columns) {
+        if (!oldParts.columns.has(name)) {
+            let def = `"${name}" ${col.type}`;
+            if (col.notNull)
+                def += ' NOT NULL';
+            if (col.default != null)
+                def += ` DEFAULT ${col.default}`;
+            alters.push(`ALTER TABLE ${q} ADD COLUMN ${def};`);
+        }
+    }
+    // 5. MODIFY changed columns
+    for (const [name, newCol] of newParts.columns) {
+        const oldCol = oldParts.columns.get(name);
+        if (!oldCol)
+            continue; // New column — already handled above
+        if (oldCol.type !== newCol.type) {
+            // Note: may fail for incompatible casts (e.g. text→integer with non-numeric data).
+            // The transaction wrapper will catch this and roll back cleanly.
+            alters.push(`ALTER TABLE ${q} ALTER COLUMN "${name}" TYPE ${newCol.type};`);
+        }
+        if (oldCol.notNull !== newCol.notNull) {
+            alters.push(newCol.notNull
+                ? `ALTER TABLE ${q} ALTER COLUMN "${name}" SET NOT NULL;`
+                : `ALTER TABLE ${q} ALTER COLUMN "${name}" DROP NOT NULL;`);
+        }
+        // Compare defaults via string equality (both come from information_schema so format is stable)
+        const oldDefault = oldCol.default ?? null;
+        const newDefault = newCol.default ?? null;
+        if (oldDefault !== newDefault) {
+            alters.push(newDefault != null
+                ? `ALTER TABLE ${q} ALTER COLUMN "${name}" SET DEFAULT ${newDefault};`
+                : `ALTER TABLE ${q} ALTER COLUMN "${name}" DROP DEFAULT;`);
+        }
+    }
+    // 6. ADD new or changed constraints
+    for (const [name, def] of newParts.constraints) {
+        const oldDef = oldParts.constraints.get(name);
+        if (!oldDef || oldDef !== def) {
+            alters.push(`ALTER TABLE ${q} ADD CONSTRAINT "${name}" ${def};`);
+        }
+    }
+    // 7. ADD new or changed indexes
+    for (const [name, def] of newParts.indexes) {
+        const oldDef = oldParts.indexes.get(name);
+        if (!oldDef || oldDef !== def) {
+            alters.push(`${def};`);
+        }
+    }
+    // 8. RLS status
+    if (newParts.rlsEnabled && !oldParts.rlsEnabled) {
+        alters.push(`ALTER TABLE ${q} ENABLE ROW LEVEL SECURITY;`);
+    }
+    else if (!newParts.rlsEnabled && oldParts.rlsEnabled) {
+        alters.push(`ALTER TABLE ${q} DISABLE ROW LEVEL SECURITY;`);
+    }
+    return alters;
+}
+// ---------------------------------------------------------------------------
+// Enum ALTER generation
+// ---------------------------------------------------------------------------
+/**
+ * Extracts the ordered list of values from a CREATE TYPE ... AS ENUM (...) statement.
+ */
+function extractEnumValues(sql) {
+    const match = sql.match(/AS ENUM\s*\(([^)]+)\)/i);
+    if (!match)
+        return [];
+    return match[1]
+        .split(',')
+        .map(v => v.trim().replace(/^'|'$/g, ''));
+}
+/**
+ * Attempts to generate `ALTER TYPE ... ADD VALUE` statements for additive
+ * enum changes (i.e. only new values added, no values removed or reordered).
+ *
+ * Returns:
+ *   - `string[]`  — ALTER TYPE statements to apply (may be empty if no change)
+ *   - `null`      — cannot safely alter; caller must DROP+CREATE
+ */
+export function generateEnumAlter(typeName, oldSql, newSql) {
+    const oldValues = extractEnumValues(oldSql);
+    const newValues = extractEnumValues(newSql);
+    // Check if any existing values were removed — requires DROP+CREATE
+    for (const v of oldValues) {
+        if (!newValues.includes(v))
+            return null;
+    }
+    // Check if shared values were reordered — requires DROP+CREATE
+    // (PostgreSQL enum ordering is significant)
+    const sharedInOldOrder = oldValues.filter(v => newValues.includes(v));
+    const sharedInNewOrder = newValues.filter(v => oldValues.includes(v));
+    if (JSON.stringify(sharedInOldOrder) !== JSON.stringify(sharedInNewOrder))
+        return null;
+    // Only new values added — safe to use ADD VALUE
+    const addedValues = newValues.filter(v => !oldValues.includes(v));
+    if (addedValues.length === 0)
+        return []; // No change
+    return addedValues.map(val => {
+        const idx = newValues.indexOf(val);
+        if (idx === newValues.length - 1) {
+            // Adding at end — AFTER the preceding value
+            const after = newValues[idx - 1];
+            return `ALTER TYPE public."${typeName}" ADD VALUE '${val}' AFTER '${after}';`;
+        }
+        else {
+            // Adding before an existing value
+            const before = newValues[idx + 1];
+            return `ALTER TYPE public."${typeName}" ADD VALUE '${val}' BEFORE '${before}';`;
+        }
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coldge.com/gitbase",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "The Time Machine for Supabase",
   "main": "dist/index.js",
   "type": "module",
@@ -32,6 +32,7 @@
     "diff": "^8.0.3",
     "dotenv": "^17.3.1",
     "pg": "^8.19.0",
+    "pgsql-parser": "^17.9.11",
     "toposort": "^2.0.2",
     "yargs": "^17.0.0"
   },