mcp-migration-advisor 0.2.0

package/build/parsers/flyway-sql.js

@@ -0,0 +1,189 @@
+/**
+ * Flyway SQL migration parser.
+ *
+ * Parses Flyway V__*.sql and R__*.sql migration files.
+ * Extracts DDL statements and categorizes operations.
+ */
+const FLYWAY_VERSIONED_RE = /^V(\d+(?:[._]\d+)*)__(.+)\.sql$/i;
+const FLYWAY_REPEATABLE_RE = /^R__(.+)\.sql$/i;
+/**
+ * Parse a Flyway migration filename to extract version and description.
+ */
+export function parseFlywayFilename(filename) {
+    const basename = filename.replace(/^.*[/\\]/, "");
+    const vMatch = basename.match(FLYWAY_VERSIONED_RE);
+    if (vMatch) {
+        return {
+            version: vMatch[1].replace(/_/g, "."),
+            description: vMatch[2].replace(/_/g, " "),
+            isRepeatable: false,
+        };
+    }
+    const rMatch = basename.match(FLYWAY_REPEATABLE_RE);
+    if (rMatch) {
+        return {
+            version: null,
+            description: rMatch[1].replace(/_/g, " "),
+            isRepeatable: true,
+        };
+    }
+    return { version: null, description: basename, isRepeatable: false };
+}
+/**
+ * Split SQL text into individual statements.
+ * Handles semicolons, ignoring those inside strings and comments.
+ */
+function splitStatements(sql) {
+    // Remove block comments
+    let cleaned = sql.replace(/\/\*[\s\S]*?\*\//g, "");
+    // Remove line comments
+    cleaned = cleaned.replace(/--.*$/gm, "");
+    const stmts = [];
+    let current = "";
+    for (const char of cleaned) {
+        if (char === ";") {
+            const trimmed = current.trim();
+            if (trimmed.length > 0) {
+                stmts.push(trimmed);
+            }
+            current = "";
+        }
+        else {
+            current += char;
+        }
+    }
+    const last = current.trim();
+    if (last.length > 0) {
+        stmts.push(last);
+    }
+    return stmts;
+}
+// Pattern matchers for DDL statement types
+const CREATE_TABLE_RE = /CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?(?:`|"|)?(\w+)(?:`|"|)?/i;
+const ALTER_TABLE_RE = /ALTER\s+TABLE\s+(?:ONLY\s+)?(?:`|"|)?(\w+)(?:`|"|)?/i;
+const DROP_TABLE_RE = /DROP\s+TABLE\s+(?:IF\s+EXISTS\s+)?(?:`|"|)?(\w+)(?:`|"|)?/i;
+const CREATE_INDEX_RE = /CREATE\s+(?:UNIQUE\s+)?INDEX\s+(?:CONCURRENTLY\s+)?(?:IF\s+NOT\s+EXISTS\s+)?(?:`|"|)?(\w+)(?:`|"|\s).*?\bON\s+(?:`|"|)?(\w+)(?:`|"|)?/i;
+const DROP_INDEX_RE = /DROP\s+INDEX\s+(?:CONCURRENTLY\s+)?(?:IF\s+EXISTS\s+)?(?:`|"|)?(\w+)(?:`|"|)?/i;
+const ADD_COLUMN_RE = /ADD\s+(?:COLUMN\s+)?(?:`|"|)?(\w+)(?:`|"|)?/i;
+const DROP_COLUMN_RE = /DROP\s+(?:COLUMN\s+)?(?:IF\s+EXISTS\s+)?(?:`|"|)?(\w+)(?:`|"|)?/i;
+const ALTER_COLUMN_RE = /ALTER\s+(?:COLUMN\s+)?(?:`|"|)?(\w+)(?:`|"|)?/i;
+const ADD_CONSTRAINT_RE = /ADD\s+CONSTRAINT\s+(?:`|"|)?(\w+)(?:`|"|)?/i;
+const DROP_CONSTRAINT_RE = /DROP\s+CONSTRAINT\s+(?:IF\s+EXISTS\s+)?(?:`|"|)?(\w+)(?:`|"|)?/i;
+/**
+ * Classify a single SQL statement into a DDLStatement.
+ */
+function classifyStatement(raw) {
+    const upper = raw.toUpperCase();
+    const details = {};
+    // CREATE TABLE
+    const createTableMatch = raw.match(CREATE_TABLE_RE);
+    if (createTableMatch && upper.startsWith("CREATE")) {
+        return { type: "CREATE_TABLE", raw, tableName: createTableMatch[1], columnName: null, details };
+    }
+    // CREATE INDEX
+    const createIndexMatch = raw.match(CREATE_INDEX_RE);
+    if (createIndexMatch && upper.includes("INDEX")) {
+        if (upper.includes("CONCURRENTLY")) {
+            details.concurrently = "true";
+        }
+        if (upper.includes("UNIQUE")) {
+            details.unique = "true";
+        }
+        return { type: "CREATE_INDEX", raw, tableName: createIndexMatch[2], columnName: null, details };
+    }
+    // DROP TABLE
+    const dropTableMatch = raw.match(DROP_TABLE_RE);
+    if (dropTableMatch) {
+        if (upper.includes("CASCADE"))
+            details.cascade = "true";
+        return { type: "DROP_TABLE", raw, tableName: dropTableMatch[1], columnName: null, details };
+    }
+    // DROP INDEX
+    const dropIndexMatch = raw.match(DROP_INDEX_RE);
+    if (dropIndexMatch && upper.includes("INDEX")) {
+        if (upper.includes("CONCURRENTLY"))
+            details.concurrently = "true";
+        return { type: "DROP_INDEX", raw, tableName: null, columnName: null, details };
+    }
+    // ALTER TABLE with sub-operations
+    const alterTableMatch = raw.match(ALTER_TABLE_RE);
+    if (alterTableMatch) {
+        const tableName = alterTableMatch[1];
+        const afterAlter = raw.substring(alterTableMatch[0].length).trim();
+        // ADD CONSTRAINT
+        const addConstraintMatch = afterAlter.match(ADD_CONSTRAINT_RE);
+        if (addConstraintMatch) {
+            details.constraintName = addConstraintMatch[1];
+            if (upper.includes("FOREIGN KEY"))
+                details.constraintType = "FOREIGN_KEY";
+            else if (upper.includes("UNIQUE"))
+                details.constraintType = "UNIQUE";
+            else if (upper.includes("CHECK"))
+                details.constraintType = "CHECK";
+            else if (upper.includes("PRIMARY KEY"))
+                details.constraintType = "PRIMARY_KEY";
+            return { type: "ADD_CONSTRAINT", raw, tableName, columnName: null, details };
+        }
+        // DROP CONSTRAINT
+        const dropConstraintMatch = afterAlter.match(DROP_CONSTRAINT_RE);
+        if (dropConstraintMatch) {
+            details.constraintName = dropConstraintMatch[1];
+            return { type: "DROP_CONSTRAINT", raw, tableName, columnName: null, details };
+        }
+        // ALTER COLUMN (type change, set not null, drop not null, set default, drop default)
+        // Must be checked BEFORE DROP COLUMN — otherwise "ALTER COLUMN x DROP NOT NULL"
+        // matches DROP_COLUMN_RE with "NOT" as the column name.
+        const alterColMatch = afterAlter.match(ALTER_COLUMN_RE);
+        if (alterColMatch && upper.includes("ALTER") && afterAlter.toUpperCase().startsWith("ALTER")) {
+            const colName = alterColMatch[1];
+            if (upper.includes("SET NOT NULL"))
+                details.setNotNull = "true";
+            if (upper.includes("DROP NOT NULL"))
+                details.dropNotNull = "true";
+            if (upper.includes("SET DEFAULT"))
+                details.setDefault = "true";
+            if (upper.includes("DROP DEFAULT"))
+                details.dropDefault = "true";
+            if (upper.includes("TYPE") || upper.includes("SET DATA TYPE"))
+                details.typeChange = "true";
+            return { type: "MODIFY_COLUMN", raw, tableName, columnName: colName, details };
+        }
+        // DROP COLUMN
+        const dropColMatch = afterAlter.match(DROP_COLUMN_RE);
+        if (dropColMatch && upper.includes("DROP")) {
+            return { type: "DROP_COLUMN", raw, tableName, columnName: dropColMatch[1], details };
+        }
+        // ADD COLUMN
+        const addColMatch = afterAlter.match(ADD_COLUMN_RE);
+        if (addColMatch && upper.includes("ADD")) {
+            const colName = addColMatch[1];
+            if (upper.includes("NOT NULL"))
+                details.notNull = "true";
+            if (upper.includes("DEFAULT"))
+                details.hasDefault = "true";
+            return { type: "ADD_COLUMN", raw, tableName, columnName: colName, details };
+        }
+        // Generic ALTER TABLE (RENAME, etc.)
+        if (upper.includes("RENAME")) {
+            return { type: "RENAME", raw, tableName, columnName: null, details };
+        }
+        return { type: "ALTER_TABLE", raw, tableName, columnName: null, details };
+    }
+    return { type: "OTHER", raw, tableName: null, columnName: null, details };
+}
+/**
+ * Parse a complete Flyway migration file.
+ */
+export function parseMigration(filename, sql) {
+    const { version, description, isRepeatable } = parseFlywayFilename(filename);
+    const rawStatements = splitStatements(sql);
+    const statements = rawStatements.map(classifyStatement);
+    return {
+        version,
+        description,
+        filename,
+        isRepeatable,
+        statements,
+    };
+}
+//# sourceMappingURL=flyway-sql.js.map

package/build/parsers/liquibase-xml.js

@@ -0,0 +1,263 @@
+/**
+ * Liquibase XML changelog parser.
+ *
+ * Parses Liquibase XML changelogs and extracts DDL operations
+ * compatible with the same DDLStatement interface used by Flyway.
+ */
+/**
+ * Parse a Liquibase XML changelog and extract DDL statements.
+ *
+ * Supports: createTable, dropTable, addColumn, dropColumn, modifyDataType,
+ * addNotNullConstraint, createIndex, dropIndex, addForeignKeyConstraint,
+ * dropForeignKeyConstraint, renameTable, renameColumn, sql (raw).
+ */
+export function parseLiquibaseXml(xml) {
+    const changeSets = extractChangeSets(xml);
+    const allStatements = [];
+    for (const cs of changeSets) {
+        allStatements.push(...cs.statements);
+    }
+    return {
+        version: changeSets.length > 0 ? changeSets[0].id : null,
+        description: `Liquibase changelog (${changeSets.length} changeSets)`,
+        filename: "changelog.xml",
+        isRepeatable: false,
+        statements: allStatements,
+    };
+}
+function extractChangeSets(xml) {
+    const results = [];
+    const changeSetRe = /<changeSet\s+([^>]*)>([\s\S]*?)<\/changeSet>/gi;
+    let match;
+    while ((match = changeSetRe.exec(xml)) !== null) {
+        const attrs = match[1];
+        const body = match[2];
+        const id = extractAttr(attrs, "id") || "unknown";
+        const author = extractAttr(attrs, "author") || "unknown";
+        const statements = parseChangeSetBody(body);
+        results.push({ id, author, statements });
+    }
+    return results;
+}
+function extractAttr(attrs, name) {
+    const re = new RegExp(`${name}\\s*=\\s*"([^"]*)"`, "i");
+    const match = attrs.match(re);
+    return match ? match[1] : null;
+}
+function parseChangeSetBody(body) {
+    const statements = [];
+    // createTable
+    const createTableRe = /<createTable\s+([^>]*)(?:\/>|>([\s\S]*?)<\/createTable>)/gi;
+    let m;
+    while ((m = createTableRe.exec(body)) !== null) {
+        const tableName = extractAttr(m[1], "tableName") || "unknown";
+        const columnsBody = m[2] || "";
+        const columns = extractColumns(columnsBody);
+        const details = {};
+        if (columns.length > 0)
+            details.columns = columns.join(", ");
+        statements.push({
+            type: "CREATE_TABLE",
+            raw: m[0],
+            tableName,
+            columnName: null,
+            details,
+        });
+    }
+    // dropTable
+    const dropTableRe = /<dropTable\s+([^/>]*)\/?>(?:<\/dropTable>)?/gi;
+    while ((m = dropTableRe.exec(body)) !== null) {
+        const tableName = extractAttr(m[1], "tableName") || "unknown";
+        const details = {};
+        const cascade = extractAttr(m[1], "cascadeConstraints");
+        if (cascade === "true")
+            details.cascade = "true";
+        statements.push({
+            type: "DROP_TABLE",
+            raw: m[0],
+            tableName,
+            columnName: null,
+            details,
+        });
+    }
+    // addColumn
+    const addColumnRe = /<addColumn\s+([^>]*)>([\s\S]*?)<\/addColumn>/gi;
+    while ((m = addColumnRe.exec(body)) !== null) {
+        const tableName = extractAttr(m[1], "tableName") || "unknown";
+        const columnBody = m[2];
+        const colRe = /<column\s+([^/>]*)\/?>(?:<\/column>)?/gi;
+        let cm;
+        while ((cm = colRe.exec(columnBody)) !== null) {
+            const colName = extractAttr(cm[1], "name") || "unknown";
+            const details = {};
+            const colType = extractAttr(cm[1], "type");
+            if (colType)
+                details.type = colType;
+            // Check for constraints
+            if (columnBody.includes("nullable=\"false\"") || cm[0].includes("nullable=\"false\"")) {
+                details.notNull = "true";
+            }
+            if (extractAttr(cm[1], "defaultValue") || extractAttr(cm[1], "defaultValueNumeric") || extractAttr(cm[1], "defaultValueBoolean")) {
+                details.hasDefault = "true";
+            }
+            statements.push({
+                type: "ADD_COLUMN",
+                raw: cm[0],
+                tableName,
+                columnName: colName,
+                details,
+            });
+        }
+    }
+    // dropColumn
+    const dropColumnRe = /<dropColumn\s+([^/>]*)\/?>(?:<\/dropColumn>)?/gi;
+    while ((m = dropColumnRe.exec(body)) !== null) {
+        const tableName = extractAttr(m[1], "tableName") || "unknown";
+        const colName = extractAttr(m[1], "columnName") || "unknown";
+        statements.push({
+            type: "DROP_COLUMN",
+            raw: m[0],
+            tableName,
+            columnName: colName,
+            details: {},
+        });
+    }
+    // modifyDataType
+    const modifyRe = /<modifyDataType\s+([^/>]*)\/?>(?:<\/modifyDataType>)?/gi;
+    while ((m = modifyRe.exec(body)) !== null) {
+        const tableName = extractAttr(m[1], "tableName") || "unknown";
+        const colName = extractAttr(m[1], "columnName") || "unknown";
+        const newType = extractAttr(m[1], "newDataType");
+        const details = { typeChange: "true" };
+        if (newType)
+            details.newType = newType;
+        statements.push({
+            type: "MODIFY_COLUMN",
+            raw: m[0],
+            tableName,
+            columnName: colName,
+            details,
+        });
+    }
+    // addNotNullConstraint
+    const addNotNullRe = /<addNotNullConstraint\s+([^/>]*)\/?>(?:<\/addNotNullConstraint>)?/gi;
+    while ((m = addNotNullRe.exec(body)) !== null) {
+        const tableName = extractAttr(m[1], "tableName") || "unknown";
+        const colName = extractAttr(m[1], "columnName") || "unknown";
+        const details = { setNotNull: "true" };
+        const defaultVal = extractAttr(m[1], "defaultNullValue");
+        if (defaultVal)
+            details.hasDefault = "true";
+        statements.push({
+            type: "MODIFY_COLUMN",
+            raw: m[0],
+            tableName,
+            columnName: colName,
+            details,
+        });
+    }
+    // createIndex
+    const createIndexRe = /<createIndex\s+([^>]*)(?:\/>|>([\s\S]*?)<\/createIndex>)/gi;
+    while ((m = createIndexRe.exec(body)) !== null) {
+        const tableName = extractAttr(m[1], "tableName") || "unknown";
+        const details = {};
+        if (extractAttr(m[1], "unique") === "true")
+            details.unique = "true";
+        // Liquibase doesn't have CONCURRENTLY — it's SQL-level
+        statements.push({
+            type: "CREATE_INDEX",
+            raw: m[0],
+            tableName,
+            columnName: null,
+            details,
+        });
+    }
+    // dropIndex
+    const dropIndexRe = /<dropIndex\s+([^/>]*)\/?>(?:<\/dropIndex>)?/gi;
+    while ((m = dropIndexRe.exec(body)) !== null) {
+        statements.push({
+            type: "DROP_INDEX",
+            raw: m[0],
+            tableName: extractAttr(m[1], "tableName") || null,
+            columnName: null,
+            details: {},
+        });
+    }
+    // addForeignKeyConstraint
+    const addFkRe = /<addForeignKeyConstraint\s+([^/>]*)\/?>(?:<\/addForeignKeyConstraint>)?/gi;
+    while ((m = addFkRe.exec(body)) !== null) {
+        const tableName = extractAttr(m[1], "baseTableName") || "unknown";
+        const constraintName = extractAttr(m[1], "constraintName") || "unknown";
+        statements.push({
+            type: "ADD_CONSTRAINT",
+            raw: m[0],
+            tableName,
+            columnName: null,
+            details: { constraintName, constraintType: "FOREIGN_KEY" },
+        });
+    }
+    // dropForeignKeyConstraint
+    const dropFkRe = /<dropForeignKeyConstraint\s+([^/>]*)\/?>(?:<\/dropForeignKeyConstraint>)?/gi;
+    while ((m = dropFkRe.exec(body)) !== null) {
+        const tableName = extractAttr(m[1], "baseTableName") || "unknown";
+        const constraintName = extractAttr(m[1], "constraintName") || "unknown";
+        statements.push({
+            type: "DROP_CONSTRAINT",
+            raw: m[0],
+            tableName,
+            columnName: null,
+            details: { constraintName },
+        });
+    }
+    // renameTable
+    const renameTableRe = /<renameTable\s+([^/>]*)\/?>(?:<\/renameTable>)?/gi;
+    while ((m = renameTableRe.exec(body)) !== null) {
+        const oldName = extractAttr(m[1], "oldTableName");
+        const newName = extractAttr(m[1], "newTableName");
+        statements.push({
+            type: "RENAME",
+            raw: m[0],
+            tableName: oldName || "unknown",
+            columnName: null,
+            details: { newName: newName || "unknown" },
+        });
+    }
+    // renameColumn
+    const renameColRe = /<renameColumn\s+([^/>]*)\/?>(?:<\/renameColumn>)?/gi;
+    while ((m = renameColRe.exec(body)) !== null) {
+        const tableName = extractAttr(m[1], "tableName") || "unknown";
+        const oldName = extractAttr(m[1], "oldColumnName");
+        const newName = extractAttr(m[1], "newColumnName");
+        statements.push({
+            type: "RENAME",
+            raw: m[0],
+            tableName,
+            columnName: oldName || null,
+            details: { newName: newName || "unknown" },
+        });
+    }
+    // Raw SQL
+    const sqlRe = /<sql>([\s\S]*?)<\/sql>/gi;
+    while ((m = sqlRe.exec(body)) !== null) {
+        statements.push({
+            type: "OTHER",
+            raw: m[1].trim(),
+            tableName: null,
+            columnName: null,
+            details: { source: "inline-sql" },
+        });
+    }
+    return statements;
+}
+function extractColumns(body) {
+    const cols = [];
+    const colRe = /<column\s+([^/>]*)\/?>(?:<\/column>)?/gi;
+    let m;
+    while ((m = colRe.exec(body)) !== null) {
+        const name = extractAttr(m[1], "name");
+        if (name)
+            cols.push(name);
+    }
+    return cols;
+}
+//# sourceMappingURL=liquibase-xml.js.map