zenstack-kit 0.1.1 → 0.1.2

package/dist/prisma-migrations.js

@@ -1,789 +0,0 @@
-/**
- * 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 "./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 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;
-        // Field changes
-        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,
-                });
-            }
-        }
-        // Unique constraint changes
-        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 });
-            }
-        }
-        // Index changes
-        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 });
-            }
-        }
-        // Foreign key changes
-        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 });
-            }
-        }
-        // Primary key changes
-        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 {
-        addedModels,
-        removedModels,
-        addedFields,
-        removedFields,
-        alteredFields,
-        addedUniqueConstraints,
-        removedUniqueConstraints,
-        addedIndexes,
-        removedIndexes,
-        addedForeignKeys,
-        removedForeignKeys,
-        primaryKeyChanges,
-        renamedTables: [],
-        renamedColumns: [],
-    };
-}
-/**
- * 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
-    for (const model of diff.addedModels) {
-        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);
-    let diff = diffSchemas(previousSnapshot?.schema ?? null, currentSchema);
-    // Apply rename mappings
-    if (options.renameTables?.length || options.renameColumns?.length) {
-        // Handle table renames
-        for (const mapping of options.renameTables ?? []) {
-            const removedIdx = diff.removedModels.findIndex((m) => m.name === mapping.from);
-            const addedIdx = diff.addedModels.findIndex((m) => m.name === mapping.to);
-            if (removedIdx !== -1 && addedIdx !== -1) {
-                diff.removedModels.splice(removedIdx, 1);
-                diff.addedModels.splice(addedIdx, 1);
-                diff.renamedTables.push(mapping);
-            }
-        }
-        // Handle column renames
-        for (const mapping of options.renameColumns ?? []) {
-            const removedIdx = diff.removedFields.findIndex((f) => f.tableName === mapping.table && f.column.name === mapping.from);
-            const addedIdx = diff.addedFields.findIndex((f) => f.tableName === mapping.table && f.column.name === mapping.to);
-            if (removedIdx !== -1 && addedIdx !== -1) {
-                diff.removedFields.splice(removedIdx, 1);
-                diff.addedFields.splice(addedIdx, 1);
-                diff.renamedColumns.push({ tableName: mapping.table, from: mapping.from, to: mapping.to });
-            }
-        }
-    }
-    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");
-}
-/**
- * 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 });
-        try {
-            await pool.query(sqlContent);
-        }
-        finally {
-            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 result = {
-            applied: [],
-            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
-            }
-            const checksum = calculateChecksum(sqlContent);
-            // Verify checksum against migration log
-            const migrationLog = await readMigrationLog(options.migrationsFolder);
-            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();
-    }
-}
-/**
- * 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);
-}
-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 };