zenstack-kit 0.1.4 → 0.1.7

package/dist/migrations/prisma/diff.js

@@ -0,0 +1,442 @@
+import { compileCreateTable, compileDropTable, compileAddColumn, compileDropColumn, compileRenameTable, compileRenameColumn, compileCreateIndex, compileDropIndex, compileAddUniqueConstraint, compileDropConstraint, compileAddForeignKeyConstraint, compileAddPrimaryKeyConstraint, compileAlterColumn, } from "../../sql/compiler.js";
+function diffTableChanges(previousModel, currentModel, tableName) {
+    const addedFields = [];
+    const removedFields = [];
+    const alteredFields = [];
+    const addedUniqueConstraints = [];
+    const removedUniqueConstraints = [];
+    const addedIndexes = [];
+    const removedIndexes = [];
+    const addedForeignKeys = [];
+    const removedForeignKeys = [];
+    const primaryKeyChanges = [];
+    const previousFields = new Map(previousModel.columns.map((f) => [f.name, f]));
+    const currentFields = new Map(currentModel.columns.map((f) => [f.name, f]));
+    for (const [columnName, column] of currentFields.entries()) {
+        if (!previousFields.has(columnName)) {
+            addedFields.push({ tableName, column });
+        }
+    }
+    for (const [columnName, column] of previousFields.entries()) {
+        if (!currentFields.has(columnName)) {
+            removedFields.push({ tableName, column });
+        }
+    }
+    for (const [columnName, currentColumn] of currentFields.entries()) {
+        const previousColumn = previousFields.get(columnName);
+        if (!previousColumn)
+            continue;
+        if (previousColumn.type !== currentColumn.type ||
+            previousColumn.notNull !== currentColumn.notNull ||
+            previousColumn.default !== currentColumn.default) {
+            alteredFields.push({
+                tableName,
+                columnName,
+                previous: previousColumn,
+                current: currentColumn,
+            });
+        }
+    }
+    const prevUnique = new Map(previousModel.uniqueConstraints.map((c) => [c.name, c]));
+    const currUnique = new Map(currentModel.uniqueConstraints.map((c) => [c.name, c]));
+    for (const [name, constraint] of currUnique.entries()) {
+        if (!prevUnique.has(name)) {
+            addedUniqueConstraints.push({ tableName, constraint });
+        }
+    }
+    for (const [name, constraint] of prevUnique.entries()) {
+        if (!currUnique.has(name)) {
+            removedUniqueConstraints.push({ tableName, constraint });
+        }
+    }
+    const prevIndexes = new Map(previousModel.indexes.map((i) => [i.name, i]));
+    const currIndexes = new Map(currentModel.indexes.map((i) => [i.name, i]));
+    for (const [name, index] of currIndexes.entries()) {
+        if (!prevIndexes.has(name)) {
+            addedIndexes.push({ tableName, index });
+        }
+    }
+    for (const [name, index] of prevIndexes.entries()) {
+        if (!currIndexes.has(name)) {
+            removedIndexes.push({ tableName, index });
+        }
+    }
+    const prevFks = new Map(previousModel.foreignKeys.map((f) => [f.name, f]));
+    const currFks = new Map(currentModel.foreignKeys.map((f) => [f.name, f]));
+    for (const [name, fk] of currFks.entries()) {
+        if (!prevFks.has(name)) {
+            addedForeignKeys.push({ tableName, foreignKey: fk });
+        }
+    }
+    for (const [name, fk] of prevFks.entries()) {
+        if (!currFks.has(name)) {
+            removedForeignKeys.push({ tableName, foreignKey: fk });
+        }
+    }
+    const prevPk = previousModel.primaryKey;
+    const currPk = currentModel.primaryKey;
+    const pkEqual = (prevPk?.name ?? "") === (currPk?.name ?? "") &&
+        JSON.stringify(prevPk?.columns ?? []) === JSON.stringify(currPk?.columns ?? []);
+    if (!pkEqual) {
+        primaryKeyChanges.push({
+            tableName,
+            previous: prevPk,
+            current: currPk,
+        });
+    }
+    return {
+        addedFields,
+        removedFields,
+        alteredFields,
+        addedUniqueConstraints,
+        removedUniqueConstraints,
+        addedIndexes,
+        removedIndexes,
+        addedForeignKeys,
+        removedForeignKeys,
+        primaryKeyChanges,
+    };
+}
+export function diffSchemas(previous, current) {
+    const previousModels = new Map();
+    const currentModels = new Map();
+    previous?.tables.forEach((model) => previousModels.set(model.name, model));
+    current.tables.forEach((model) => currentModels.set(model.name, model));
+    const addedModels = [];
+    const removedModels = [];
+    for (const [tableName, model] of currentModels.entries()) {
+        if (!previousModels.has(tableName)) {
+            addedModels.push(model);
+        }
+    }
+    for (const [tableName, model] of previousModels.entries()) {
+        if (!currentModels.has(tableName)) {
+            removedModels.push(model);
+        }
+    }
+    const addedFields = [];
+    const removedFields = [];
+    const alteredFields = [];
+    const addedUniqueConstraints = [];
+    const removedUniqueConstraints = [];
+    const addedIndexes = [];
+    const removedIndexes = [];
+    const addedForeignKeys = [];
+    const removedForeignKeys = [];
+    const primaryKeyChanges = [];
+    for (const [tableName, currentModel] of currentModels.entries()) {
+        const previousModel = previousModels.get(tableName);
+        if (!previousModel)
+            continue;
+        const modelDiff = diffTableChanges(previousModel, currentModel, tableName);
+        addedFields.push(...modelDiff.addedFields);
+        removedFields.push(...modelDiff.removedFields);
+        alteredFields.push(...modelDiff.alteredFields);
+        addedUniqueConstraints.push(...modelDiff.addedUniqueConstraints);
+        removedUniqueConstraints.push(...modelDiff.removedUniqueConstraints);
+        addedIndexes.push(...modelDiff.addedIndexes);
+        removedIndexes.push(...modelDiff.removedIndexes);
+        addedForeignKeys.push(...modelDiff.addedForeignKeys);
+        removedForeignKeys.push(...modelDiff.removedForeignKeys);
+        primaryKeyChanges.push(...modelDiff.primaryKeyChanges);
+    }
+    return {
+        addedModels,
+        removedModels,
+        addedFields,
+        removedFields,
+        alteredFields,
+        addedUniqueConstraints,
+        removedUniqueConstraints,
+        addedIndexes,
+        removedIndexes,
+        addedForeignKeys,
+        removedForeignKeys,
+        primaryKeyChanges,
+        renamedTables: [],
+        renamedColumns: [],
+    };
+}
+function columnsSignature(columns) {
+    return columns.join("|");
+}
+function consumeSignature(map, signature) {
+    const count = map.get(signature) ?? 0;
+    if (count > 0) {
+        map.set(signature, count - 1);
+        return true;
+    }
+    return false;
+}
+function buildSignatureCount(items, getSignature) {
+    const counts = new Map();
+    for (const item of items) {
+        const signature = getSignature(item);
+        counts.set(signature, (counts.get(signature) ?? 0) + 1);
+    }
+    return counts;
+}
+function columnsEqual(a, b) {
+    return JSON.stringify(a ?? []) === JSON.stringify(b ?? []);
+}
+function filterRenamedConstraintChanges(previousModel, currentModel, modelDiff) {
+    const prevUnique = buildSignatureCount(previousModel.uniqueConstraints, (c) => columnsSignature(c.columns));
+    const currUnique = buildSignatureCount(currentModel.uniqueConstraints, (c) => columnsSignature(c.columns));
+    const prevIndexes = buildSignatureCount(previousModel.indexes, (i) => columnsSignature(i.columns));
+    const currIndexes = buildSignatureCount(currentModel.indexes, (i) => columnsSignature(i.columns));
+    const prevFks = buildSignatureCount(previousModel.foreignKeys, (f) => `${columnsSignature(f.columns)}->${f.referencedTable}:${columnsSignature(f.referencedColumns)}`);
+    const currFks = buildSignatureCount(currentModel.foreignKeys, (f) => `${columnsSignature(f.columns)}->${f.referencedTable}:${columnsSignature(f.referencedColumns)}`);
+    const addedUniqueConstraints = modelDiff.addedUniqueConstraints.filter(({ constraint }) => !consumeSignature(prevUnique, columnsSignature(constraint.columns)));
+    const removedUniqueConstraints = modelDiff.removedUniqueConstraints.filter(({ constraint }) => !consumeSignature(currUnique, columnsSignature(constraint.columns)));
+    const addedIndexes = modelDiff.addedIndexes.filter(({ index }) => !consumeSignature(prevIndexes, columnsSignature(index.columns)));
+    const removedIndexes = modelDiff.removedIndexes.filter(({ index }) => !consumeSignature(currIndexes, columnsSignature(index.columns)));
+    const addedForeignKeys = modelDiff.addedForeignKeys.filter(({ foreignKey }) => !consumeSignature(prevFks, `${columnsSignature(foreignKey.columns)}->${foreignKey.referencedTable}:${columnsSignature(foreignKey.referencedColumns)}`));
+    const removedForeignKeys = modelDiff.removedForeignKeys.filter(({ foreignKey }) => !consumeSignature(currFks, `${columnsSignature(foreignKey.columns)}->${foreignKey.referencedTable}:${columnsSignature(foreignKey.referencedColumns)}`));
+    let primaryKeyChanges = modelDiff.primaryKeyChanges;
+    if (previousModel.primaryKey && currentModel.primaryKey) {
+        if (columnsEqual(previousModel.primaryKey.columns, currentModel.primaryKey.columns)) {
+            primaryKeyChanges = [];
+        }
+    }
+    return {
+        ...modelDiff,
+        addedUniqueConstraints,
+        removedUniqueConstraints,
+        addedIndexes,
+        removedIndexes,
+        addedForeignKeys,
+        removedForeignKeys,
+        primaryKeyChanges,
+    };
+}
+export function applyRenameMappings(diff, renameTables = [], renameColumns = []) {
+    const removedModels = [...diff.removedModels];
+    const addedModels = [...diff.addedModels];
+    const removedFields = [...diff.removedFields];
+    const addedFields = [...diff.addedFields];
+    const alteredFields = [...diff.alteredFields];
+    const addedUniqueConstraints = [...diff.addedUniqueConstraints];
+    const removedUniqueConstraints = [...diff.removedUniqueConstraints];
+    const addedIndexes = [...diff.addedIndexes];
+    const removedIndexes = [...diff.removedIndexes];
+    const addedForeignKeys = [...diff.addedForeignKeys];
+    const removedForeignKeys = [...diff.removedForeignKeys];
+    const primaryKeyChanges = [...diff.primaryKeyChanges];
+    const renamedTables = [];
+    const renamedColumns = [];
+    const renamedTableMap = new Map();
+    renameTables.forEach((mapping) => {
+        const fromIndex = removedModels.findIndex((model) => model.name === mapping.from);
+        const toIndex = addedModels.findIndex((model) => model.name === mapping.to);
+        if (fromIndex === -1 || toIndex === -1) {
+            return;
+        }
+        const previousModel = removedModels[fromIndex];
+        const currentModel = addedModels[toIndex];
+        removedModels.splice(fromIndex, 1);
+        addedModels.splice(toIndex, 1);
+        renamedTables.push({ from: mapping.from, to: mapping.to });
+        renamedTableMap.set(mapping.from, mapping.to);
+        const modelDiff = filterRenamedConstraintChanges(previousModel, currentModel, diffTableChanges(previousModel, currentModel, mapping.to));
+        addedFields.push(...modelDiff.addedFields);
+        removedFields.push(...modelDiff.removedFields);
+        alteredFields.push(...modelDiff.alteredFields);
+        addedUniqueConstraints.push(...modelDiff.addedUniqueConstraints);
+        removedUniqueConstraints.push(...modelDiff.removedUniqueConstraints);
+        addedIndexes.push(...modelDiff.addedIndexes);
+        removedIndexes.push(...modelDiff.removedIndexes);
+        addedForeignKeys.push(...modelDiff.addedForeignKeys);
+        removedForeignKeys.push(...modelDiff.removedForeignKeys);
+        primaryKeyChanges.push(...modelDiff.primaryKeyChanges);
+    });
+    const remapTableName = (tableName) => renamedTableMap.get(tableName) ?? tableName;
+    const remapTableEntries = (items) => items.map((item) => ({ ...item, tableName: remapTableName(item.tableName) }));
+    if (renamedTableMap.size > 0) {
+        removedFields.forEach((entry) => {
+            const mapped = renamedTableMap.get(entry.tableName);
+            if (mapped) {
+                entry.tableName = mapped;
+            }
+        });
+    }
+    renameColumns.forEach((mapping) => {
+        const mappedTable = remapTableName(mapping.table);
+        const removedIdx = removedFields.findIndex((f) => f.tableName === mappedTable && f.column.name === mapping.from);
+        const addedIdx = addedFields.findIndex((f) => f.tableName === mappedTable && f.column.name === mapping.to);
+        if (removedIdx !== -1 && addedIdx !== -1) {
+            removedFields.splice(removedIdx, 1);
+            addedFields.splice(addedIdx, 1);
+            renamedColumns.push({ tableName: mappedTable, from: mapping.from, to: mapping.to });
+        }
+    });
+    return {
+        ...diff,
+        removedModels,
+        addedModels,
+        removedFields: remapTableEntries(removedFields),
+        addedFields: remapTableEntries(addedFields),
+        alteredFields: remapTableEntries(alteredFields),
+        renamedTables,
+        renamedColumns,
+        addedUniqueConstraints: remapTableEntries(addedUniqueConstraints),
+        removedUniqueConstraints: remapTableEntries(removedUniqueConstraints),
+        addedIndexes: remapTableEntries(addedIndexes),
+        removedIndexes: remapTableEntries(removedIndexes),
+        addedForeignKeys: remapTableEntries(addedForeignKeys),
+        removedForeignKeys: remapTableEntries(removedForeignKeys),
+        primaryKeyChanges: remapTableEntries(primaryKeyChanges),
+    };
+}
+/**
+ * Topologically sort tables so that referenced tables come before tables that reference them.
+ * Tables with no foreign keys come first, then tables that only reference already-ordered tables.
+ */
+function sortTablesByDependencies(tables) {
+    const tableMap = new Map(tables.map((t) => [t.name, t]));
+    const sorted = [];
+    const visited = new Set();
+    const visiting = new Set();
+    function visit(tableName) {
+        if (visited.has(tableName))
+            return;
+        if (visiting.has(tableName)) {
+            // Circular dependency - just add it and let the DB handle it
+            return;
+        }
+        const table = tableMap.get(tableName);
+        if (!table)
+            return;
+        visiting.add(tableName);
+        // Visit all tables this table references first
+        for (const fk of table.foreignKeys) {
+            if (tableMap.has(fk.referencedTable) && fk.referencedTable !== tableName) {
+                visit(fk.referencedTable);
+            }
+        }
+        visiting.delete(tableName);
+        visited.add(tableName);
+        sorted.push(table);
+    }
+    for (const table of tables) {
+        visit(table.name);
+    }
+    return sorted;
+}
+/**
+ * Build SQL statements from diff
+ */
+export function buildSqlStatements(diff, dialect) {
+    const up = [];
+    const down = [];
+    const compileOpts = { dialect };
+    // Table renames
+    for (const rename of diff.renamedTables) {
+        up.push(compileRenameTable(rename.from, rename.to, compileOpts));
+        down.unshift(compileRenameTable(rename.to, rename.from, compileOpts));
+    }
+    // Column renames
+    for (const rename of diff.renamedColumns) {
+        up.push(compileRenameColumn(rename.tableName, rename.from, rename.to, compileOpts));
+        down.unshift(compileRenameColumn(rename.tableName, rename.to, rename.from, compileOpts));
+    }
+    // Create tables (sorted by dependency order so referenced tables are created first)
+    const sortedAddedModels = sortTablesByDependencies(diff.addedModels);
+    for (const model of sortedAddedModels) {
+        up.push(compileCreateTable(model, compileOpts));
+        down.unshift(compileDropTable(model.name, compileOpts));
+    }
+    // Drop tables
+    for (const model of diff.removedModels) {
+        up.push(compileDropTable(model.name, compileOpts));
+        down.unshift(compileCreateTable(model, compileOpts));
+    }
+    // Primary key changes (drop old first)
+    for (const change of diff.primaryKeyChanges) {
+        if (change.previous) {
+            up.push(compileDropConstraint(change.tableName, change.previous.name, compileOpts));
+            down.unshift(compileAddPrimaryKeyConstraint(change.tableName, change.previous.name, change.previous.columns, compileOpts));
+        }
+    }
+    // Drop foreign keys first (before dropping columns)
+    for (const { tableName, foreignKey } of diff.removedForeignKeys) {
+        up.push(compileDropConstraint(tableName, foreignKey.name, compileOpts));
+        down.unshift(compileAddForeignKeyConstraint(tableName, foreignKey.name, foreignKey.columns, foreignKey.referencedTable, foreignKey.referencedColumns, compileOpts));
+    }
+    // Drop unique constraints
+    for (const { tableName, constraint } of diff.removedUniqueConstraints) {
+        up.push(compileDropConstraint(tableName, constraint.name, compileOpts));
+        down.unshift(compileAddUniqueConstraint(tableName, constraint.name, constraint.columns, compileOpts));
+    }
+    // Drop indexes
+    for (const { tableName, index } of diff.removedIndexes) {
+        up.push(compileDropIndex(index.name, compileOpts));
+        down.unshift(compileCreateIndex(tableName, index.name, index.columns, compileOpts));
+    }
+    // Add columns
+    for (const { tableName, column } of diff.addedFields) {
+        up.push(compileAddColumn(tableName, column, compileOpts));
+        down.unshift(compileDropColumn(tableName, column.name, compileOpts));
+    }
+    // Drop columns
+    for (const { tableName, column } of diff.removedFields) {
+        up.push(compileDropColumn(tableName, column.name, compileOpts));
+        down.unshift(compileAddColumn(tableName, column, compileOpts));
+    }
+    // Alter columns
+    for (const change of diff.alteredFields) {
+        const typeChanged = change.previous.type !== change.current.type;
+        const nullChanged = change.previous.notNull !== change.current.notNull;
+        const defaultChanged = change.previous.default !== change.current.default;
+        if (typeChanged) {
+            up.push(...compileAlterColumn(change.tableName, change.columnName, { setType: change.current.type }, compileOpts));
+            down.unshift(...compileAlterColumn(change.tableName, change.columnName, { setType: change.previous.type }, compileOpts));
+        }
+        if (nullChanged) {
+            if (change.current.notNull) {
+                up.push(...compileAlterColumn(change.tableName, change.columnName, { setNotNull: true }, compileOpts));
+                down.unshift(...compileAlterColumn(change.tableName, change.columnName, { dropNotNull: true }, compileOpts));
+            }
+            else {
+                up.push(...compileAlterColumn(change.tableName, change.columnName, { dropNotNull: true }, compileOpts));
+                down.unshift(...compileAlterColumn(change.tableName, change.columnName, { setNotNull: true }, compileOpts));
+            }
+        }
+        if (defaultChanged) {
+            if (change.current.default !== undefined) {
+                up.push(...compileAlterColumn(change.tableName, change.columnName, { setDefault: change.current.default }, compileOpts));
+            }
+            else {
+                up.push(...compileAlterColumn(change.tableName, change.columnName, { dropDefault: true }, compileOpts));
+            }
+            if (change.previous.default !== undefined) {
+                down.unshift(...compileAlterColumn(change.tableName, change.columnName, { setDefault: change.previous.default }, compileOpts));
+            }
+            else {
+                down.unshift(...compileAlterColumn(change.tableName, change.columnName, { dropDefault: true }, compileOpts));
+            }
+        }
+    }
+    // Primary key changes (add new)
+    for (const change of diff.primaryKeyChanges) {
+        if (change.current) {
+            up.push(compileAddPrimaryKeyConstraint(change.tableName, change.current.name, change.current.columns, compileOpts));
+            down.unshift(compileDropConstraint(change.tableName, change.current.name, compileOpts));
+        }
+    }
+    // Add unique constraints
+    for (const { tableName, constraint } of diff.addedUniqueConstraints) {
+        up.push(compileAddUniqueConstraint(tableName, constraint.name, constraint.columns, compileOpts));
+        down.unshift(compileDropConstraint(tableName, constraint.name, compileOpts));
+    }
+    // Add indexes
+    for (const { tableName, index } of diff.addedIndexes) {
+        up.push(compileCreateIndex(tableName, index.name, index.columns, compileOpts));
+        down.unshift(compileDropIndex(index.name, compileOpts));
+    }
+    // Add foreign keys
+    for (const { tableName, foreignKey } of diff.addedForeignKeys) {
+        up.push(compileAddForeignKeyConstraint(tableName, foreignKey.name, foreignKey.columns, foreignKey.referencedTable, foreignKey.referencedColumns, compileOpts));
+        down.unshift(compileDropConstraint(tableName, foreignKey.name, compileOpts));
+    }
+    return { up, down };
+}

