@fragno-dev/db 0.2.2 → 0.4.1

package/src/adapters/generic-sql/migration/dialect/sqlite.ts

@@ -1,24 +1,21 @@
+import { createHash } from "node:crypto";
+
 import { type ColumnDefinitionBuilder, type CompiledQuery, type RawBuilder, sql } from "kysely";
+
 import type {
   ColumnInfo,
   ColumnOperation,
-  ForeignKeyInfo,
   MigrationOperation,
+  SqliteAlterTableMetadata,
+  SqliteCopyColumn,
+  SqliteCreateTableMetadata,
 } from "../../../../migration-engine/shared";
-import type { TableNameMapper } from "../../../shared/table-name-mapper";
+import type { NamingResolver } from "../../../../naming/sql-naming";
 import { SQLGenerator } from "../sql-generator";
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 type CreateTableBuilderAny = any;
 
-/**
- * Metadata attached to create-table operations for inline foreign keys.
- */
-interface SqliteCreateTableMetadata {
-  [key: string]: unknown;
-  inlineForeignKeys?: ForeignKeyInfo[];
-}
-
 const errors = {
   IdColumnUpdate:
     "ID columns cannot be updated. Not every database supports updating primary keys and often requires workarounds.",
@@ -27,6 +24,147 @@ const errors = {
     "SQLite doesn't support modifying foreign keys directly. Use `recreate-table` instead.",
 } as const;
 
+type RenameOrDropColumnOperation = Extract<
+  ColumnOperation,
+  { type: "rename-column" } | { type: "drop-column" }
+>;
+
+type CopyColumnMapping = { from: string; to: string };
+type SqliteRecreateTable = NonNullable<SqliteAlterTableMetadata["recreateTable"]>;
+type SqliteRecreateIndex = SqliteRecreateTable["indexes"][number];
+type SqliteRecreateForeignKey = SqliteRecreateTable["foreignKeys"][number];
+
+function normalizeCopyColumns(copyColumns: SqliteCopyColumn[]): CopyColumnMapping[] {
+  return copyColumns.map((column) =>
+    typeof column === "string"
+      ? { from: column, to: column }
+      : { from: column.from, to: column.to },
+  );
+}
+
+function applyRenameDropToColumns(
+  columns: ColumnInfo[],
+  operations: RenameOrDropColumnOperation[],
+): ColumnInfo[] {
+  let next = columns.map((column) => ({ ...column }));
+
+  for (const op of operations) {
+    if (op.type === "rename-column") {
+      const column = next.find((col) => col.name === op.from);
+      if (column) {
+        column.name = op.to;
+      }
+    } else if (op.type === "drop-column") {
+      next = next.filter((column) => column.name !== op.name);
+    }
+  }
+
+  return next;
+}
+
+function applyRenameDropToCopyColumns(
+  copyColumns: CopyColumnMapping[],
+  operations: RenameOrDropColumnOperation[],
+): CopyColumnMapping[] {
+  let next = copyColumns.map((column) => ({ ...column }));
+
+  for (const op of operations) {
+    if (op.type === "rename-column") {
+      for (const mapping of next) {
+        if (mapping.to === op.from) {
+          mapping.to = op.to;
+        }
+      }
+    } else if (op.type === "drop-column") {
+      next = next.filter((mapping) => mapping.to !== op.name);
+    }
+  }
+
+  return next;
+}
+
+function applyRenameDropToIndexes(
+  indexes: SqliteRecreateIndex[],
+  operations: RenameOrDropColumnOperation[],
+): SqliteRecreateIndex[] {
+  const next: SqliteRecreateIndex[] = [];
+
+  for (const index of indexes) {
+    let columns = [...index.columns];
+    let dropped = false;
+
+    for (const op of operations) {
+      if (op.type === "rename-column") {
+        columns = columns.map((column) => (column === op.from ? op.to : column));
+      } else if (columns.includes(op.name)) {
+        dropped = true;
+        break;
+      }
+    }
+
+    if (!dropped) {
+      next.push({ ...index, columns });
+    }
+  }
+
+  return next;
+}
+
+function applyRenameDropToForeignKeys(
+  foreignKeys: SqliteRecreateForeignKey[],
+  operations: RenameOrDropColumnOperation[],
+): SqliteRecreateForeignKey[] {
+  const next: SqliteRecreateForeignKey[] = [];
+
+  for (const foreignKey of foreignKeys) {
+    let columns = [...foreignKey.columns];
+    let dropped = false;
+
+    for (const op of operations) {
+      if (op.type === "rename-column") {
+        columns = columns.map((column) => (column === op.from ? op.to : column));
+      } else if (columns.includes(op.name)) {
+        dropped = true;
+        break;
+      }
+    }
+
+    if (!dropped) {
+      next.push({
+        ...foreignKey,
+        columns,
+      });
+    }
+  }
+
+  return next;
+}
+
+function mergeRenameDropIntoRecreate(
+  recreate: SqliteRecreateTable,
+  operations: ColumnOperation[],
+): SqliteRecreateTable {
+  const renameDropOps = operations.filter(
+    (op): op is RenameOrDropColumnOperation =>
+      op.type === "rename-column" || op.type === "drop-column",
+  );
+
+  if (renameDropOps.length === 0) {
+    return recreate;
+  }
+
+  return {
+    ...recreate,
+    columns: applyRenameDropToColumns(recreate.columns, renameDropOps),
+    copyColumns: applyRenameDropToCopyColumns(
+      normalizeCopyColumns(recreate.copyColumns),
+      renameDropOps,
+    ),
+    indexes: applyRenameDropToIndexes(recreate.indexes, renameDropOps),
+    foreignKeys: applyRenameDropToForeignKeys(recreate.foreignKeys, renameDropOps),
+  };
+}
+
 /**
  * SQLite-specific SQL generator.
  * Handles SQLite's limitations around foreign keys and column updates.
@@ -45,6 +183,7 @@ export class SQLiteSQLGenerator extends SQLGenerator {
 
     const result: MigrationOperation[] = [];
     const createTableIndices = new Map<string, number>();
+    const alterTableIndices = new Map<string, number[]>();
     const foreignKeysByTable = new Map<
       string,
       Extract<MigrationOperation, { type: "add-foreign-key" }>[]
@@ -55,6 +194,15 @@ export class SQLiteSQLGenerator extends SQLGenerator {
       if (op.type === "create-table") {
         createTableIndices.set(op.name, result.length);
         result.push(op);
+      } else if (op.type === "alter-table") {
+        const index = result.length;
+        result.push(op);
+        const existing = alterTableIndices.get(op.name);
+        if (existing) {
+          existing.push(index);
+        } else {
+          alterTableIndices.set(op.name, [index]);
+        }
       } else if (op.type === "add-foreign-key") {
         if (!foreignKeysByTable.has(op.table)) {
           foreignKeysByTable.set(op.table, []);
@@ -65,20 +213,81 @@ export class SQLiteSQLGenerator extends SQLGenerator {
       }
     }
 
+    const extractCreateColumn = (tableName: string, columnName: string): ColumnInfo | undefined => {
+      const indices = alterTableIndices.get(tableName);
+      if (!indices) {
+        return undefined;
+      }
+
+      for (const index of indices) {
+        const operation = result[index];
+        if (!operation || operation.type !== "alter-table") {
+          continue;
+        }
+
+        let extracted: ColumnInfo | undefined;
+        const nextValue = operation.value.filter((columnOp) => {
+          if (columnOp.type === "create-column" && columnOp.value.name === columnName) {
+            extracted = columnOp.value;
+            return false;
+          }
+          return true;
+        });
+
+        if (extracted) {
+          result[index] = { ...operation, value: nextValue };
+          return extracted;
+        }
+      }
+
+      return undefined;
+    };
+
     // Second pass: attach foreign keys as metadata to create-table ops
     for (const [tableName, fkOps] of foreignKeysByTable.entries()) {
       const createTableIdx = createTableIndices.get(tableName);
 
       if (createTableIdx !== undefined) {
-        const createOp = result[createTableIdx];
+        let createOp = result[createTableIdx];
         if (createOp.type === "create-table") {
+          const columnNames = new Set(createOp.columns.map((column) => column.name));
+          const missingColumns = new Set<string>();
+
+          for (const fkOp of fkOps) {
+            for (const columnName of fkOp.value.columns) {
+              if (!columnNames.has(columnName)) {
+                missingColumns.add(columnName);
+              }
+            }
+          }
+
+          if (missingColumns.size > 0) {
+            for (const columnName of Array.from(missingColumns)) {
+              const column = extractCreateColumn(tableName, columnName);
+              if (column) {
+                createOp = { ...createOp, columns: [...createOp.columns, column] };
+                result[createTableIdx] = createOp;
+                columnNames.add(columnName);
+                missingColumns.delete(columnName);
+              }
+            }
+          }
+
+          if (missingColumns.size > 0) {
+            throw new Error(
+              `SQLite FK preprocessing failed for "${tableName}": missing column(s) ${Array.from(
+                missingColumns,
+              ).join(", ")} required by foreign keys.`,
+            );
+          }
+
+          const existingInline = (createOp.metadata as SqliteCreateTableMetadata | undefined)
+            ?.inlineForeignKeys;
           const metadata: SqliteCreateTableMetadata = {
-            inlineForeignKeys: fkOps.map((fkOp) => fkOp.value),
-          };
-          result[createTableIdx] = {
-            ...createOp,
-            metadata,
+            ...createOp.metadata,
+            inlineForeignKeys: [...(existingInline ?? []), ...fkOps.map((fkOp) => fkOp.value)],
           };
+          result[createTableIdx] = { ...createOp, metadata };
         }
       } else {
         // Table already exists - keep add-foreign-key operations (will throw error during compile)
@@ -87,7 +296,13 @@ export class SQLiteSQLGenerator extends SQLGenerator {
     }
 
     // Add pragma at the beginning for deferred foreign key checking
-    return [{ type: "custom", sql: "PRAGMA defer_foreign_keys = ON" }, ...result];
+    const pruned = result.filter((op) => {
+      if (op.type !== "alter-table") {
+        return true;
+      }
+      return op.value.length > 0;
+    });
+    return [{ type: "custom", sql: "PRAGMA defer_foreign_keys = ON" }, ...pruned];
   }
 
   override applyAutoIncrement(builder: ColumnDefinitionBuilder): ColumnDefinitionBuilder {
@@ -105,6 +320,10 @@ export class SQLiteSQLGenerator extends SQLGenerator {
     }
 
     if ("dbSpecial" in value && value.dbSpecial === "now") {
+      const dbType = this.typeMapper.getDatabaseType(column);
+      if (dbType === "integer" && (column.type === "timestamp" || column.type === "date")) {
+        return sql`(cast((julianday('now') - 2440587.5)*86400000 as integer))`;
+      }
       return sql`CURRENT_TIMESTAMP`;
     }
 
@@ -121,36 +340,17 @@ export class SQLiteSQLGenerator extends SQLGenerator {
    */
   protected override compileCreateTable(
     operation: Extract<MigrationOperation, { type: "create-table" }>,
-    mapper?: TableNameMapper,
+    resolver?: NamingResolver,
   ): CompiledQuery {
-    const tableName = this.getTableName(operation.name, mapper);
-    let builder: CreateTableBuilderAny = this.db.schema.createTable(tableName);
-
-    // Add columns
-    for (const col of operation.columns) {
-      builder = builder.addColumn(
-        col.name,
-        sql.raw(this.getDBType(col)),
-        (b: ColumnDefinitionBuilder) => this.buildColumn(col, b),
-      );
-    }
-
-    // Add inline foreign keys from metadata
+    const tableName = this.getTableName(operation.name, resolver);
     const metadata = operation.metadata as SqliteCreateTableMetadata | undefined;
-    if (metadata?.inlineForeignKeys) {
-      for (const fk of metadata.inlineForeignKeys) {
-        builder = builder.addForeignKeyConstraint(
-          fk.name,
-          fk.columns,
-          this.getTableName(fk.referencedTable, mapper),
-          fk.referencedColumns,
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any
-          (cb: any) => cb.onUpdate("restrict").onDelete("restrict"),
-        );
-      }
-    }
-
-    return builder.compile();
+    return this.compileCreateTableForName(
+      tableName,
+      operation.name,
+      operation.columns,
+      metadata,
+      resolver,
+    );
   }
 
   /**
@@ -158,7 +358,7 @@ export class SQLiteSQLGenerator extends SQLGenerator {
    */
   protected override compileAddForeignKey(
     _operation: Extract<MigrationOperation, { type: "add-foreign-key" }>,
-    _mapper?: TableNameMapper,
+    _resolver?: NamingResolver,
   ): CompiledQuery {
     throw new Error(errors.SQLiteUpdateForeignKeys);
   }
@@ -168,22 +368,165 @@ export class SQLiteSQLGenerator extends SQLGenerator {
    */
   protected override compileDropForeignKey(
     _operation: Extract<MigrationOperation, { type: "drop-foreign-key" }>,
-    _mapper?: TableNameMapper,
+    _resolver?: NamingResolver,
   ): CompiledQuery {
     throw new Error(errors.SQLiteUpdateForeignKeys);
   }
 
   /**
-   * SQLite doesn't support updating columns.
+   * SQLite doesn't support updating columns directly. Use table recreation when metadata is provided.
    */
+  protected override compileAlterTable(
+    operation: Extract<MigrationOperation, { type: "alter-table" }>,
+    resolver?: NamingResolver,
+  ): CompiledQuery[] {
+    const hasUpdateColumn = operation.value.some((columnOp) => columnOp.type === "update-column");
+
+    if (!hasUpdateColumn) {
+      return super.compileAlterTable(operation, resolver);
+    }
+
+    for (const columnOp of operation.value) {
+      if (columnOp.type !== "update-column") {
+        continue;
+      }
+      const col = columnOp.value;
+      if (col.role === "external-id" || col.role === "internal-id") {
+        throw new Error(errors.IdColumnUpdate);
+      }
+    }
+
+    const metadata = operation.metadata as SqliteAlterTableMetadata | undefined;
+    const recreate = metadata?.recreateTable;
+    if (!recreate) {
+      throw new Error(errors.SQLiteUpdateColumn);
+    }
+
+    const mergedRecreate = mergeRenameDropIntoRecreate(recreate, operation.value);
+    return this.compileRecreateTable(operation.name, mergedRecreate, resolver);
+  }
+
   protected override compileUpdateColumn(
     _tableName: string,
-    operation: Extract<ColumnOperation, { type: "update-column" }>,
+    _logicalTableName: string,
+    _operation: Extract<ColumnOperation, { type: "update-column" }>,
+    _resolver?: NamingResolver,
   ): CompiledQuery | CompiledQuery[] {
-    const col = operation.value;
-    if (col.role === "external-id" || col.role === "internal-id") {
-      throw new Error(errors.IdColumnUpdate);
-    }
     throw new Error(errors.SQLiteUpdateColumn);
   }
+
+  private compileRecreateTable(
+    logicalTableName: string,
+    recreate: NonNullable<SqliteAlterTableMetadata["recreateTable"]>,
+    resolver?: NamingResolver,
+  ): CompiledQuery[] {
+    const queries: CompiledQuery[] = [];
+    const tableName = this.getTableName(logicalTableName, resolver);
+    const tempTableName = `${tableName}__fragno_tmp_${createHash("md5")
+      .update(tableName)
+      .digest("hex")
+      .slice(0, 6)}`;
+
+    queries.push(this.compileRaw(sql.raw("PRAGMA foreign_keys = OFF")));
+
+    queries.push(
+      this.compileCreateTableForName(
+        tempTableName,
+        logicalTableName,
+        recreate.columns,
+        {
+          inlineForeignKeys: recreate.foreignKeys,
+        },
+        resolver,
+      ),
+    );
+
+    const copyColumns = normalizeCopyColumns(recreate.copyColumns);
+    if (copyColumns.length > 0) {
+      const targetRefs = copyColumns.map((column) =>
+        sql.ref(this.getColumnName(column.to, logicalTableName, resolver)),
+      );
+      const sourceRefs = copyColumns.map((column) =>
+        sql.ref(this.getColumnName(column.from, logicalTableName, resolver)),
+      );
+      const targetList = sql.join(targetRefs);
+      const sourceList = sql.join(sourceRefs);
+      queries.push(
+        sql`insert into ${sql.ref(tempTableName)} (${targetList}) select ${sourceList} from ${sql.ref(
+          tableName,
+        )}`.compile(this.db),
+      );
+    }
+
+    queries.push(this.getSchemaBuilder(resolver).dropTable(tableName).compile());
+    queries.push(
+      this.getSchemaBuilder(resolver).alterTable(tempTableName).renameTo(tableName).compile(),
+    );
+
+    for (const index of recreate.indexes) {
+      const compiled = this.compileAddIndex(
+        {
+          type: "add-index",
+          table: logicalTableName,
+          name: index.name,
+          columns: index.columns,
+          unique: index.unique,
+        },
+        resolver,
+      );
+      if (Array.isArray(compiled)) {
+        queries.push(...compiled);
+      } else {
+        queries.push(compiled);
+      }
+    }
+
+    queries.push(this.compileRaw(sql.raw("PRAGMA foreign_keys = ON")));
+
+    return queries;
+  }
+
+  private compileCreateTableForName(
+    physicalTableName: string,
+    logicalTableName: string,
+    columns: ColumnInfo[],
+    metadata: SqliteCreateTableMetadata | undefined,
+    resolver?: NamingResolver,
+  ): CompiledQuery {
+    let builder: CreateTableBuilderAny =
+      this.getSchemaBuilder(resolver).createTable(physicalTableName);
+
+    for (const col of columns) {
+      const columnName = this.getColumnName(col.name, logicalTableName, resolver);
+      builder = builder.addColumn(
+        columnName,
+        sql.raw(this.getDBType(col)),
+        (b: ColumnDefinitionBuilder) => this.buildColumn(col, b),
+      );
+    }
+
+    if (metadata?.inlineForeignKeys) {
+      for (const fk of metadata.inlineForeignKeys) {
+        builder = builder.addForeignKeyConstraint(
+          this.getForeignKeyName(fk.name, logicalTableName, fk.referencedTable, resolver),
+          fk.columns.map((columnName) =>
+            this.getColumnName(columnName, logicalTableName, resolver),
+          ),
+          this.getTableName(fk.referencedTable, resolver),
+          fk.referencedColumns.map((columnName) =>
+            this.getColumnName(columnName, fk.referencedTable, resolver),
+          ),
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          (cb: any) => cb.onUpdate("restrict").onDelete("restrict"),
+        );
+      }
+    }
+
+    const compiled = builder.compile();
+    const sqlText = compiled.sql.replace(/\bconstraint\s+"[^"]+"\s+foreign key\b/gi, "foreign key");
+    return {
+      ...compiled,
+      sql: sqlText,
+    };
+  }
 }

package/src/adapters/generic-sql/migration/executor.test.ts

@@ -0,0 +1,52 @@
+import { describe, expect, it } from "vitest";
+
+import type { CompiledQuery } from "kysely";
+
+import type { SqlDriverAdapter } from "../../../sql-driver/sql-driver-adapter";
+import { executeMigration } from "./executor";
+
+function query(sql: string): CompiledQuery {
+  return { sql, parameters: [] } as unknown as CompiledQuery;
+}
+
+describe("executeMigration", () => {
+  it("runs foreign_keys pragmas outside the transaction", async () => {
+    const calls: string[] = [];
+
+    const driver = {
+      executeQuery: async (statement: CompiledQuery) => {
+        calls.push(`exec:${statement.sql}`);
+        return { rows: [] };
+      },
+      transaction: async (callback: (trx: SqlDriverAdapter) => Promise<void>) => {
+        calls.push("tx:begin");
+        const tx = {
+          executeQuery: async (statement: CompiledQuery) => {
+            calls.push(`tx:${statement.sql}`);
+            return { rows: [] };
+          },
+        } as unknown as SqlDriverAdapter;
+        await callback(tx);
+        calls.push("tx:commit");
+      },
+    } as unknown as SqlDriverAdapter;
+
+    await executeMigration(driver, {
+      statements: [
+        query("PRAGMA foreign_keys = OFF"),
+        query("alter table users rename to users_tmp"),
+        query("PRAGMA foreign_keys = ON"),
+      ],
+      fromVersion: 0,
+      toVersion: 1,
+    });
+
+    expect(calls).toEqual([
+      "exec:PRAGMA foreign_keys = OFF",
+      "tx:begin",
+      "tx:alter table users rename to users_tmp",
+      "tx:commit",
+      "exec:PRAGMA foreign_keys = ON",
+    ]);
+  });
+});

package/src/adapters/generic-sql/migration/executor.ts

@@ -1,4 +1,5 @@
 import type { CompiledQuery } from "kysely";
+
 import type { SqlDriverAdapter } from "../../../sql-driver/sql-driver-adapter";
 
 /**
@@ -25,9 +26,51 @@ export async function executeMigration(
     return;
   }
 
-  await driver.transaction(async (tx) => {
-    for (const statement of migration.statements) {
-      await tx.executeQuery(statement);
+  const isForeignKeysOff = (statement: CompiledQuery) =>
+    /^\s*pragma\s+foreign_keys\s*=\s*off\s*;?\s*$/i.test(statement.sql.trim());
+  const isForeignKeysOn = (statement: CompiledQuery) =>
+    /^\s*pragma\s+foreign_keys\s*=\s*on\s*;?\s*$/i.test(statement.sql.trim());
+
+  const preStatements: CompiledQuery[] = [];
+  const postStatements: CompiledQuery[] = [];
+  const transactionalStatements: CompiledQuery[] = [];
+
+  for (const statement of migration.statements) {
+    if (isForeignKeysOff(statement)) {
+      preStatements.push(statement);
+      continue;
+    }
+    if (isForeignKeysOn(statement)) {
+      postStatements.push(statement);
+      continue;
+    }
+    transactionalStatements.push(statement);
+  }
+
+  if (preStatements.length === 0 && postStatements.length === 0) {
+    await driver.transaction(async (tx) => {
+      for (const statement of migration.statements) {
+        await tx.executeQuery(statement);
+      }
+    });
+    return;
+  }
+
+  for (const statement of preStatements) {
+    await driver.executeQuery(statement);
+  }
+
+  try {
+    if (transactionalStatements.length > 0) {
+      await driver.transaction(async (tx) => {
+        for (const statement of transactionalStatements) {
+          await tx.executeQuery(statement);
+        }
+      });
+    }
+  } finally {
+    for (const statement of postStatements) {
+      await driver.executeQuery(statement);
     }
-  });
+  }
 }