zenstack-kit 0.1.4 → 0.1.7

package/dist/migrations/prisma.js

@@ -1,1168 +1,5 @@
-/**
- * Prisma-compatible migrations
- *
- * Generates migrations in Prisma format:
- * - Folder structure: migrations/<timestamp>_<name>/migration.sql
- * - Tracks migrations in _prisma_migrations table
- * - Compatible with `prisma migrate deploy`
- */
-import * as fs from "fs/promises";
-import * as path from "path";
-import * as crypto from "crypto";
-import { sql } from "kysely";
-import { createKyselyAdapter } from "../sql/kysely-adapter.js";
-import { generateSchemaSnapshot, createSnapshot } from "../schema/snapshot.js";
-import { compileCreateTable, compileDropTable, compileAddColumn, compileDropColumn, compileRenameTable, compileRenameColumn, compileCreateIndex, compileDropIndex, compileAddUniqueConstraint, compileDropConstraint, compileAddForeignKeyConstraint, compileAddPrimaryKeyConstraint, compileAlterColumn, } from "../sql/compiler.js";
-/**
- * Generate timestamp string for migration folder name
- */
-export function generateTimestamp() {
-    const now = new Date();
-    return [
-        now.getFullYear(),
-        String(now.getMonth() + 1).padStart(2, "0"),
-        String(now.getDate()).padStart(2, "0"),
-        String(now.getHours()).padStart(2, "0"),
-        String(now.getMinutes()).padStart(2, "0"),
-        String(now.getSeconds()).padStart(2, "0"),
-    ].join("");
-}
-/**
- * Get paths for snapshot file
- */
-function getSnapshotPaths(outputPath) {
-    const metaDir = path.join(outputPath, "meta");
-    return {
-        metaDir,
-        snapshotPath: path.join(metaDir, "_snapshot.json"),
-    };
-}
-/**
- * Read existing snapshot
- */
-async function readSnapshot(snapshotPath) {
-    try {
-        const content = await fs.readFile(snapshotPath, "utf-8");
-        const snapshot = JSON.parse(content);
-        if (!snapshot || snapshot.version !== 2 || !snapshot.schema) {
-            throw new Error("Snapshot format is invalid");
-        }
-        return snapshot;
-    }
-    catch (error) {
-        if (error instanceof Error && "code" in error && error.code === "ENOENT") {
-            return null;
-        }
-        throw error;
-    }
-}
-/**
- * Write snapshot to file
- */
-export async function writeSnapshot(snapshotPath, schema) {
-    const snapshot = createSnapshot(schema);
-    await fs.mkdir(path.dirname(snapshotPath), { recursive: true });
-    await fs.writeFile(snapshotPath, JSON.stringify(snapshot, null, 2), "utf-8");
-}
-/**
- * Diff two schemas and return the changes
- */
-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,
-    };
-}
-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);
-        }
-    }
-    // Field-level changes for existing tables
-    const addedFields = [];
-    const removedFields = [];
-    const alteredFields = [];
-    // Constraint changes
-    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,
-    };
-}
-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
- */
-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 };
-}
-/**
- * Create a Prisma-compatible migration
- */
-export async function createPrismaMigration(options) {
-    const currentSchema = await generateSchemaSnapshot(options.schemaPath);
-    const { snapshotPath } = getSnapshotPaths(options.outputPath);
-    const previousSnapshot = await readSnapshot(snapshotPath);
-    const diff = applyRenameMappings(diffSchemas(previousSnapshot?.schema ?? null, currentSchema), options.renameTables, options.renameColumns);
-    const { up, down } = buildSqlStatements(diff, options.dialect);
-    if (up.length === 0) {
-        return null;
-    }
-    const timestamp = Date.now();
-    const timestampStr = generateTimestamp();
-    const safeName = options.name.replace(/[^a-z0-9]/gi, "_").toLowerCase();
-    const folderName = `${timestampStr}_${safeName}`;
-    const folderPath = path.join(options.outputPath, folderName);
-    // Build migration.sql content with comments
-    const sqlContent = [
-        `-- Migration: ${options.name}`,
-        `-- Generated at: ${new Date(timestamp).toISOString()}`,
-        "",
-        ...up,
-        "",
-    ].join("\n");
-    // Create migration folder and file
-    await fs.mkdir(folderPath, { recursive: true });
-    await fs.writeFile(path.join(folderPath, "migration.sql"), sqlContent, "utf-8");
-    // Update snapshot
-    await writeSnapshot(snapshotPath, currentSchema);
-    // Append to migration log
-    const checksum = calculateChecksum(sqlContent);
-    await appendToMigrationLog(options.outputPath, { name: folderName, checksum });
-    return {
-        folderName,
-        folderPath,
-        sql: sqlContent,
-        timestamp,
-    };
-}
-/**
- * Create an initial migration that creates all tables from scratch.
- * This is used when initializing a project where the database is empty.
- */
-export async function createInitialMigration(options) {
-    const currentSchema = await generateSchemaSnapshot(options.schemaPath);
-    const { snapshotPath } = getSnapshotPaths(options.outputPath);
-    // Diff against empty schema to get full creation SQL
-    const diff = diffSchemas(null, currentSchema);
-    const { up } = buildSqlStatements(diff, options.dialect);
-    const timestamp = Date.now();
-    const timestampStr = generateTimestamp();
-    const safeName = (options.name ?? "init").replace(/[^a-z0-9]/gi, "_").toLowerCase();
-    const folderName = `${timestampStr}_${safeName}`;
-    const folderPath = path.join(options.outputPath, folderName);
-    // Build migration.sql content with comments
-    const sqlContent = [
-        `-- Migration: ${options.name ?? "init"}`,
-        `-- Generated at: ${new Date(timestamp).toISOString()}`,
-        "",
-        ...up,
-        "",
-    ].join("\n");
-    // Create migration folder and file
-    await fs.mkdir(folderPath, { recursive: true });
-    await fs.writeFile(path.join(folderPath, "migration.sql"), sqlContent, "utf-8");
-    // Update snapshot
-    await writeSnapshot(snapshotPath, currentSchema);
-    // Append to migration log
-    const checksum = calculateChecksum(sqlContent);
-    await appendToMigrationLog(options.outputPath, { name: folderName, checksum });
-    return {
-        folderName,
-        folderPath,
-        sql: sqlContent,
-        timestamp,
-    };
-}
-/**
- * Ensure _prisma_migrations table exists
- */
-async function ensureMigrationsTable(db, tableName, schema, dialect) {
-    const fullTableName = schema && dialect === "postgres" ? `${schema}.${tableName}` : tableName;
-    if (dialect === "sqlite") {
-        await sql `
-      CREATE TABLE IF NOT EXISTS ${sql.raw(`"${tableName}"`)} (
-        id TEXT PRIMARY KEY,
-        checksum TEXT NOT NULL,
-        finished_at TEXT,
-        migration_name TEXT NOT NULL,
-        logs TEXT,
-        rolled_back_at TEXT,
-        started_at TEXT NOT NULL DEFAULT (datetime('now')),
-        applied_steps_count INTEGER NOT NULL DEFAULT 0
-      )
-    `.execute(db);
-    }
-    else if (dialect === "postgres") {
-        await sql `
-      CREATE TABLE IF NOT EXISTS ${sql.raw(`"${schema}"."${tableName}"`)} (
-        id VARCHAR(36) PRIMARY KEY,
-        checksum VARCHAR(64) NOT NULL,
-        finished_at TIMESTAMPTZ,
-        migration_name VARCHAR(255) NOT NULL,
-        logs TEXT,
-        rolled_back_at TIMESTAMPTZ,
-        started_at TIMESTAMPTZ NOT NULL DEFAULT now(),
-        applied_steps_count INTEGER NOT NULL DEFAULT 0
-      )
-    `.execute(db);
-    }
-    else {
-        await sql `
-      CREATE TABLE IF NOT EXISTS ${sql.raw(`\`${tableName}\``)} (
-        id VARCHAR(36) PRIMARY KEY,
-        checksum VARCHAR(64) NOT NULL,
-        finished_at DATETIME,
-        migration_name VARCHAR(255) NOT NULL,
-        logs TEXT,
-        rolled_back_at DATETIME,
-        started_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
-        applied_steps_count INTEGER NOT NULL DEFAULT 0
-      )
-    `.execute(db);
-    }
-}
-/**
- * Get list of applied migrations from _prisma_migrations table
- */
-async function getAppliedMigrations(db, tableName, schema, dialect) {
-    let result;
-    if (dialect === "postgres" && schema) {
-        result = await sql `
-      SELECT * FROM ${sql.raw(`"${schema}"."${tableName}"`)}
-      WHERE rolled_back_at IS NULL AND finished_at IS NOT NULL
-    `.execute(db);
-    }
-    else if (dialect === "sqlite") {
-        result = await sql `
-      SELECT * FROM ${sql.raw(`"${tableName}"`)}
-      WHERE rolled_back_at IS NULL AND finished_at IS NOT NULL
-    `.execute(db);
-    }
-    else {
-        result = await sql `
-      SELECT * FROM ${sql.raw(`\`${tableName}\``)}
-      WHERE rolled_back_at IS NULL AND finished_at IS NOT NULL
-    `.execute(db);
-    }
-    return new Map(result.rows.map((row) => [row.migration_name, row]));
-}
-/**
- * Record a migration in _prisma_migrations table
- */
-async function recordMigration(db, tableName, schema, dialect, migrationName, checksum) {
-    const id = crypto.randomUUID();
-    if (dialect === "postgres" && schema) {
-        await sql `
-      INSERT INTO ${sql.raw(`"${schema}"."${tableName}"`)} (id, checksum, migration_name, finished_at, applied_steps_count)
-      VALUES (${id}, ${checksum}, ${migrationName}, now(), 1)
-    `.execute(db);
-    }
-    else if (dialect === "sqlite") {
-        await sql `
-      INSERT INTO ${sql.raw(`"${tableName}"`)} (id, checksum, migration_name, finished_at, applied_steps_count)
-      VALUES (${id}, ${checksum}, ${migrationName}, datetime('now'), 1)
-    `.execute(db);
-    }
-    else {
-        await sql `
-      INSERT INTO ${sql.raw(`\`${tableName}\``)} (id, checksum, migration_name, finished_at, applied_steps_count)
-      VALUES (${id}, ${checksum}, ${migrationName}, NOW(), 1)
-    `.execute(db);
-    }
-}
-/**
- * Calculate SHA256 checksum of migration SQL
- */
-export function calculateChecksum(sql) {
-    return crypto.createHash("sha256").update(sql).digest("hex");
-}
-/**
- * Validate that the database's applied migrations are coherent with the migration log.
- *
- * Coherence rules:
- * 1. Every migration applied in the DB must exist in the migration log
- * 2. Applied migrations must be a prefix of the log (no gaps)
- * 3. Checksums must match for applied migrations
- */
-function validateMigrationCoherence(appliedMigrations, migrationLog, migrationFolders) {
-    const errors = [];
-    // Build a set of log migration names for quick lookup
-    const logMigrationNames = new Set(migrationLog.map((e) => e.name));
-    const folderNames = new Set(migrationFolders);
-    for (const entry of migrationLog) {
-        if (!folderNames.has(entry.name)) {
-            errors.push({
-                type: "missing_from_disk",
-                migrationName: entry.name,
-                details: `Migration "${entry.name}" exists in migration log but not on disk`,
-            });
-        }
-    }
-    // Check 1: Every applied migration must exist in the log
-    for (const [migrationName, row] of appliedMigrations) {
-        if (!logMigrationNames.has(migrationName)) {
-            errors.push({
-                type: "missing_from_log",
-                migrationName,
-                details: `Migration "${migrationName}" exists in database but not in migration log`,
-            });
-        }
-    }
-    // If there are migrations missing from the log, return early
-    // (other checks don't make sense if the log is incomplete)
-    if (errors.length > 0) {
-        return { isCoherent: false, errors };
-    }
-    // Check 2: Applied migrations should be a continuous prefix of the log
-    // i.e., if migration N is applied, all migrations before N in the log must also be applied
-    let lastAppliedIndex = -1;
-    for (let i = 0; i < migrationLog.length; i++) {
-        const logEntry = migrationLog[i];
-        const isApplied = appliedMigrations.has(logEntry.name);
-        if (isApplied) {
-            // Check for gaps: if this is applied, all previous should be applied
-            if (lastAppliedIndex !== i - 1) {
-                // There's a gap - find the missing migrations
-                for (let j = lastAppliedIndex + 1; j < i; j++) {
-                    const missing = migrationLog[j];
-                    errors.push({
-                        type: "order_mismatch",
-                        migrationName: missing.name,
-                        details: `Migration "${missing.name}" is in the log but not applied, yet later migration "${logEntry.name}" is applied`,
-                    });
-                }
-            }
-            lastAppliedIndex = i;
-            // Check 3: Checksum validation for applied migrations
-            const dbRow = appliedMigrations.get(logEntry.name);
-            if (dbRow.checksum !== logEntry.checksum) {
-                errors.push({
-                    type: "checksum_mismatch",
-                    migrationName: logEntry.name,
-                    details: `Checksum mismatch for "${logEntry.name}": database has ${dbRow.checksum.slice(0, 8)}..., log has ${logEntry.checksum.slice(0, 8)}...`,
-                });
-            }
-        }
-    }
-    return {
-        isCoherent: errors.length === 0,
-        errors,
-    };
-}
-/**
- * Execute raw SQL using the database driver directly
- * This bypasses Kysely for DDL statements which don't work reliably with sql.raw()
- */
-async function executeRawSql(dialect, sqlContent, options) {
-    if (dialect === "sqlite") {
-        const { default: Database } = await import("better-sqlite3");
-        const sqliteDb = new Database(options.databasePath || ":memory:");
-        try {
-            // better-sqlite3's exec() handles multiple statements properly
-            sqliteDb.exec(sqlContent);
-        }
-        finally {
-            sqliteDb.close();
-        }
-    }
-    else if (dialect === "postgres") {
-        const { Pool } = await import("pg");
-        const pool = new Pool({ connectionString: options.connectionUrl });
-        const client = await pool.connect();
-        try {
-            // PostgreSQL supports transactional DDL, so wrap migration in a transaction
-            await client.query("BEGIN");
-            await client.query(sqlContent);
-            await client.query("COMMIT");
-        }
-        catch (error) {
-            await client.query("ROLLBACK");
-            throw error;
-        }
-        finally {
-            client.release();
-            await pool.end();
-        }
-    }
-    else if (dialect === "mysql") {
-        // Use mysql2 with promise wrapper
-        const mysql = await import("mysql2");
-        const pool = mysql.createPool({ uri: options.connectionUrl });
-        const promisePool = pool.promise();
-        try {
-            // MySQL needs statements executed one at a time
-            const statements = sqlContent
-                .split(/;(?:\s*\n|\s*$)/)
-                .map((s) => s.trim())
-                .filter((s) => s.length > 0 && !s.startsWith("--"));
-            for (const statement of statements) {
-                await promisePool.query(statement);
-            }
-        }
-        finally {
-            await pool.promise().end();
-        }
-    }
-}
-/**
- * Apply pending Prisma migrations
- */
-export async function applyPrismaMigrations(options) {
-    const migrationsTable = options.migrationsTable ?? "_prisma_migrations";
-    const migrationsSchema = options.migrationsSchema ?? "public";
-    const { db, destroy } = await createKyselyAdapter({
-        dialect: options.dialect,
-        connectionUrl: options.connectionUrl,
-        databasePath: options.databasePath,
-    });
-    try {
-        // Ensure migrations table exists
-        await ensureMigrationsTable(db, migrationsTable, migrationsSchema, options.dialect);
-        // Get already applied migrations
-        const appliedMigrations = await getAppliedMigrations(db, migrationsTable, migrationsSchema, options.dialect);
-        // Read migration folders
-        const entries = await fs.readdir(options.migrationsFolder, { withFileTypes: true });
-        const migrationFolders = entries
-            .filter((e) => e.isDirectory() && /^\d{14}_/.test(e.name))
-            .map((e) => e.name)
-            .sort();
-        const migrationFoldersWithSql = [];
-        for (const folderName of migrationFolders) {
-            const sqlPath = path.join(options.migrationsFolder, folderName, "migration.sql");
-            try {
-                await fs.access(sqlPath);
-                migrationFoldersWithSql.push(folderName);
-            }
-            catch {
-                // Missing migration.sql; coherence check will flag if it's in the log
-            }
-        }
-        // Read migration log and validate coherence
-        const migrationLog = await readMigrationLog(options.migrationsFolder);
-        const coherence = validateMigrationCoherence(appliedMigrations, migrationLog, migrationFoldersWithSql);
-        if (!coherence.isCoherent) {
-            return {
-                applied: [],
-                alreadyApplied: [],
-                coherenceErrors: coherence.errors,
-            };
-        }
-        const result = {
-            applied: [],
-            alreadyApplied: [],
-        };
-        for (const folderName of migrationFoldersWithSql) {
-            if (appliedMigrations.has(folderName)) {
-                result.alreadyApplied.push(folderName);
-                continue;
-            }
-            const sqlPath = path.join(options.migrationsFolder, folderName, "migration.sql");
-            let sqlContent;
-            try {
-                sqlContent = await fs.readFile(sqlPath, "utf-8");
-            }
-            catch {
-                continue; // Skip if no migration.sql
-            }
-            const checksum = calculateChecksum(sqlContent);
-            // Verify checksum against migration log (migrationLog already read above)
-            const logEntry = migrationLog.find((m) => m.name === folderName);
-            if (logEntry && logEntry.checksum !== checksum) {
-                result.failed = {
-                    migrationName: folderName,
-                    error: `Checksum mismatch for migration ${folderName}.\n` +
-                        `Expected: ${logEntry.checksum}\n` +
-                        `Found: ${checksum}\n` +
-                        `The migration file may have been modified after generation.`,
-                };
-                break;
-            }
-            const startTime = Date.now();
-            try {
-                // Execute the migration SQL using direct driver access
-                await executeRawSql(options.dialect, sqlContent, {
-                    connectionUrl: options.connectionUrl,
-                    databasePath: options.databasePath,
-                });
-                // Record the migration (still use Kysely for this since it's simple INSERT)
-                await recordMigration(db, migrationsTable, migrationsSchema, options.dialect, folderName, checksum);
-                result.applied.push({
-                    migrationName: folderName,
-                    duration: Date.now() - startTime,
-                });
-            }
-            catch (error) {
-                result.failed = {
-                    migrationName: folderName,
-                    error: error instanceof Error ? error.message : String(error),
-                };
-                break; // Stop on first failure
-            }
-        }
-        return result;
-    }
-    finally {
-        await destroy();
-    }
-}
-/**
- * Preview pending migrations without applying them
- */
-export async function previewPrismaMigrations(options) {
-    const migrationsTable = options.migrationsTable ?? "_prisma_migrations";
-    const migrationsSchema = options.migrationsSchema ?? "public";
-    const { db, destroy } = await createKyselyAdapter({
-        dialect: options.dialect,
-        connectionUrl: options.connectionUrl,
-        databasePath: options.databasePath,
-    });
-    try {
-        // Ensure migrations table exists
-        await ensureMigrationsTable(db, migrationsTable, migrationsSchema, options.dialect);
-        // Get already applied migrations
-        const appliedMigrations = await getAppliedMigrations(db, migrationsTable, migrationsSchema, options.dialect);
-        // Read migration folders
-        const entries = await fs.readdir(options.migrationsFolder, { withFileTypes: true });
-        const migrationFolders = entries
-            .filter((e) => e.isDirectory() && /^\d{14}_/.test(e.name))
-            .map((e) => e.name)
-            .sort();
-        const result = {
-            pending: [],
-            alreadyApplied: [],
-        };
-        for (const folderName of migrationFolders) {
-            if (appliedMigrations.has(folderName)) {
-                result.alreadyApplied.push(folderName);
-                continue;
-            }
-            const sqlPath = path.join(options.migrationsFolder, folderName, "migration.sql");
-            let sqlContent;
-            try {
-                sqlContent = await fs.readFile(sqlPath, "utf-8");
-            }
-            catch {
-                continue; // Skip if no migration.sql
-            }
-            result.pending.push({
-                name: folderName,
-                sql: sqlContent,
-            });
-        }
-        return result;
-    }
-    finally {
-        await destroy();
-    }
-}
-/**
- * Check if there are schema changes
- */
-export async function hasPrismaSchemaChanges(options) {
-    const currentSchema = await generateSchemaSnapshot(options.schemaPath);
-    const { snapshotPath } = getSnapshotPaths(options.outputPath);
-    const previousSnapshot = await readSnapshot(snapshotPath);
-    const diff = diffSchemas(previousSnapshot?.schema ?? null, currentSchema);
-    return (diff.addedModels.length > 0 ||
-        diff.removedModels.length > 0 ||
-        diff.addedFields.length > 0 ||
-        diff.removedFields.length > 0 ||
-        diff.alteredFields.length > 0 ||
-        diff.addedUniqueConstraints.length > 0 ||
-        diff.removedUniqueConstraints.length > 0 ||
-        diff.addedIndexes.length > 0 ||
-        diff.removedIndexes.length > 0 ||
-        diff.addedForeignKeys.length > 0 ||
-        diff.removedForeignKeys.length > 0 ||
-        diff.primaryKeyChanges.length > 0);
-}
-/**
- * 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;
-}
-const MIGRATION_LOG_HEADER = `# zenstack-kit migration log
-# Format: <migration_name> <checksum>
-`;
-/**
- * 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;
-}
-/**
- * Check if snapshot exists
- */
-export async function hasSnapshot(outputPath) {
-    const { snapshotPath } = getSnapshotPaths(outputPath);
-    try {
-        await fs.access(snapshotPath);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Initialize snapshot from schema without generating migration
- */
-export async function initializeSnapshot(options) {
-    const currentSchema = await generateSchemaSnapshot(options.schemaPath);
-    const { snapshotPath } = getSnapshotPaths(options.outputPath);
-    await writeSnapshot(snapshotPath, currentSchema);
-    return {
-        snapshotPath,
-        tableCount: currentSchema.tables.length,
-    };
-}
-/**
- * Export getSnapshotPaths for external use
- */
-export { getSnapshotPaths };
+export { createPrismaMigration, createInitialMigration, hasPrismaSchemaChanges, } from "./prisma/create.js";
+export { applyPrismaMigrations, previewPrismaMigrations, } from "./prisma/apply.js";
+export { readMigrationLog, writeMigrationLog, appendToMigrationLog, scanMigrationFolders, getMigrationLogPath, calculateChecksum, } from "./prisma/log.js";
+export { initializeSnapshot, hasSnapshot, getSnapshotPaths, writeSnapshot, } from "./prisma/snapshot.js";
+export { detectPotentialRenames, } from "./prisma/rename.js";