package/dist/migrations/prisma/log.d.ts

@@ -0,0 +1,31 @@
+export interface MigrationLogEntry {
+    /** Migration folder name e.g. "20260108120000_init" */
+    name: string;
+    /** SHA256 checksum of migration.sql content (64 hex chars) */
+    checksum: string;
+}
+/**
+ * Calculate SHA256 checksum of migration SQL
+ */
+export declare function calculateChecksum(sql: string): string;
+/**
+ * Get the path to the migration log file
+ */
+export declare function getMigrationLogPath(outputPath: string): string;
+/**
+ * Read migration log file
+ */
+export declare function readMigrationLog(outputPath: string): Promise<MigrationLogEntry[]>;
+/**
+ * Write migration log file
+ */
+export declare function writeMigrationLog(outputPath: string, entries: MigrationLogEntry[]): Promise<void>;
+/**
+ * Append a single entry to the migration log
+ */
+export declare function appendToMigrationLog(outputPath: string, entry: MigrationLogEntry): Promise<void>;
+/**
+ * Scan migration folders and compute checksums for each
+ */
+export declare function scanMigrationFolders(outputPath: string): Promise<MigrationLogEntry[]>;
+//# sourceMappingURL=log.d.ts.map

package/dist/migrations/prisma/log.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"log.d.ts","sourceRoot":"","sources":["../../../src/migrations/prisma/log.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,iBAAiB;IAChC,uDAAuD;IACvD,IAAI,EAAE,MAAM,CAAC;IACb,8DAA8D;IAC9D,QAAQ,EAAE,MAAM,CAAC;CAClB;AAMD;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAErD;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAE9D;AAwBD;;GAEG;AACH,wBAAsB,gBAAgB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,EAAE,CAAC,CAWvF;AAED;;GAEG;AACH,wBAAsB,iBAAiB,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,iBAAiB,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAIvG;AAED;;GAEG;AACH,wBAAsB,oBAAoB,CAAC,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CAItG;AAED;;GAEG;AACH,wBAAsB,oBAAoB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,EAAE,CAAC,CA4B3F"}

