@fragno-dev/db 0.1.2 → 0.1.5

package/src/adapters/kysely/migration/execute-sqlite.ts

@@ -0,0 +1,247 @@
+import { sql } from "kysely";
+import type {
+  ColumnOperation,
+  MigrationOperation,
+  SqliteCreateTableMetadata,
+} from "../../../migration-engine/shared";
+import type { TableNameMapper } from "../kysely-shared";
+import {
+  BaseMigrationExecutor,
+  createUniqueIndex,
+  dropUniqueIndex,
+  type ExecuteNode,
+} from "./execute-base";
+
+const errors = {
+  IdColumnUpdate:
+    "ID columns cannot be updated. Not every database supports updating primary keys and often requires workarounds.",
+  SQLiteUpdateColumn: "SQLite doesn't support updating columns. Recreate the table instead.",
+  SQLiteUpdateForeignKeys:
+    "SQLite doesn't support modifying foreign keys directly. Use `recreate-table` instead.",
+} as const;
+
+/**
+ * SQLite-specific migration executor.
+ * Handles SQLite's limitations around foreign keys and column updates.
+ */
+export class SqliteMigrationExecutor extends BaseMigrationExecutor<SqliteCreateTableMetadata> {
+  /**
+   * SQLite preprocessing: merge add-foreign-key operations into create-table operations
+   * when both exist in the same batch.
+   *
+   * SQLite requires foreign keys to be defined at table creation time. This preprocessing
+   * step identifies create-table + add-foreign-key pairs and merges them.
+   */
+  preprocessOperations(
+    operations: MigrationOperation[],
+  ): MigrationOperation<SqliteCreateTableMetadata>[] {
+    const result: MigrationOperation<SqliteCreateTableMetadata>[] = [];
+    const createTableIndices = new Map<string, number>(); // table name -> index in result
+    const foreignKeysByTable = new Map<string, (typeof operations)[number][]>();
+
+    // First pass: identify create-table operations and collect foreign keys
+    for (const op of operations) {
+      if (op.type === "create-table") {
+        createTableIndices.set(op.name, result.length);
+        result.push(op);
+      } else if (op.type === "add-foreign-key") {
+        if (!foreignKeysByTable.has(op.table)) {
+          foreignKeysByTable.set(op.table, []);
+        }
+        foreignKeysByTable.get(op.table)!.push(op);
+      } else {
+        result.push(op);
+      }
+    }
+
+    // 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) {
+        // Table is being created in this batch - attach FKs as metadata
+        const createOp = result[createTableIdx];
+        if (createOp.type === "create-table") {
+          result[createTableIdx] = {
+            ...createOp,
+            metadata: {
+              ...createOp.metadata,
+              inlineForeignKeys: fkOps.map((fkOp) => {
+                if (fkOp.type === "add-foreign-key") {
+                  return fkOp.value;
+                }
+                throw new Error("Unexpected operation type");
+              }),
+            },
+          };
+        }
+      } else {
+        // Table already exists - keep add-foreign-key operations (will throw error during execution)
+        result.push(...fkOps);
+      }
+    }
+
+    return result;
+  }
+
+  executeOperation(
+    operation: MigrationOperation<SqliteCreateTableMetadata>,
+    mapper?: TableNameMapper,
+  ): ExecuteNode | ExecuteNode[] {
+    switch (operation.type) {
+      case "create-table":
+        return this.createTable(operation, mapper);
+      case "rename-table":
+        return this.renameTable(operation, mapper);
+      case "alter-table":
+        return this.alterTable(operation, mapper);
+      case "drop-table":
+        return this.dropTable(operation, mapper);
+      case "add-foreign-key":
+        throw new Error(errors.SQLiteUpdateForeignKeys);
+      case "drop-foreign-key":
+        throw new Error(errors.SQLiteUpdateForeignKeys);
+      case "add-index":
+        return this.addIndex(operation, mapper);
+      case "drop-index":
+        return this.dropIndex(operation, mapper);
+      case "custom":
+        return this.handleCustomOperation(operation);
+    }
+  }
+
+  private createTable(
+    operation: Extract<MigrationOperation<SqliteCreateTableMetadata>, { type: "create-table" }>,
+    mapper?: TableNameMapper,
+  ): ExecuteNode {
+    const tableName = this.getTableName(operation.name, mapper);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let builder: any = this.db.schema.createTable(tableName);
+
+    // Add columns
+    for (const columnInfo of operation.columns) {
+      builder = builder.addColumn(
+        columnInfo.name,
+        sql.raw(this.getDBType(columnInfo)),
+        this.getColumnBuilderCallback(columnInfo),
+      );
+    }
+
+    // Add inline foreign keys from metadata (SQLite-specific)
+    const inlineForeignKeys = operation.metadata?.inlineForeignKeys;
+    if (inlineForeignKeys) {
+      for (const fk of 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;
+  }
+
+  private renameTable(
+    operation: Extract<MigrationOperation, { type: "rename-table" }>,
+    mapper?: TableNameMapper,
+  ): ExecuteNode {
+    return this.db.schema
+      .alterTable(this.getTableName(operation.from, mapper))
+      .renameTo(this.getTableName(operation.to, mapper));
+  }
+
+  private alterTable(
+    operation: Extract<MigrationOperation, { type: "alter-table" }>,
+    mapper?: TableNameMapper,
+  ): ExecuteNode[] {
+    const results: ExecuteNode[] = [];
+    const tableName = this.getTableName(operation.name, mapper);
+
+    for (const columnOp of operation.value) {
+      results.push(...this.executeColumnOperation(tableName, columnOp));
+    }
+
+    return results;
+  }
+
+  private executeColumnOperation(tableName: string, operation: ColumnOperation): ExecuteNode[] {
+    const next = () => this.db.schema.alterTable(tableName);
+    const results: ExecuteNode[] = [];
+
+    switch (operation.type) {
+      case "rename-column":
+        results.push(next().renameColumn(operation.from, operation.to));
+        return results;
+
+      case "drop-column":
+        results.push(next().dropColumn(operation.name));
+        return results;
+
+      case "create-column": {
+        const col = operation.value;
+        results.push(
+          next().addColumn(
+            col.name,
+            sql.raw(this.getDBType(col)),
+            this.getColumnBuilderCallback(col),
+          ),
+        );
+        return results;
+      }
+
+      case "update-column": {
+        const col = operation.value;
+        // Check for ID columns first to provide a more specific error message
+        if (col.role === "external-id" || col.role === "internal-id") {
+          throw new Error(errors.IdColumnUpdate);
+        }
+        throw new Error(errors.SQLiteUpdateColumn);
+      }
+    }
+  }
+
+  private dropTable(
+    operation: Extract<MigrationOperation, { type: "drop-table" }>,
+    mapper?: TableNameMapper,
+  ): ExecuteNode {
+    return this.db.schema.dropTable(this.getTableName(operation.name, mapper));
+  }
+
+  private addIndex(
+    operation: Extract<MigrationOperation, { type: "add-index" }>,
+    mapper?: TableNameMapper,
+  ): ExecuteNode {
+    const tableName = this.getTableName(operation.table, mapper);
+
+    if (operation.unique) {
+      return createUniqueIndex(
+        this.db,
+        operation.name,
+        tableName,
+        operation.columns,
+        this.provider,
+      );
+    }
+
+    return this.db.schema.createIndex(operation.name).on(tableName).columns(operation.columns);
+  }
+
+  private dropIndex(
+    operation: Extract<MigrationOperation, { type: "drop-index" }>,
+    mapper?: TableNameMapper,
+  ): ExecuteNode {
+    const tableName = this.getTableName(operation.table, mapper);
+    return dropUniqueIndex(this.db, operation.name, tableName, this.provider);
+  }
+
+  private handleCustomOperation(
+    operation: Extract<MigrationOperation, { type: "custom" }>,
+  ): ExecuteNode {
+    const statement = sql.raw(operation["sql"] as string);
+    return this.rawToNode(statement);
+  }
+}

package/src/adapters/kysely/migration/execute.ts

@@ -1,413 +1,50 @@
-import {
-  type ColumnBuilderCallback,
-  type Compilable,
-  type CreateTableBuilder,
-  type Kysely,
-  type RawBuilder,
-  sql,
-} from "kysely";
-import {
-  type CustomOperation,
-  isUpdated,
-  type ColumnOperation,
-  type MigrationOperation,
-  type ColumnInfo,
-} from "../../../migration-engine/shared";
-import type { SQLProvider } from "../../../shared/providers";
-import { schemaToDBType } from "../../../schema/serialize";
+import type { CustomOperation, MigrationOperation } from "../../../migration-engine/shared";
 import type { KyselyConfig } from "../kysely-adapter";
 import type { TableNameMapper } from "../kysely-shared";
-import { SETTINGS_TABLE_NAME } from "../../../shared/settings-schema";
+import type { ExecuteNode } from "./execute-base";
+import { createMigrationExecutor } from "./execute-factory";
 
-export type ExecuteNode = Compilable & {
-  execute(): Promise<unknown>;
-};
-
-type KyselyAny = Kysely<any>; // eslint-disable-line @typescript-eslint/no-explicit-any
-
-const errors = {
-  IdColumnUpdate:
-    "ID columns cannot be updated. Not every database supports updating primary keys and often requires workarounds.",
-  SQLiteUpdateColumn: "SQLite doesn't support updating columns. Recreate the table instead.",
-  SQLiteUpdateForeignKeys:
-    "SQLite doesn't support modifying foreign keys directly. Use `recreate-table` instead.",
-} as const;
-
-/**
- * Returns the appropriate foreign key action based on the provider.
- * MSSQL doesn't support RESTRICT, so we use NO ACTION (functionally equivalent).
- */
-function getForeignKeyAction(provider: SQLProvider): "restrict" | "no action" {
-  return provider === "mssql" ? "no action" : "restrict";
-}
+export type { ExecuteNode };
 
 /**
- * Generates MSSQL default constraint name following the DF_tableName_columnName pattern.
+ * Execute a single migration operation using the appropriate provider-specific executor.
+ *
+ * @param operation - The migration operation to execute
+ * @param config - Kysely configuration with database instance and provider
+ * @param onCustomNode - Handler for custom operations
+ * @param mapper - Optional table name mapper for namespacing
+ * @returns ExecuteNode(s) that can be compiled to SQL or executed
  */
-function getMssqlDefaultConstraintName(tableName: string, columnName: string): string {
-  const MSSQL_DEFAULT_CONSTRAINT_PREFIX = "DF" as const;
-  return `${MSSQL_DEFAULT_CONSTRAINT_PREFIX}_${tableName}_${columnName}`;
-}
-
-function createUniqueIndex(
-  db: KyselyAny,
-  name: string,
-  tableName: string,
-  cols: string[],
-  provider: SQLProvider,
-) {
-  const query = db.schema.createIndex(name).on(tableName).columns(cols).unique();
-
-  if (provider === "mssql") {
-    // MSSQL: ignore null values in unique indexes by default
-    return query.where((b) => {
-      return b.and(cols.map((col) => b(col, "is not", null)));
-    });
-  }
-
-  return query;
-}
-
-function dropUniqueIndex(db: KyselyAny, name: string, tableName: string, provider: SQLProvider) {
-  let query = db.schema.dropIndex(name).ifExists();
-
-  if (provider === "cockroachdb") {
-    query = query.cascade();
-  }
-
-  if (provider === "mssql") {
-    query = query.on(tableName);
-  }
-
-  return query;
-}
-
-function executeColumn(
-  tableName: string,
-  operation: ColumnOperation,
-  config: KyselyConfig,
-): ExecuteNode[] {
-  const { db, provider } = config;
-  const next = () => db.schema.alterTable(tableName);
-  const results: ExecuteNode[] = [];
-
-  switch (operation.type) {
-    case "rename-column":
-      results.push(next().renameColumn(operation.from, operation.to));
-      return results;
-
-    case "drop-column":
-      results.push(next().dropColumn(operation.name));
-
-      return results;
-    case "create-column": {
-      const col = operation.value;
-
-      results.push(
-        next().addColumn(
-          col.name,
-          sql.raw(schemaToDBType(col, provider)),
-          getColumnBuilderCallback(col, provider),
-        ),
-      );
-
-      return results;
-    }
-    case "update-column": {
-      const col = operation.value;
-
-      if (col.role === "external-id" || col.role === "internal-id") {
-        throw new Error(errors.IdColumnUpdate);
-      }
-      if (provider === "sqlite") {
-        throw new Error(errors.SQLiteUpdateColumn);
-      }
-
-      if (!isUpdated(operation)) {
-        return results;
-      }
-      if (provider === "mysql") {
-        results.push(
-          next().modifyColumn(
-            operation.name,
-            sql.raw(schemaToDBType(col, provider)),
-            getColumnBuilderCallback(col, provider),
-          ),
-        );
-        return results;
-      }
-
-      // MSSQL requires dropping and recreating default constraints when changing data type or default value
-      const mssqlRecreateDefaultConstraint = operation.updateDataType || operation.updateDefault;
-
-      if (provider === "mssql" && mssqlRecreateDefaultConstraint) {
-        results.push(rawToNode(db, mssqlDropDefaultConstraint(tableName, col.name)));
-      }
-
-      // TODO: We should maybe do some of these operations in a single query
-
-      if (operation.updateDataType) {
-        const dbType = sql.raw(schemaToDBType(col, provider));
-
-        if (provider === "postgresql" || provider === "cockroachdb") {
-          // PostgreSQL/CockroachDB: Use explicit USING clause for type conversion
-          results.push(
-            rawToNode(
-              db,
-              sql`ALTER TABLE ${sql.ref(tableName)} ALTER COLUMN ${sql.ref(operation.name)} TYPE ${dbType} USING (${sql.ref(operation.name)}::${dbType})`,
-            ),
-          );
-        } else {
-          results.push(next().alterColumn(operation.name, (b) => b.setDataType(dbType)));
-        }
-      }
-
-      if (operation.updateNullable) {
-        results.push(
-          next().alterColumn(operation.name, (build) =>
-            col.isNullable ? build.dropNotNull() : build.setNotNull(),
-          ),
-        );
-      }
-
-      if (provider === "mssql" && mssqlRecreateDefaultConstraint) {
-        const defaultValue = defaultValueToDB(col, provider);
-
-        if (defaultValue) {
-          const constraintName = getMssqlDefaultConstraintName(tableName, col.name);
-
-          results.push(
-            rawToNode(
-              db,
-              sql`ALTER TABLE ${sql.ref(tableName)} ADD CONSTRAINT ${sql.ref(constraintName)} DEFAULT ${defaultValue} FOR ${sql.ref(col.name)}`,
-            ),
-          );
-        }
-      } else if (operation.updateDefault) {
-        const defaultValue = defaultValueToDB(col, provider);
-
-        results.push(
-          next().alterColumn(operation.name, (build) => {
-            if (!defaultValue) {
-              return build.dropDefault();
-            }
-            return build.setDefault(defaultValue);
-          }),
-        );
-      }
-
-      return results;
-    }
-  }
-}
-
 export function execute(
   operation: MigrationOperation,
   config: KyselyConfig,
   onCustomNode: (op: CustomOperation) => ExecuteNode | ExecuteNode[],
   mapper?: TableNameMapper,
 ): ExecuteNode | ExecuteNode[] {
-  const { db, provider } = config;
-
-  // Settings table is never namespaced
-  const getTableName = (tableName: string) =>
-    tableName === SETTINGS_TABLE_NAME
-      ? tableName
-      : mapper
-        ? mapper.toPhysical(tableName)
-        : tableName;
-
-  function createTable(tableName: string, columns: ColumnInfo[]) {
-    let builder = db.schema.createTable(getTableName(tableName)) as CreateTableBuilder<
-      string,
-      string
-    >;
-
-    // Add columns from the column info array
-    for (const columnInfo of columns) {
-      builder = builder.addColumn(
-        columnInfo.name,
-        sql.raw(schemaToDBType(columnInfo, provider)),
-        getColumnBuilderCallback(columnInfo, provider),
-      );
-    }
-
-    return builder;
-  }
-
-  switch (operation.type) {
-    case "create-table":
-      return createTable(operation.name, operation.columns);
-    case "rename-table":
-      if (provider === "mssql") {
-        return rawToNode(
-          db,
-          sql`EXEC sp_rename ${sql.lit(getTableName(operation.from))}, ${sql.lit(getTableName(operation.to))}`,
-        );
-      }
-
-      return db.schema
-        .alterTable(getTableName(operation.from))
-        .renameTo(getTableName(operation.to));
-    case "alter-table": {
-      const results: ExecuteNode[] = [];
-
-      for (const op of operation.value) {
-        results.push(...executeColumn(getTableName(operation.name), op, config));
-      }
-
-      return results;
-    }
-    case "drop-table":
-      return db.schema.dropTable(getTableName(operation.name));
-    case "custom":
-      return onCustomNode(operation);
-    case "add-foreign-key": {
-      if (provider === "sqlite") {
-        throw new Error(errors.SQLiteUpdateForeignKeys);
-      }
-
-      const { table, value } = operation;
-      const action = getForeignKeyAction(provider);
-
-      return db.schema
-        .alterTable(getTableName(table))
-        .addForeignKeyConstraint(
-          value.name,
-          value.columns,
-          getTableName(value.referencedTable),
-          value.referencedColumns,
-          (b) => b.onUpdate(action).onDelete(action),
-        );
-    }
-    case "drop-foreign-key": {
-      if (provider === "sqlite") {
-        throw new Error(errors.SQLiteUpdateForeignKeys);
-      }
-
-      const { table, name } = operation;
-      let query = db.schema.alterTable(getTableName(table)).dropConstraint(name);
-
-      // MySQL doesn't support IF EXISTS for dropping constraints
-      if (provider !== "mysql") {
-        query = query.ifExists();
-      }
-
-      return query;
-    }
-    case "add-index": {
-      if (operation.unique) {
-        return createUniqueIndex(
-          db,
-          operation.name,
-          getTableName(operation.table),
-          operation.columns,
-          provider,
-        );
-      }
-      return db.schema
-        .createIndex(operation.name)
-        .on(getTableName(operation.table))
-        .columns(operation.columns);
-    }
-    case "drop-index": {
-      return dropUniqueIndex(db, operation.name, getTableName(operation.table), provider);
-    }
+  // For custom operations, use the provided handler
+  if (operation.type === "custom") {
+    return onCustomNode(operation);
   }
-}
-
-// ============================================================================
-// Helper Functions
-// ============================================================================
-
-function getColumnBuilderCallback(col: ColumnInfo, provider: SQLProvider): ColumnBuilderCallback {
-  return (build) => {
-    if (!col.isNullable) {
-      build = build.notNull();
-    }
-
-    // Internal ID is the primary key with auto-increment
-    if (col.role === "internal-id") {
-      build = build.primaryKey();
-      // Auto-increment for internal ID
-      if (provider === "postgresql" || provider === "cockroachdb") {
-        // SERIAL/BIGSERIAL handles auto-increment
-        // Already handled in schemaToDBType
-      } else if (provider === "mysql") {
-        build = build.autoIncrement();
-      } else if (provider === "sqlite") {
-        build = build.autoIncrement();
-      } else if (provider === "mssql") {
-        build = build.identity();
-      }
-    }
 
-    // External ID must be unique
-    if (col.role === "external-id") {
-      build = build.unique();
-    }
-
-    const defaultValue = defaultValueToDB(col, provider);
-    if (defaultValue) {
-      build = build.defaultTo(defaultValue);
-    }
-    return build;
-  };
-}
-
-function rawToNode(db: KyselyAny, raw: RawBuilder<unknown>): ExecuteNode {
-  return {
-    compile() {
-      return raw.compile(db);
-    },
-    execute() {
-      return raw.execute(db);
-    },
-  };
-}
-
-function mssqlDropDefaultConstraint(tableName: string, columnName: string) {
-  return sql`
-DECLARE @ConstraintName NVARCHAR(200);
-
-SELECT @ConstraintName = dc.name
-FROM sys.default_constraints dc
-JOIN sys.columns c ON dc.parent_object_id = c.object_id AND dc.parent_column_id = c.column_id
-JOIN sys.tables t ON t.object_id = c.object_id
-JOIN sys.schemas s ON t.schema_id = s.schema_id
-WHERE s.name = 'dbo' AND t.name = ${sql.lit(tableName)} AND c.name = ${sql.lit(columnName)};
-
-IF @ConstraintName IS NOT NULL
-BEGIN
-    EXEC('ALTER TABLE [dbo].[' + ${sql.lit(tableName)} + '] DROP CONSTRAINT [' + @ConstraintName + ']');
-END`;
+  const executor = createMigrationExecutor(config);
+  return executor.executeOperation(operation, mapper);
 }
 
-function defaultValueToDB(column: ColumnInfo, provider: SQLProvider) {
-  const value = column.default;
-  if (!value) {
-    return undefined;
-  }
-
-  // MySQL doesn't support default values for TEXT columns
-  if (provider === "mysql" && column.type === "string") {
-    return undefined;
-  }
-
-  // Static default values: defaultTo(value)
-  if ("value" in value && value.value !== undefined) {
-    return sql.lit(value.value);
-  }
-
-  // Database-level special functions: defaultTo(b => b.now())
-  if ("dbSpecial" in value && value.dbSpecial === "now") {
-    return sql`CURRENT_TIMESTAMP`;
-  }
-
-  // Runtime defaults (defaultTo$) are NOT generated in SQL - they're handled in application code
-  if ("runtime" in value) {
-    return undefined;
-  }
-
-  return undefined;
+/**
+ * Preprocess a batch of migration operations.
+ * This allows provider-specific transformations before execution.
+ *
+ * For example, SQLite merges add-foreign-key operations into create-table operations
+ * since foreign keys must be defined at table creation time.
+ *
+ * @param operations - The migration operations to preprocess
+ * @param config - Kysely configuration with database instance and provider
+ * @returns Preprocessed migration operations
+ */
+export function preprocessOperations(
+  operations: MigrationOperation[],
+  config: KyselyConfig,
+): MigrationOperation[] {
+  const executor = createMigrationExecutor(config);
+  return executor.preprocessOperations(operations);
 }