zenstack-kit 0.1.4 → 0.1.7

package/dist/migrations/prisma/apply.js

@@ -0,0 +1,384 @@
+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 { calculateChecksum, readMigrationLog } from "./log.js";
+/**
+ * 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);
+    }
+}
+/**
+ * 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] 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 {
+                if (!options.markApplied) {
+                    // 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();
+    }
+}

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

@@ -0,0 +1,63 @@
+import type { KyselyDialect } from "../../sql/kysely-adapter.js";
+export interface PrismaMigrationOptions {
+    /** Migration name */
+    name: string;
+    /** Path to ZenStack schema file */
+    schemaPath: string;
+    /** Output directory for migration files */
+    outputPath: string;
+    /** Database dialect for SQL generation */
+    dialect: KyselyDialect;
+    /** Table rename mappings */
+    renameTables?: Array<{
+        from: string;
+        to: string;
+    }>;
+    /** Column rename mappings */
+    renameColumns?: Array<{
+        table: string;
+        from: string;
+        to: string;
+    }>;
+}
+export interface PrismaMigration {
+    /** Migration folder name (timestamp_name) */
+    folderName: string;
+    /** Full path to migration folder */
+    folderPath: string;
+    /** SQL content */
+    sql: string;
+    /** Timestamp */
+    timestamp: number;
+}
+export interface CreateInitialMigrationOptions {
+    /** Migration name (default: "init") */
+    name?: string;
+    /** Path to ZenStack schema file */
+    schemaPath: string;
+    /** Output directory for migration files */
+    outputPath: string;
+    /** Database dialect for SQL generation */
+    dialect: KyselyDialect;
+}
+/**
+ * Generate timestamp string for migration folder name
+ */
+export declare function generateTimestamp(): string;
+/**
+ * Create a Prisma-compatible migration
+ */
+export declare function createPrismaMigration(options: PrismaMigrationOptions): Promise<PrismaMigration | null>;
+/**
+ * Create an initial migration that creates all tables from scratch.
+ * This is used when initializing a project where the database is empty.
+ */
+export declare function createInitialMigration(options: CreateInitialMigrationOptions): Promise<PrismaMigration>;
+/**
+ * Check if there are schema changes
+ */
+export declare function hasPrismaSchemaChanges(options: {
+    schemaPath: string;
+    outputPath: string;
+}): Promise<boolean>;
+//# sourceMappingURL=create.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"create.d.ts","sourceRoot":"","sources":["../../../src/migrations/prisma/create.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAMjE,MAAM,WAAW,sBAAsB;IACrC,qBAAqB;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,mCAAmC;IACnC,UAAU,EAAE,MAAM,CAAC;IACnB,2CAA2C;IAC3C,UAAU,EAAE,MAAM,CAAC;IACnB,0CAA0C;IAC1C,OAAO,EAAE,aAAa,CAAC;IACvB,4BAA4B;IAC5B,YAAY,CAAC,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACnD,6BAA6B;IAC7B,aAAa,CAAC,EAAE,KAAK,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACpE;AAED,MAAM,WAAW,eAAe;IAC9B,6CAA6C;IAC7C,UAAU,EAAE,MAAM,CAAC;IACnB,oCAAoC;IACpC,UAAU,EAAE,MAAM,CAAC;IACnB,kBAAkB;IAClB,GAAG,EAAE,MAAM,CAAC;IACZ,gBAAgB;IAChB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,6BAA6B;IAC5C,uCAAuC;IACvC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,mCAAmC;IACnC,UAAU,EAAE,MAAM,CAAC;IACnB,2CAA2C;IAC3C,UAAU,EAAE,MAAM,CAAC;IACnB,0CAA0C;IAC1C,OAAO,EAAE,aAAa,CAAC;CACxB;AAED;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,MAAM,CAU1C;AAED;;GAEG;AACH,wBAAsB,qBAAqB,CACzC,OAAO,EAAE,sBAAsB,GAC9B,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC,CAiDjC;AAED;;;GAGG;AACH,wBAAsB,sBAAsB,CAC1C,OAAO,EAAE,6BAA6B,GACrC,OAAO,CAAC,eAAe,CAAC,CAwC1B;AAED;;GAEG;AACH,wBAAsB,sBAAsB,CAAC,OAAO,EAAE;IACpD,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;CACpB,GAAG,OAAO,CAAC,OAAO,CAAC,CAqBnB"}

package/dist/migrations/prisma/create.js

