import { diffLines, type Change } from "diff"; export type HunkType = "equal" | "delete" | "insert" | "modify"; export interface DiffLine { type: HunkType; content: string; lineNumber: number | null; isPadding: boolean; comparisonContent?: string; } export interface DiffHunk { id: string; type: HunkType; leftLines: DiffLine[]; rightLines: DiffLine[]; // Measured pixel positions after rendering leftTop: number; leftBottom: number; rightTop: number; rightBottom: number; } const SIMILARITY_THRESHOLD = 0.3; const ALIGN_WINDOW = 3; const MAX_GLOBAL_ALIGNMENT_CELLS = 10_000; const ALIGN_DELETE = 1; const ALIGN_INSERT = 2; const ALIGN_MODIFY = 3; const SQL_LINE_KEYWORDS = new Set([ "add", "alter", "as", "begin", "check", "cluster", "comment", "constraint", "create", "delete", "distributed", "drop", "else", "end", "engine", "foreign", "from", "group", "having", "if", "index", "insert", "join", "key", "on", "order", "partition", "primary", "references", "return", "returns", "select", "set", "settings", "tablespace", "then", "union", "unique", "update", "using", "values", "when", "where", "with", ]); function splitLines(value: string): string[] { const lines = value.split("\n"); if (lines.length > 0 && lines[lines.length - 1] === "") lines.pop(); return lines; } function buildLines(lines: string[], type: HunkType, startLineNum: number): DiffLine[] { return lines.map((content, idx) => ({ type, content, lineNumber: startLineNum + idx, isPadding: false, })); } function buildPaddingLines(count: number): DiffLine[] { return Array.from({ length: count }, () => ({ type: "equal" as HunkType, content: "", lineNumber: null, isPadding: true, })); } function normalizeDdl(ddl: string): string { return ddl .replace(/\r\n/g, "\n") .replace(/\r/g, "\n") .split("\n") .map((line) => line.replace(/[ \t]+$/g, "")) .join("\n"); } function collectSameKindChanges(changes: Change[], startIdx: number, kind: "added" | "removed"): [string[], number] { const parts: string[] = []; let i = startIdx; while (i < changes.length && changes[i][kind]) { parts.push(changes[i].value); i++; } return [parts, i]; } function levenshteinDistance(a: string, b: string): number { let previous = Array.from({ length: a.length + 1 }, (_, index) => index); for (let i = 1; i <= b.length; i++) { const current = [i]; for (let j = 1; j <= a.length; j++) { current[j] = b.charAt(i - 1) === a.charAt(j - 1) ? previous[j - 1] : Math.min(previous[j - 1] + 1, current[j - 1] + 1, previous[j] + 1); } previous = current; } return previous[a.length]; } function computeSimilarity(a: string, b: string): number { if (a === b) return 1; const longer = a.length > b.length ? a : b; if (longer.length === 0) return 1; const distance = levenshteinDistance(a, b); return (longer.length - distance) / longer.length; } type AlignedItem = { type: "modify"; left: string; right: string } | { type: "delete"; left: string } | { type: "insert"; right: string }; type SqlIdentifier = { value: string; rest: string; quoted: boolean; }; function readSqlIdentifier(value: string): SqlIdentifier | null { const input = value.trimStart(); const opening = input[0]; const closing = opening === "[" ? "]" : opening; if (opening === "`" || opening === '"' || opening === "[") { let identifier = ""; for (let i = 1; i < input.length; i++) { if (input[i] !== closing) { identifier += input[i]; continue; } if (input[i + 1] === closing) { identifier += closing; i++; continue; } return { value: identifier, rest: input.slice(i + 1), quoted: true }; } return null; } const match = input.match(/^([A-Za-z_][A-Za-z0-9_$#@]*)(.*)$/s); if (!match) return null; return { value: match[1], rest: match[2], quoted: false }; } function readIdentifierAfterKeyword(line: string, keyword: RegExp): string | null { const match = line.trimStart().match(keyword); if (!match) return null; return readSqlIdentifier(line.trimStart().slice(match[0].length))?.value ?? null; } function ddlLineIdentity(line: string): string | null { const trimmed = line.trimStart(); const constraint = readIdentifierAfterKeyword(trimmed, /^CONSTRAINT\s+/i); if (constraint !== null) return `constraint:${constraint}`; const index = readIdentifierAfterKeyword(trimmed, /^(?:(?:UNIQUE|FULLTEXT|SPATIAL)\s+)?(?:KEY|INDEX)\s+/i); if (index !== null) return `index:${index}`; const createdIndex = readIdentifierAfterKeyword(trimmed, /^CREATE\s+(?:(?:UNIQUE|FULLTEXT|SPATIAL)\s+)?INDEX\s+/i); if (createdIndex !== null) return `index:${createdIndex}`; if (/^PRIMARY\s+KEY\b/i.test(trimmed)) return "constraint:primary-key"; const identifier = readSqlIdentifier(trimmed); if (!identifier || !/^\s+/.test(identifier.rest)) return null; const normalizedIdentifier = identifier.quoted ? identifier.value : identifier.value.toLowerCase(); if (!identifier.quoted && SQL_LINE_KEYWORDS.has(normalizedIdentifier)) return `keyword:${normalizedIdentifier}`; return `column:${normalizedIdentifier}`; } function isNamedDdlIdentity(identity: string | null): identity is string { return identity !== null && (identity.startsWith("column:") || identity.startsWith("constraint:") || identity.startsWith("index:")); } function comparableDdlLine(line: string): string { return line.trim().replace(/,\s*$/, ""); } function linePairSimilarity(left: string, right: string, leftIdentity = ddlLineIdentity(left), rightIdentity = ddlLineIdentity(right)): number | null { if (leftIdentity !== null || rightIdentity !== null) { if (leftIdentity === null || rightIdentity === null || leftIdentity !== rightIdentity) return null; } const similarity = computeSimilarity(left, right); return similarity >= SIMILARITY_THRESHOLD ? similarity : null; } function alignWithinWindow(removedLines: string[], addedLines: string[]): AlignedItem[] { const result: AlignedItem[] = []; let r = 0; let a = 0; while (r < removedLines.length && a < addedLines.length) { let bestR = -1; let bestA = -1; let bestSimilarity = -1; for (let ri = r; ri < Math.min(r + ALIGN_WINDOW, removedLines.length); ri++) { for (let ai = a; ai < Math.min(a + ALIGN_WINDOW, addedLines.length); ai++) { const similarity = linePairSimilarity(removedLines[ri], addedLines[ai]); if (similarity !== null && similarity > bestSimilarity) { bestSimilarity = similarity; bestR = ri; bestA = ai; } } } if (bestR < 0 || bestA < 0) { result.push({ type: "delete", left: removedLines[r++] }); result.push({ type: "insert", right: addedLines[a++] }); continue; } while (r < bestR) result.push({ type: "delete", left: removedLines[r++] }); while (a < bestA) result.push({ type: "insert", right: addedLines[a++] }); result.push({ type: "modify", left: removedLines[r++], right: addedLines[a++] }); } while (r < removedLines.length) result.push({ type: "delete", left: removedLines[r++] }); while (a < addedLines.length) result.push({ type: "insert", right: addedLines[a++] }); return result; } function buildGlobalAlignmentDirections(removedLines: string[], addedLines: string[], removedIdentities: Array, addedIdentities: Array): Uint8Array { const removedCount = removedLines.length; const addedCount = addedLines.length; const directions = new Uint8Array(removedCount * addedCount); let nextCosts = new Float64Array(addedCount + 1); for (let a = addedCount - 1; a >= 0; a--) nextCosts[a] = nextCosts[a + 1] + 1; for (let r = removedCount - 1; r >= 0; r--) { const currentCosts = new Float64Array(addedCount + 1); currentCosts[addedCount] = nextCosts[addedCount] + 1; for (let a = addedCount - 1; a >= 0; a--) { let bestCost = nextCosts[a] + 1; let direction = ALIGN_DELETE; const insertCost = currentCosts[a + 1] + 1; if (insertCost < bestCost) { bestCost = insertCost; direction = ALIGN_INSERT; } const similarity = linePairSimilarity(removedLines[r], addedLines[a], removedIdentities[r], addedIdentities[a]); if (similarity !== null) { const modifyCost = nextCosts[a + 1] + (1 - similarity); if (modifyCost <= bestCost) { bestCost = modifyCost; direction = ALIGN_MODIFY; } } currentCosts[a] = bestCost; directions[r * addedCount + a] = direction; } nextCosts = currentCosts; } return directions; } function alignLineByLine(removedLines: string[], addedLines: string[]): AlignedItem[] { const removedCount = removedLines.length; const addedCount = addedLines.length; if (removedCount * addedCount > MAX_GLOBAL_ALIGNMENT_CELLS) return alignWithinWindow(removedLines, addedLines); const removedIdentities = removedLines.map(ddlLineIdentity); const addedIdentities = addedLines.map(ddlLineIdentity); const directions = buildGlobalAlignmentDirections(removedLines, addedLines, removedIdentities, addedIdentities); const result: AlignedItem[] = []; let r = 0; let a = 0; while (r < removedLines.length || a < addedLines.length) { if (r >= removedLines.length) { result.push({ type: "insert", right: addedLines[a] }); a++; } else if (a >= addedLines.length) { result.push({ type: "delete", left: removedLines[r] }); r++; } else { const direction = directions[r * addedCount + a]; if (direction === ALIGN_MODIFY) { result.push({ type: "modify", left: removedLines[r], right: addedLines[a] }); r++; a++; } else if (direction === ALIGN_INSERT) { result.push({ type: "insert", right: addedLines[a] }); a++; } else { result.push({ type: "delete", left: removedLines[r] }); r++; } } } return result; } type DiffLineReference = { line: DiffLine; identity: string; }; function collectChangedLineReferences(hunks: DiffHunk[], side: "leftLines" | "rightLines", hunkType: "delete" | "insert"): DiffLineReference[] { const references: DiffLineReference[] = []; for (const hunk of hunks) { if (hunk.type !== hunkType) continue; for (const line of hunk[side]) { if (line.isPadding || line.type !== hunkType) continue; const identity = ddlLineIdentity(line.content); if (isNamedDdlIdentity(identity)) references.push({ line, identity }); } } return references; } function reconcileMovedDdlLines(hunks: DiffHunk[]): void { const deletedLines = collectChangedLineReferences(hunks, "leftLines", "delete"); const insertedByIdentity = new Map(); for (const reference of collectChangedLineReferences(hunks, "rightLines", "insert")) { const matches = insertedByIdentity.get(reference.identity) ?? []; matches.push(reference); insertedByIdentity.set(reference.identity, matches); } for (const deleted of deletedLines) { const matches = insertedByIdentity.get(deleted.identity); if (!matches?.length) continue; const exactIndex = matches.findIndex((inserted) => comparableDdlLine(inserted.line.content) === comparableDdlLine(deleted.line.content)); const inserted = matches.splice(exactIndex >= 0 ? exactIndex : 0, 1)[0]; if (comparableDdlLine(deleted.line.content) === comparableDdlLine(inserted.line.content)) { deleted.line.type = "equal"; inserted.line.type = "equal"; continue; } deleted.line.type = "modify"; inserted.line.type = "modify"; deleted.line.comparisonContent = inserted.line.content; inserted.line.comparisonContent = deleted.line.content; } } export function buildHunks(sourceDdl: string, targetDdl: string): DiffHunk[] { const normalizedSource = normalizeDdl(sourceDdl); const normalizedTarget = normalizeDdl(targetDdl); const changes = diffLines(normalizedSource, normalizedTarget, { newlineIsToken: false }); const hunks: DiffHunk[] = []; let leftLineNum = 1; let rightLineNum = 1; let hunkIdCounter = 0; function nextId(): string { return `hunk-${hunkIdCounter++}`; } let i = 0; while (i < changes.length) { const change = changes[i]; if (!change.added && !change.removed) { const lines = splitLines(change.value); hunks.push({ id: nextId(), type: "equal", leftLines: buildLines(lines, "equal", leftLineNum), rightLines: buildLines(lines, "equal", rightLineNum), leftTop: 0, leftBottom: 0, rightTop: 0, rightBottom: 0, }); leftLineNum += lines.length; rightLineNum += lines.length; i++; continue; } if (change.removed) { const [removedParts, afterRemoved] = collectSameKindChanges(changes, i, "removed"); const [addedParts, afterAdded] = collectSameKindChanges(changes, afterRemoved, "added"); const removedValue = removedParts.join(""); const removedLines = splitLines(removedValue); if (addedParts.length > 0) { const addedValue = addedParts.join(""); const addedLines = splitLines(addedValue); const aligned = alignLineByLine(removedLines, addedLines); for (const item of aligned) { if (item.type === "modify") { const maxLines = 1; const leftReal = buildLines([item.left], "modify", leftLineNum); const rightReal = buildLines([item.right], "modify", rightLineNum); leftLineNum++; rightLineNum++; hunks.push({ id: nextId(), type: "modify", leftLines: padLines(leftReal, maxLines, "modify"), rightLines: padLines(rightReal, maxLines, "modify"), leftTop: 0, leftBottom: 0, rightTop: 0, rightBottom: 0, }); } else if (item.type === "delete") { const leftReal = buildLines([item.left], "delete", leftLineNum); leftLineNum++; hunks.push({ id: nextId(), type: "delete", leftLines: leftReal, rightLines: buildPaddingLines(1), leftTop: 0, leftBottom: 0, rightTop: 0, rightBottom: 0, }); } else if (item.type === "insert") { const rightReal = buildLines([item.right], "insert", rightLineNum); rightLineNum++; hunks.push({ id: nextId(), type: "insert", leftLines: buildPaddingLines(1), rightLines: rightReal, leftTop: 0, leftBottom: 0, rightTop: 0, rightBottom: 0, }); } } } else { const maxLines = removedLines.length; const leftReal = buildLines(removedLines, "delete", leftLineNum); leftLineNum += removedLines.length; hunks.push({ id: nextId(), type: "delete", leftLines: leftReal, rightLines: buildPaddingLines(maxLines), leftTop: 0, leftBottom: 0, rightTop: 0, rightBottom: 0, }); } i = afterAdded; continue; } if (change.added) { const [addedParts, afterAdded] = collectSameKindChanges(changes, i, "added"); const addedValue = addedParts.join(""); const addedLines = splitLines(addedValue); const rightReal = buildLines(addedLines, "insert", rightLineNum); rightLineNum += addedLines.length; hunks.push({ id: nextId(), type: "insert", leftLines: buildPaddingLines(addedLines.length), rightLines: rightReal, leftTop: 0, leftBottom: 0, rightTop: 0, rightBottom: 0, }); i = afterAdded; continue; } } reconcileMovedDdlLines(hunks); return hunks; } function padLines(lines: DiffLine[], targetCount: number, type: HunkType): DiffLine[] { if (lines.length >= targetCount) return lines; const padding = Array.from({ length: targetCount - lines.length }, () => ({ type, content: "", lineNumber: null, isPadding: true, })); return [...lines, ...padding]; }