package/dist/migrations/prisma/log.js

@@ -0,0 +1,101 @@
+import * as fs from "fs/promises";
+import * as path from "path";
+import * as crypto from "crypto";
+const MIGRATION_LOG_HEADER = `# zenstack-kit migration log
+# Format: <migration_name> <checksum>
+`;
+/**
+ * Calculate SHA256 checksum of migration SQL
+ */
+export function calculateChecksum(sql) {
+    return crypto.createHash("sha256").update(sql).digest("hex");
+}
+/**
+ * Get the path to the migration log file
+ */
+export function getMigrationLogPath(outputPath) {
+    return path.join(outputPath, "meta", "_migration_log");
+}
+/**
+ * Parse migration log content into entries
+ */
+function parseMigrationLog(content) {
+    return content
+        .split("\n")
+        .filter((line) => line.trim() && !line.startsWith("#"))
+        .map((line) => {
+        const [name, checksum] = line.split(" ");
+        return { name, checksum };
+    })
+        .filter((entry) => entry.name && entry.checksum);
+}
+/**
+ * Serialize migration log entries to string
+ */
+function serializeMigrationLog(entries) {
+    const lines = entries.map((e) => `${e.name} ${e.checksum}`).join("\n");
+    return MIGRATION_LOG_HEADER + lines + (lines.length > 0 ? "\n" : "");
+}
+/**
+ * Read migration log file
+ */
+export async function readMigrationLog(outputPath) {
+    const logPath = getMigrationLogPath(outputPath);
+    try {
+        const content = await fs.readFile(logPath, "utf-8");
+        return parseMigrationLog(content);
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+            return [];
+        }
+        throw error;
+    }
+}
+/**
+ * Write migration log file
+ */
+export async function writeMigrationLog(outputPath, entries) {
+    const logPath = getMigrationLogPath(outputPath);
+    await fs.mkdir(path.dirname(logPath), { recursive: true });
+    await fs.writeFile(logPath, serializeMigrationLog(entries), "utf-8");
+}
+/**
+ * Append a single entry to the migration log
+ */
+export async function appendToMigrationLog(outputPath, entry) {
+    const entries = await readMigrationLog(outputPath);
+    entries.push(entry);
+    await writeMigrationLog(outputPath, entries);
+}
+/**
+ * Scan migration folders and compute checksums for each
+ */
+export async function scanMigrationFolders(outputPath) {
+    const entries = [];
+    try {
+        const dirEntries = await fs.readdir(outputPath, { withFileTypes: true });
+        const migrationFolders = dirEntries
+            .filter((e) => e.isDirectory() && /^\d{14}_/.test(e.name))
+            .map((e) => e.name)
+            .sort();
+        for (const folderName of migrationFolders) {
+            const sqlPath = path.join(outputPath, folderName, "migration.sql");
+            try {
+                const sqlContent = await fs.readFile(sqlPath, "utf-8");
+                const checksum = calculateChecksum(sqlContent);
+                entries.push({ name: folderName, checksum });
+            }
+            catch {
+                // Skip folders without migration.sql
+            }
+        }
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+            return [];
+        }
+        throw error;
+    }
+    return entries;
+}