@@ -0,0 +1,119 @@
+import * as fs from "fs/promises";
+import * as path from "path";
+import { generateSchemaSnapshot } from "../../schema/snapshot.js";
+import { applyRenameMappings, buildSqlStatements, diffSchemas } from "./diff.js";
+import { appendToMigrationLog, calculateChecksum } from "./log.js";
+import { getSnapshotPaths, readSnapshot, writeSnapshot } from "./snapshot.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("");
+}
+/**
+ * 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 } = 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,
+    };
+}
+/**
+ * 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);
+}

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

@@ -0,0 +1,104 @@
+import type { KyselyDialect } from "../../sql/kysely-adapter.js";
+import type { SchemaSnapshot, SchemaTable, SchemaColumn } from "../../schema/snapshot.js";
+export declare function diffSchemas(previous: SchemaSnapshot | null, current: SchemaSnapshot): {
+    addedModels: SchemaTable[];
+    removedModels: SchemaTable[];
+    addedFields: {
+        tableName: string;
+        column: SchemaColumn;
+    }[];
+    removedFields: {
+        tableName: string;
+        column: SchemaColumn;
+    }[];
+    alteredFields: {
+        tableName: string;
+        columnName: string;
+        previous: SchemaColumn;
+        current: SchemaColumn;
+    }[];
+    addedUniqueConstraints: {
+        tableName: string;
+        constraint: {
+            name: string;
+            columns: string[];
+        };
+    }[];
+    removedUniqueConstraints: {
+        tableName: string;
+        constraint: {
+            name: string;
+            columns: string[];
+        };
+    }[];
+    addedIndexes: {
+        tableName: string;
+        index: {
+            name: string;
+            columns: string[];
+        };
+    }[];
+    removedIndexes: {
+        tableName: string;
+        index: {
+            name: string;
+            columns: string[];
+        };
+    }[];
+    addedForeignKeys: {
+        tableName: string;
+        foreignKey: {
+            name: string;
+            columns: string[];
+            referencedTable: string;
+            referencedColumns: string[];
+        };
+    }[];
+    removedForeignKeys: {
+        tableName: string;
+        foreignKey: {
+            name: string;
+            columns: string[];
+            referencedTable: string;
+            referencedColumns: string[];
+        };
+    }[];
+    primaryKeyChanges: {
+        tableName: string;
+        previous?: {
+            name: string;
+            columns: string[];
+        };
+        current?: {
+            name: string;
+            columns: string[];
+        };
+    }[];
+    renamedTables: Array<{
+        from: string;
+        to: string;
+    }>;
+    renamedColumns: Array<{
+        tableName: string;
+        from: string;
+        to: string;
+    }>;
+};
+type PrismaDiff = ReturnType<typeof diffSchemas>;
+export declare function applyRenameMappings(diff: PrismaDiff, renameTables?: Array<{
+    from: string;
+    to: string;
+}>, renameColumns?: Array<{
+    table: string;
+    from: string;
+    to: string;
+}>): PrismaDiff;
+/**
+ * Build SQL statements from diff
+ */
+export declare function buildSqlStatements(diff: ReturnType<typeof diffSchemas>, dialect: KyselyDialect): {
+    up: string[];
+    down: string[];
+};
+export {};
+//# sourceMappingURL=diff.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"diff.d.ts","sourceRoot":"","sources":["../../../src/migrations/prisma/diff.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AACjE,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAyK1F,wBAAgB,WAAW,CAAC,QAAQ,EAAE,cAAc,GAAG,IAAI,EAAE,OAAO,EAAE,cAAc;;;;mBAsB5C,MAAM;gBAAU,YAAY;;;mBAC1B,MAAM;gBAAU,YAAY;;;mBAEvD,MAAM;oBACL,MAAM;kBACR,YAAY;iBACb,YAAY;;;mBAGV,MAAM;oBACL;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,OAAO,EAAE,MAAM,EAAE,CAAA;SAAE;;;mBAGpC,MAAM;oBACL;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,OAAO,EAAE,MAAM,EAAE,CAAA;SAAE;;;mBAGpC,MAAM;eACV;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,OAAO,EAAE,MAAM,EAAE,CAAA;SAAE;;;mBAG/B,MAAM;eACV;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,OAAO,EAAE,MAAM,EAAE,CAAA;SAAE;;;mBAG/B,MAAM;oBACL;YACV,IAAI,EAAE,MAAM,CAAC;YACb,OAAO,EAAE,MAAM,EAAE,CAAC;YAClB,eAAe,EAAE,MAAM,CAAC;YACxB,iBAAiB,EAAE,MAAM,EAAE,CAAC;SAC7B;;;mBAGU,MAAM;oBACL;YACV,IAAI,EAAE,MAAM,CAAC;YACb,OAAO,EAAE,MAAM,EAAE,CAAC;YAClB,eAAe,EAAE,MAAM,CAAC;YACxB,iBAAiB,EAAE,MAAM,EAAE,CAAC;SAC7B;;;mBAGU,MAAM;mBACN;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,OAAO,EAAE,MAAM,EAAE,CAAA;SAAE;kBACpC;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,OAAO,EAAE,MAAM,EAAE,CAAA;SAAE;;mBAiCxB,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC;oBAClC,KAAK,CAAC;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC;EAE/E;AAED,KAAK,UAAU,GAAG,UAAU,CAAC,OAAO,WAAW,CAAC,CAAC;AAkGjD,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,UAAU,EAChB,YAAY,GAAE,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,CAAM,EACtD,aAAa,GAAE,KAAK,CAAC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,CAAM,GACrE,UAAU,CA8FZ;AA2CD;;GAEG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,UAAU,CAAC,OAAO,WAAW,CAAC,EACpC,OAAO,EAAE,aAAa,GACrB;IAAE,EAAE,EAAE,MAAM,EAAE,CAAC;IAAC,IAAI,EAAE,MAAM,EAAE,CAAA;CAAE,CAkNlC"}