@fragno-dev/db 0.1.14 → 0.2.0

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

@@ -1,256 +0,0 @@
-import { type ColumnBuilderCallback, type Kysely, type RawBuilder, sql } from "kysely";
-import type {
-  ColumnInfo,
-  MigrationOperation,
-  MigrationOperationMetadata,
-} from "../../../migration-engine/shared";
-import type { SQLProvider } from "../../../shared/providers";
-import { schemaToDBType } from "../../../schema/serialize";
-import type { TableNameMapper } from "../kysely-shared";
-import { SETTINGS_TABLE_NAME } from "../../../shared/settings-schema";
-
-export type ExecuteNode = {
-  compile(): { sql: string; parameters: readonly unknown[] };
-  execute(): Promise<unknown>;
-};
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-type KyselyAny = Kysely<any>;
-
-/**
- * Migration executor interface.
- * Each provider implements this to handle database-specific migration execution.
- */
-export interface MigrationExecutor<
-  TMeta extends MigrationOperationMetadata = MigrationOperationMetadata,
-> {
-  /**
-   * Preprocess operations before execution.
-   * Allows executors to combine, split, or transform operations based on provider capabilities.
-   *
-   * For example, SQLite can merge add-foreign-key operations into create-table operations.
-   */
-  preprocessOperations(operations: MigrationOperation[]): MigrationOperation<TMeta>[];
-
-  /**
-   * Execute a single migration operation.
-   */
-  executeOperation(
-    operation: MigrationOperation<TMeta>,
-    mapper?: TableNameMapper,
-  ): ExecuteNode | ExecuteNode[];
-}
-
-/**
- * Base migration executor with common functionality.
- * Provider-specific executors should extend this class.
- */
-export abstract class BaseMigrationExecutor<
-  TMeta extends MigrationOperationMetadata = MigrationOperationMetadata,
-> implements MigrationExecutor<TMeta>
-{
-  constructor(
-    protected readonly db: KyselyAny,
-    protected readonly provider: SQLProvider,
-  ) {}
-
-  /**
-   * Default implementation: no preprocessing, no metadata.
-   * Providers can override to transform operations.
-   */
-  preprocessOperations(operations: MigrationOperation[]): MigrationOperation<TMeta>[] {
-    return operations as MigrationOperation<TMeta>[];
-  }
-
-  /**
-   * Execute a single migration operation.
-   * Must be implemented by provider-specific executors.
-   */
-  abstract executeOperation(
-    operation: MigrationOperation<TMeta>,
-    mapper?: TableNameMapper,
-  ): ExecuteNode | ExecuteNode[];
-
-  /**
-   * Get table name, applying namespace mapping if provided.
-   * Settings table is never namespaced.
-   */
-  protected getTableName(tableName: string, mapper?: TableNameMapper): string {
-    return tableName === SETTINGS_TABLE_NAME
-      ? tableName
-      : mapper
-        ? mapper.toPhysical(tableName)
-        : tableName;
-  }
-
-  /**
-   * Get column builder callback for creating/altering columns.
-   */
-  protected getColumnBuilderCallback(col: ColumnInfo): 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 (this.provider === "postgresql" || this.provider === "cockroachdb") {
-          // SERIAL/BIGSERIAL handles auto-increment
-          // Already handled in schemaToDBType
-        } else if (this.provider === "mysql") {
-          build = build.autoIncrement();
-        } else if (this.provider === "sqlite") {
-          build = build.autoIncrement();
-        } else if (this.provider === "mssql") {
-          build = build.identity();
-        }
-      }
-
-      // External ID must be unique
-      if (col.role === "external-id") {
-        build = build.unique();
-      }
-
-      const defaultValue = this.defaultValueToDB(col);
-      if (defaultValue) {
-        build = build.defaultTo(defaultValue);
-      }
-      return build;
-    };
-  }
-
-  /**
-   * Convert column default value to database representation.
-   */
-  protected defaultValueToDB(column: ColumnInfo): RawBuilder<unknown> | undefined {
-    const value = column.default;
-    if (!value) {
-      return undefined;
-    }
-
-    // MySQL doesn't support default values for TEXT columns
-    if (this.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;
-  }
-
-  /**
-   * Wrap a raw SQL builder in an ExecuteNode.
-   */
-  protected rawToNode(raw: RawBuilder<unknown>): ExecuteNode {
-    return {
-      compile: () => raw.compile(this.db),
-      execute: () => raw.execute(this.db),
-    };
-  }
-
-  /**
-   * Get the database type string for a column.
-   */
-  protected getDBType(col: ColumnInfo): string {
-    return schemaToDBType(col, this.provider);
-  }
-}
-
-// ============================================================================
-// Provider-Specific Helper Functions
-// ============================================================================
-
-/**
- * Returns the appropriate foreign key action based on the provider.
- * MSSQL doesn't support RESTRICT, so we use NO ACTION (functionally equivalent).
- */
-export function getForeignKeyAction(provider: SQLProvider): "restrict" | "no action" {
-  return provider === "mssql" ? "no action" : "restrict";
-}
-
-/**
- * Generates MSSQL default constraint name following the DF_tableName_columnName pattern.
- */
-export function getMssqlDefaultConstraintName(tableName: string, columnName: string): string {
-  const MSSQL_DEFAULT_CONSTRAINT_PREFIX = "DF" as const;
-  return `${MSSQL_DEFAULT_CONSTRAINT_PREFIX}_${tableName}_${columnName}`;
-}
-
-/**
- * Generate SQL to drop MSSQL default constraint.
- */
-export 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`;
-}
-
-/**
- * Create a unique index with provider-specific handling.
- */
-export 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;
-}
-
-/**
- * Drop a unique index with provider-specific handling.
- */
-export 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;
-}

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

@@ -1,53 +0,0 @@
-import type { Kysely } from "kysely";
-import type { KyselyConfig } from "../kysely-adapter";
-import type { MigrationExecutor } from "./execute-base";
-import { SqliteMigrationExecutor } from "./execute-sqlite";
-import { PostgresMigrationExecutor } from "./execute-postgres";
-import { MysqlMigrationExecutor } from "./execute-mysql";
-import { MssqlMigrationExecutor } from "./execute-mssql";
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-type KyselyAny = Kysely<any>;
-
-/**
- * Create a provider-specific migration executor.
- */
-export function createMigrationExecutor(config: KyselyConfig): MigrationExecutor {
-  const { provider } = config;
-  // Resolve db instance synchronously
-  // Safe cast: This is only called from synchronous contexts where the db must be available
-  const dbOrFactory = config.db;
-  let kysely: KyselyAny;
-
-  if (typeof dbOrFactory === "function") {
-    const result = dbOrFactory();
-    // Check if it's a Promise - if so, this is an error in usage
-    if (result && typeof (result as Promise<unknown>).then === "function") {
-      throw new Error(
-        "Cannot create migration executor with async database factory. " +
-          "Database must be initialized before calling preprocessOperations.",
-      );
-    }
-    // Safe cast: We've verified it's not a Promise
-    kysely = result as KyselyAny;
-  } else {
-    kysely = dbOrFactory;
-  }
-
-  switch (provider) {
-    case "sqlite":
-      return new SqliteMigrationExecutor(kysely, provider);
-    case "postgresql":
-    case "cockroachdb":
-      return new PostgresMigrationExecutor(kysely, provider);
-    case "mysql":
-      return new MysqlMigrationExecutor(kysely, provider);
-    case "mssql":
-      return new MssqlMigrationExecutor(kysely, provider);
-    default: {
-      // Ensure exhaustive switch
-      const _exhaustive: never = provider;
-      throw new Error(`Unsupported provider: ${_exhaustive}`);
-    }
-  }
-}

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

@@ -1,250 +0,0 @@
-import { sql } from "kysely";
-import {
-  type ColumnOperation,
-  isUpdated,
-  type MigrationOperation,
-} from "../../../migration-engine/shared";
-import type { TableNameMapper } from "../kysely-shared";
-import {
-  BaseMigrationExecutor,
-  createUniqueIndex,
-  dropUniqueIndex,
-  type ExecuteNode,
-  getForeignKeyAction,
-  getMssqlDefaultConstraintName,
-  mssqlDropDefaultConstraint,
-} from "./execute-base";
-
-const errors = {
-  IdColumnUpdate:
-    "ID columns cannot be updated. Not every database supports updating primary keys and often requires workarounds.",
-} as const;
-
-/**
- * MSSQL-specific migration executor.
- * Handles complex default constraint management and uses sp_rename for table renames.
- */
-export class MssqlMigrationExecutor extends BaseMigrationExecutor {
-  executeOperation(
-    operation: MigrationOperation,
-    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":
-        return this.addForeignKey(operation, mapper);
-      case "drop-foreign-key":
-        return this.dropForeignKey(operation, mapper);
-      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, { type: "create-table" }>,
-    mapper?: TableNameMapper,
-  ): ExecuteNode {
-    const tableName = this.getTableName(operation.name, mapper);
-    let builder = 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),
-      );
-    }
-
-    return builder;
-  }
-
-  private renameTable(
-    operation: Extract<MigrationOperation, { type: "rename-table" }>,
-    mapper?: TableNameMapper,
-  ): ExecuteNode {
-    // MSSQL uses sp_rename procedure
-    return this.rawToNode(
-      sql`EXEC sp_rename ${sql.lit(this.getTableName(operation.from, mapper))}, ${sql.lit(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;
-
-        if (col.role === "external-id" || col.role === "internal-id") {
-          throw new Error(errors.IdColumnUpdate);
-        }
-
-        if (!isUpdated(operation)) {
-          return results;
-        }
-
-        // MSSQL requires dropping and recreating default constraints when changing data type or default value
-        const mssqlRecreateDefaultConstraint = operation.updateDataType || operation.updateDefault;
-
-        if (mssqlRecreateDefaultConstraint) {
-          results.push(this.rawToNode(mssqlDropDefaultConstraint(tableName, col.name)));
-        }
-
-        if (operation.updateDataType) {
-          const dbType = sql.raw(this.getDBType(col));
-          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 (mssqlRecreateDefaultConstraint) {
-          const defaultValue = this.defaultValueToDB(col);
-
-          if (defaultValue) {
-            const constraintName = getMssqlDefaultConstraintName(tableName, col.name);
-            results.push(
-              this.rawToNode(
-                sql`ALTER TABLE ${sql.ref(tableName)} ADD CONSTRAINT ${sql.ref(constraintName)} DEFAULT ${defaultValue} FOR ${sql.ref(col.name)}`,
-              ),
-            );
-          }
-        } else if (operation.updateDefault) {
-          const defaultValue = this.defaultValueToDB(col);
-          results.push(
-            next().alterColumn(operation.name, (build) => {
-              if (!defaultValue) {
-                return build.dropDefault();
-              }
-              return build.setDefault(defaultValue);
-            }),
-          );
-        }
-
-        return results;
-      }
-    }
-  }
-
-  private dropTable(
-    operation: Extract<MigrationOperation, { type: "drop-table" }>,
-    mapper?: TableNameMapper,
-  ): ExecuteNode {
-    return this.db.schema.dropTable(this.getTableName(operation.name, mapper));
-  }
-
-  private addForeignKey(
-    operation: Extract<MigrationOperation, { type: "add-foreign-key" }>,
-    mapper?: TableNameMapper,
-  ): ExecuteNode {
-    const { table, value } = operation;
-    const action = getForeignKeyAction(this.provider);
-
-    return this.db.schema
-      .alterTable(this.getTableName(table, mapper))
-      .addForeignKeyConstraint(
-        value.name,
-        value.columns,
-        this.getTableName(value.referencedTable, mapper),
-        value.referencedColumns,
-        (b) => b.onUpdate(action).onDelete(action),
-      );
-  }
-
-  private dropForeignKey(
-    operation: Extract<MigrationOperation, { type: "drop-foreign-key" }>,
-    mapper?: TableNameMapper,
-  ): ExecuteNode {
-    const { table, name } = operation;
-    return this.db.schema
-      .alterTable(this.getTableName(table, mapper))
-      .dropConstraint(name)
-      .ifExists();
-  }
-
-  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);
-  }
-}