package/dist/migrations/prisma/rename.d.ts

@@ -0,0 +1,23 @@
+export interface PotentialTableRename {
+    from: string;
+    to: string;
+}
+export interface PotentialColumnRename {
+    table: string;
+    from: string;
+    to: string;
+}
+export interface PotentialRenames {
+    tables: PotentialTableRename[];
+    columns: PotentialColumnRename[];
+}
+/**
+ * Detect potential renames by finding removed+added pairs.
+ * A table rename is detected when one table is removed and one is added.
+ * A column rename is detected when within the same table, one column is removed and one is added.
+ */
+export declare function detectPotentialRenames(options: {
+    schemaPath: string;
+    outputPath: string;
+}): Promise<PotentialRenames>;
+//# sourceMappingURL=rename.d.ts.map

package/dist/migrations/prisma/rename.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rename.d.ts","sourceRoot":"","sources":["../../../src/migrations/prisma/rename.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;CACZ;AAED,MAAM,WAAW,qBAAqB;IACpC,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;CACZ;AAED,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,oBAAoB,EAAE,CAAC;IAC/B,OAAO,EAAE,qBAAqB,EAAE,CAAC;CAClC;AAED;;;;GAIG;AACH,wBAAsB,sBAAsB,CAAC,OAAO,EAAE;IACpD,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;CACpB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAwD5B"}

