@rog0x/mcp-database-tools 1.0.0

package/src/tools/migration-generator.ts

@@ -0,0 +1,497 @@
+/**
+ * Migration Generator — compare two schemas (old vs new CREATE TABLE)
+ * and generate ALTER TABLE migration statements.
+ */
+
+interface ColumnDef {
+  name: string;
+  type: string;
+  nullable: boolean;
+  defaultValue: string | null;
+  isPrimaryKey: boolean;
+  isUnique: boolean;
+  autoIncrement: boolean;
+  fullDefinition: string;
+}
+
+interface TableDef {
+  name: string;
+  columns: Map<string, ColumnDef>;
+  primaryKey: string[];
+  foreignKeys: FKDef[];
+  uniqueConstraints: string[][];
+  indexes: IdxDef[];
+}
+
+interface FKDef {
+  constraintName: string | null;
+  columns: string[];
+  referencedTable: string;
+  referencedColumns: string[];
+  onDelete: string | null;
+  onUpdate: string | null;
+  raw: string;
+}
+
+interface IdxDef {
+  name: string | null;
+  columns: string[];
+  unique: boolean;
+}
+
+interface MigrationResult {
+  upStatements: string[];
+  downStatements: string[];
+  summary: string;
+  changes: ChangeDescription[];
+}
+
+interface ChangeDescription {
+  type: "add_table" | "drop_table" | "add_column" | "drop_column" | "modify_column" | "add_fk" | "drop_fk" | "add_index" | "drop_index" | "add_unique" | "drop_unique";
+  table: string;
+  detail: string;
+}
+
+function splitRespectingParens(text: string): string[] {
+  const parts: string[] = [];
+  let depth = 0;
+  let current = "";
+  for (const ch of text) {
+    if (ch === "(") depth++;
+    if (ch === ")") depth--;
+    if (ch === "," && depth === 0) {
+      parts.push(current.trim());
+      current = "";
+      continue;
+    }
+    current += ch;
+  }
+  if (current.trim()) parts.push(current.trim());
+  return parts;
+}
+
+function extractTableBody(stmt: string): string | null {
+  let depth = 0;
+  let start = -1;
+  let end = -1;
+  for (let i = 0; i < stmt.length; i++) {
+    if (stmt[i] === "(") {
+      if (depth === 0) start = i + 1;
+      depth++;
+    }
+    if (stmt[i] === ")") {
+      depth--;
+      if (depth === 0) {
+        end = i;
+        break;
+      }
+    }
+  }
+  if (start === -1 || end === -1) return null;
+  return stmt.substring(start, end).trim();
+}
+
+function parseColumnDef(def: string): ColumnDef | null {
+  const trimmed = def.trim();
+  if (/^\s*(PRIMARY KEY|FOREIGN KEY|UNIQUE|CHECK|CONSTRAINT|INDEX|KEY)\b/i.test(trimmed)) {
+    return null;
+  }
+
+  const parts = trimmed.split(/\s+/);
+  if (parts.length < 2) return null;
+
+  const name = parts[0].replace(/[`"[\]]/g, "");
+  const upper = trimmed.toUpperCase();
+
+  // Extract type
+  const afterName = trimmed.substring(parts[0].length).trim();
+  const typeMatch = afterName.match(
+    /^(\w+(?:\s*\([^)]*\))?(?:\s+(?:PRECISION|VARYING|WITHOUT|WITH|TIME|ZONE)(?:\s*\([^)]*\))?)*)/i
+  );
+  const type = typeMatch ? typeMatch[1].trim().toUpperCase() : parts[1].toUpperCase();
+
+  // Extract default
+  const defaultMatch = trimmed.match(/\bDEFAULT\s+('[^']*'|"[^"]*"|\S+)/i);
+
+  return {
+    name,
+    type,
+    nullable: !upper.includes("NOT NULL"),
+    defaultValue: defaultMatch ? defaultMatch[1] : null,
+    isPrimaryKey: upper.includes("PRIMARY KEY"),
+    isUnique: upper.includes("UNIQUE"),
+    autoIncrement:
+      upper.includes("AUTO_INCREMENT") ||
+      upper.includes("AUTOINCREMENT") ||
+      /\bSERIAL\b|\bBIGSERIAL\b|\bSMALLSERIAL\b/i.test(type),
+    fullDefinition: trimmed,
+  };
+}
+
+function parseSchema(sql: string): Map<string, TableDef> {
+  const tables = new Map<string, TableDef>();
+  const statements = sql.split(";").map((s) => s.trim()).filter(Boolean);
+
+  for (const stmt of statements) {
+    if (!/^\s*CREATE\s+TABLE\b/i.test(stmt)) continue;
+
+    const nameMatch = stmt.match(
+      /CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?(?:`?(\w+)`?\.)?`?(\w+)`?/i
+    );
+    if (!nameMatch) continue;
+    const tableName = nameMatch[2].toLowerCase();
+
+    const body = extractTableBody(stmt);
+    if (!body) continue;
+
+    const definitions = splitRespectingParens(body);
+    const columns = new Map<string, ColumnDef>();
+    const primaryKey: string[] = [];
+    const foreignKeys: FKDef[] = [];
+    const uniqueConstraints: string[][] = [];
+    const indexes: IdxDef[] = [];
+
+    for (const def of definitions) {
+      const trimmed = def.trim();
+      const upper = trimmed.toUpperCase();
+
+      // PRIMARY KEY
+      if (/^\s*(?:CONSTRAINT\s+\w+\s+)?PRIMARY\s+KEY\s*\(/i.test(trimmed)) {
+        const m = trimmed.match(/PRIMARY\s+KEY\s*\(([^)]+)\)/i);
+        if (m) primaryKey.push(...m[1].split(",").map((c) => c.trim().replace(/[`"[\]]/g, "").toLowerCase()));
+        continue;
+      }
+
+      // FOREIGN KEY
+      if (/^\s*(?:CONSTRAINT\s+\w+\s+)?FOREIGN\s+KEY\s*\(/i.test(trimmed)) {
+        const cnMatch = trimmed.match(/CONSTRAINT\s+`?(\w+)`?/i);
+        const fkMatch = trimmed.match(
+          /FOREIGN\s+KEY\s*\(([^)]+)\)\s*REFERENCES\s+`?(\w+)`?\s*\(([^)]+)\)/i
+        );
+        if (fkMatch) {
+          const onDel = trimmed.match(/ON\s+DELETE\s+(\w+(?:\s+\w+)?)/i);
+          const onUpd = trimmed.match(/ON\s+UPDATE\s+(\w+(?:\s+\w+)?)/i);
+          foreignKeys.push({
+            constraintName: cnMatch ? cnMatch[1] : null,
+            columns: fkMatch[1].split(",").map((c) => c.trim().replace(/[`"[\]]/g, "").toLowerCase()),
+            referencedTable: fkMatch[2].toLowerCase(),
+            referencedColumns: fkMatch[3].split(",").map((c) => c.trim().replace(/[`"[\]]/g, "").toLowerCase()),
+            onDelete: onDel ? onDel[1].toUpperCase() : null,
+            onUpdate: onUpd ? onUpd[1].toUpperCase() : null,
+            raw: trimmed,
+          });
+        }
+        continue;
+      }
+
+      // UNIQUE
+      if (/^\s*(?:CONSTRAINT\s+\w+\s+)?UNIQUE\s*\(/i.test(trimmed)) {
+        const m = trimmed.match(/UNIQUE\s*\(([^)]+)\)/i);
+        if (m) uniqueConstraints.push(m[1].split(",").map((c) => c.trim().replace(/[`"[\]]/g, "").toLowerCase()));
+        continue;
+      }
+
+      // INDEX / KEY
+      if (/^\s*(?:INDEX|KEY)\s+/i.test(trimmed)) {
+        const m = trimmed.match(/(?:INDEX|KEY)\s+`?(\w+)`?\s*\(([^)]+)\)/i);
+        if (m) {
+          indexes.push({
+            name: m[1],
+            columns: m[2].split(",").map((c) => c.trim().replace(/[`"[\]]/g, "").toLowerCase()),
+            unique: false,
+          });
+        }
+        continue;
+      }
+
+      // CHECK / CONSTRAINT CHECK
+      if (/^\s*(?:CONSTRAINT\s+\w+\s+)?CHECK\s*\(/i.test(trimmed)) {
+        continue;
+      }
+
+      // Column
+      const col = parseColumnDef(trimmed);
+      if (col) {
+        columns.set(col.name.toLowerCase(), col);
+        if (col.isPrimaryKey) primaryKey.push(col.name.toLowerCase());
+      }
+    }
+
+    tables.set(tableName, {
+      name: tableName,
+      columns,
+      primaryKey,
+      foreignKeys,
+      uniqueConstraints,
+      indexes,
+    });
+  }
+
+  return tables;
+}
+
+function buildColumnDefinition(col: ColumnDef): string {
+  let def = `${col.name} ${col.type}`;
+  if (!col.nullable) def += " NOT NULL";
+  if (col.defaultValue) def += ` DEFAULT ${col.defaultValue}`;
+  if (col.isUnique) def += " UNIQUE";
+  return def;
+}
+
+export function migrationGenerator(
+  oldSchema: string,
+  newSchema: string,
+  dialect: string = "postgresql"
+): MigrationResult {
+  const oldTables = parseSchema(oldSchema);
+  const newTables = parseSchema(newSchema);
+
+  const upStatements: string[] = [];
+  const downStatements: string[] = [];
+  const changes: ChangeDescription[] = [];
+
+  // Find new tables (exist in new but not old)
+  for (const [name, newTable] of newTables) {
+    if (!oldTables.has(name)) {
+      // Reconstruct CREATE TABLE
+      const colDefs = Array.from(newTable.columns.values()).map((c) => buildColumnDefinition(c));
+      if (newTable.primaryKey.length > 0) {
+        colDefs.push(`PRIMARY KEY (${newTable.primaryKey.join(", ")})`);
+      }
+      for (const fk of newTable.foreignKeys) {
+        let fkDef = `FOREIGN KEY (${fk.columns.join(", ")}) REFERENCES ${fk.referencedTable} (${fk.referencedColumns.join(", ")})`;
+        if (fk.onDelete) fkDef += ` ON DELETE ${fk.onDelete}`;
+        if (fk.onUpdate) fkDef += ` ON UPDATE ${fk.onUpdate}`;
+        colDefs.push(fkDef);
+      }
+      for (const uc of newTable.uniqueConstraints) {
+        colDefs.push(`UNIQUE (${uc.join(", ")})`);
+      }
+
+      upStatements.push(`CREATE TABLE ${name} (\n  ${colDefs.join(",\n  ")}\n);`);
+      downStatements.push(`DROP TABLE IF EXISTS ${name};`);
+      changes.push({ type: "add_table", table: name, detail: `Create new table "${name}"` });
+    }
+  }
+
+  // Find dropped tables (exist in old but not new)
+  for (const [name, oldTable] of oldTables) {
+    if (!newTables.has(name)) {
+      const colDefs = Array.from(oldTable.columns.values()).map((c) => buildColumnDefinition(c));
+      if (oldTable.primaryKey.length > 0) {
+        colDefs.push(`PRIMARY KEY (${oldTable.primaryKey.join(", ")})`);
+      }
+
+      upStatements.push(`DROP TABLE IF EXISTS ${name};`);
+      downStatements.push(`CREATE TABLE ${name} (\n  ${colDefs.join(",\n  ")}\n);`);
+      changes.push({ type: "drop_table", table: name, detail: `Drop table "${name}"` });
+    }
+  }
+
+  // Compare tables that exist in both
+  for (const [name, newTable] of newTables) {
+    const oldTable = oldTables.get(name);
+    if (!oldTable) continue;
+
+    // New columns
+    for (const [colName, newCol] of newTable.columns) {
+      if (!oldTable.columns.has(colName)) {
+        const colDef = buildColumnDefinition(newCol);
+        upStatements.push(`ALTER TABLE ${name} ADD COLUMN ${colDef};`);
+        downStatements.push(`ALTER TABLE ${name} DROP COLUMN ${colName};`);
+        changes.push({
+          type: "add_column",
+          table: name,
+          detail: `Add column "${colName}" (${newCol.type})`,
+        });
+      }
+    }
+
+    // Dropped columns
+    for (const [colName, oldCol] of oldTable.columns) {
+      if (!newTable.columns.has(colName)) {
+        upStatements.push(`ALTER TABLE ${name} DROP COLUMN ${colName};`);
+        const colDef = buildColumnDefinition(oldCol);
+        downStatements.push(`ALTER TABLE ${name} ADD COLUMN ${colDef};`);
+        changes.push({
+          type: "drop_column",
+          table: name,
+          detail: `Drop column "${colName}"`,
+        });
+      }
+    }
+
+    // Modified columns
+    for (const [colName, newCol] of newTable.columns) {
+      const oldCol = oldTable.columns.get(colName);
+      if (!oldCol) continue;
+
+      const typeChanged = oldCol.type !== newCol.type;
+      const nullChanged = oldCol.nullable !== newCol.nullable;
+      const defaultChanged = oldCol.defaultValue !== newCol.defaultValue;
+
+      if (typeChanged || nullChanged || defaultChanged) {
+        const modifications: string[] = [];
+
+        if (typeChanged) {
+          if (dialect === "mysql") {
+            upStatements.push(
+              `ALTER TABLE ${name} MODIFY COLUMN ${buildColumnDefinition(newCol)};`
+            );
+            downStatements.push(
+              `ALTER TABLE ${name} MODIFY COLUMN ${buildColumnDefinition(oldCol)};`
+            );
+          } else {
+            upStatements.push(
+              `ALTER TABLE ${name} ALTER COLUMN ${colName} TYPE ${newCol.type};`
+            );
+            downStatements.push(
+              `ALTER TABLE ${name} ALTER COLUMN ${colName} TYPE ${oldCol.type};`
+            );
+          }
+          modifications.push(`type ${oldCol.type} -> ${newCol.type}`);
+        }
+
+        if (nullChanged && !typeChanged) {
+          if (newCol.nullable) {
+            upStatements.push(
+              `ALTER TABLE ${name} ALTER COLUMN ${colName} DROP NOT NULL;`
+            );
+            downStatements.push(
+              `ALTER TABLE ${name} ALTER COLUMN ${colName} SET NOT NULL;`
+            );
+          } else {
+            upStatements.push(
+              `ALTER TABLE ${name} ALTER COLUMN ${colName} SET NOT NULL;`
+            );
+            downStatements.push(
+              `ALTER TABLE ${name} ALTER COLUMN ${colName} DROP NOT NULL;`
+            );
+          }
+          modifications.push(newCol.nullable ? "make nullable" : "make NOT NULL");
+        }
+
+        if (defaultChanged && !typeChanged) {
+          if (newCol.defaultValue) {
+            upStatements.push(
+              `ALTER TABLE ${name} ALTER COLUMN ${colName} SET DEFAULT ${newCol.defaultValue};`
+            );
+            if (oldCol.defaultValue) {
+              downStatements.push(
+                `ALTER TABLE ${name} ALTER COLUMN ${colName} SET DEFAULT ${oldCol.defaultValue};`
+              );
+            } else {
+              downStatements.push(
+                `ALTER TABLE ${name} ALTER COLUMN ${colName} DROP DEFAULT;`
+              );
+            }
+          } else {
+            upStatements.push(
+              `ALTER TABLE ${name} ALTER COLUMN ${colName} DROP DEFAULT;`
+            );
+            downStatements.push(
+              `ALTER TABLE ${name} ALTER COLUMN ${colName} SET DEFAULT ${oldCol.defaultValue};`
+            );
+          }
+          modifications.push(`default ${oldCol.defaultValue || "none"} -> ${newCol.defaultValue || "none"}`);
+        }
+
+        if (modifications.length > 0) {
+          changes.push({
+            type: "modify_column",
+            table: name,
+            detail: `Modify column "${colName}": ${modifications.join(", ")}`,
+          });
+        }
+      }
+    }
+
+    // Foreign key changes
+    const oldFKKeys = oldTable.foreignKeys.map(
+      (fk) => `${fk.columns.join(",")}->${fk.referencedTable}(${fk.referencedColumns.join(",")})`
+    );
+    const newFKKeys = newTable.foreignKeys.map(
+      (fk) => `${fk.columns.join(",")}->${fk.referencedTable}(${fk.referencedColumns.join(",")})`
+    );
+
+    // New FKs
+    for (let i = 0; i < newTable.foreignKeys.length; i++) {
+      if (!oldFKKeys.includes(newFKKeys[i])) {
+        const fk = newTable.foreignKeys[i];
+        const cnName = fk.constraintName || `fk_${name}_${fk.columns.join("_")}`;
+        let fkDef = `ALTER TABLE ${name} ADD CONSTRAINT ${cnName} FOREIGN KEY (${fk.columns.join(", ")}) REFERENCES ${fk.referencedTable} (${fk.referencedColumns.join(", ")})`;
+        if (fk.onDelete) fkDef += ` ON DELETE ${fk.onDelete}`;
+        if (fk.onUpdate) fkDef += ` ON UPDATE ${fk.onUpdate}`;
+        upStatements.push(`${fkDef};`);
+        downStatements.push(`ALTER TABLE ${name} DROP CONSTRAINT ${cnName};`);
+        changes.push({
+          type: "add_fk",
+          table: name,
+          detail: `Add foreign key ${fk.columns.join(", ")} -> ${fk.referencedTable}(${fk.referencedColumns.join(", ")})`,
+        });
+      }
+    }
+
+    // Dropped FKs
+    for (let i = 0; i < oldTable.foreignKeys.length; i++) {
+      if (!newFKKeys.includes(oldFKKeys[i])) {
+        const fk = oldTable.foreignKeys[i];
+        const cnName = fk.constraintName || `fk_${name}_${fk.columns.join("_")}`;
+        upStatements.push(`ALTER TABLE ${name} DROP CONSTRAINT ${cnName};`);
+        let fkDef = `ALTER TABLE ${name} ADD CONSTRAINT ${cnName} FOREIGN KEY (${fk.columns.join(", ")}) REFERENCES ${fk.referencedTable} (${fk.referencedColumns.join(", ")})`;
+        if (fk.onDelete) fkDef += ` ON DELETE ${fk.onDelete}`;
+        if (fk.onUpdate) fkDef += ` ON UPDATE ${fk.onUpdate}`;
+        downStatements.push(`${fkDef};`);
+        changes.push({
+          type: "drop_fk",
+          table: name,
+          detail: `Drop foreign key ${fk.columns.join(", ")} -> ${fk.referencedTable}(${fk.referencedColumns.join(", ")})`,
+        });
+      }
+    }
+
+    // Unique constraint changes
+    const oldUQKeys = oldTable.uniqueConstraints.map((uc) => uc.sort().join(","));
+    const newUQKeys = newTable.uniqueConstraints.map((uc) => uc.sort().join(","));
+
+    for (const uc of newTable.uniqueConstraints) {
+      const key = uc.sort().join(",");
+      if (!oldUQKeys.includes(key)) {
+        const cnName = `uq_${name}_${uc.join("_")}`;
+        upStatements.push(`ALTER TABLE ${name} ADD CONSTRAINT ${cnName} UNIQUE (${uc.join(", ")});`);
+        downStatements.push(`ALTER TABLE ${name} DROP CONSTRAINT ${cnName};`);
+        changes.push({
+          type: "add_unique",
+          table: name,
+          detail: `Add unique constraint on (${uc.join(", ")})`,
+        });
+      }
+    }
+
+    for (const uc of oldTable.uniqueConstraints) {
+      const key = uc.sort().join(",");
+      if (!newUQKeys.includes(key)) {
+        const cnName = `uq_${name}_${uc.join("_")}`;
+        upStatements.push(`ALTER TABLE ${name} DROP CONSTRAINT ${cnName};`);
+        downStatements.push(`ALTER TABLE ${name} ADD CONSTRAINT ${cnName} UNIQUE (${uc.join(", ")});`);
+        changes.push({
+          type: "drop_unique",
+          table: name,
+          detail: `Drop unique constraint on (${uc.join(", ")})`,
+        });
+      }
+    }
+  }
+
+  // Summary
+  const summary = changes.length > 0
+    ? `Migration contains ${changes.length} change(s): ${changes.map((c) => c.detail).join("; ")}`
+    : "No differences detected between the two schemas.";
+
+  return {
+    upStatements,
+    downStatements,
+    summary,
+    changes,
+  };
+}