package/dist/migrations/prisma/rename.js

@@ -0,0 +1,57 @@
+import { generateSchemaSnapshot } from "../../schema/snapshot.js";
+import { diffSchemas } from "./diff.js";
+import { getSnapshotPaths, readSnapshot } from "./snapshot.js";
+/**
+ * Detect potential renames by finding removed+added pairs.
+ * A table rename is detected when one table is removed and one is added.
+ * A column rename is detected when within the same table, one column is removed and one is added.
+ */
+export async function detectPotentialRenames(options) {
+    const currentSchema = await generateSchemaSnapshot(options.schemaPath);
+    const { snapshotPath } = getSnapshotPaths(options.outputPath);
+    const previousSnapshot = await readSnapshot(snapshotPath);
+    const diff = diffSchemas(previousSnapshot?.schema ?? null, currentSchema);
+    const result = {
+        tables: [],
+        columns: [],
+    };
+    // Detect potential table renames: one removed + one added
+    // For simplicity, if there's exactly one removed and one added, suggest it as a rename
+    // For multiple, pair them up by order (user can disambiguate)
+    const minTablePairs = Math.min(diff.removedModels.length, diff.addedModels.length);
+    for (let i = 0; i < minTablePairs; i++) {
+        result.tables.push({
+            from: diff.removedModels[i].name,
+            to: diff.addedModels[i].name,
+        });
+    }
+    // Detect potential column renames within same table
+    // Group removed/added fields by table
+    const removedByTable = new Map();
+    const addedByTable = new Map();
+    for (const { tableName, column } of diff.removedFields) {
+        if (!removedByTable.has(tableName)) {
+            removedByTable.set(tableName, []);
+        }
+        removedByTable.get(tableName).push(column.name);
+    }
+    for (const { tableName, column } of diff.addedFields) {
+        if (!addedByTable.has(tableName)) {
+            addedByTable.set(tableName, []);
+        }
+        addedByTable.get(tableName).push(column.name);
+    }
+    // For each table with both removed and added columns, suggest renames
+    for (const [tableName, removed] of removedByTable.entries()) {
+        const added = addedByTable.get(tableName) || [];
+        const minPairs = Math.min(removed.length, added.length);
+        for (let i = 0; i < minPairs; i++) {
+            result.columns.push({
+                table: tableName,
+                from: removed[i],
+                to: added[i],
+            });
+        }
+    }
+    return result;
+}