@fragno-dev/db 0.1.2 → 0.1.5

package/src/adapters/drizzle/generate.test.ts

@@ -189,7 +189,7 @@ describe("generateSchema", () => {
     it("should generate SQLite schema", () => {
       const generated = generateSchema([{ namespace: "test", schema: testSchema }], "sqlite");
       expect(generated).toMatchInlineSnapshot(`
-        "import { sqliteTable, text, integer, uniqueIndex, index, blob, foreignKey } from "drizzle-orm/sqlite-core"
+        "import { sqliteTable, text, integer, uniqueIndex, index, foreignKey } from "drizzle-orm/sqlite-core"
         import { createId } from "@fragno-dev/db/id"
         import { relations } from "drizzle-orm"
 
@@ -201,7 +201,7 @@ describe("generateSchema", () => {
           id: text("id").notNull().$defaultFn(() => createId()),
           key: text("key").notNull(),
           value: text("value").notNull(),
-          _internalId: integer("_internalId").primaryKey().autoincrement().notNull(),
+          _internalId: integer("_internalId").primaryKey({ autoIncrement: true }).notNull(),
           _version: integer("_version").notNull().default(0)
         }, (table) => [
           uniqueIndex("unique_key").on(table.key)
@@ -218,7 +218,7 @@ describe("generateSchema", () => {
           name: text("name").notNull(),
           email: text("email").notNull(),
           age: integer("age"),
-          _internalId: integer("_internalId").primaryKey().autoincrement().notNull(),
+          _internalId: integer("_internalId").primaryKey({ autoIncrement: true }).notNull(),
           _version: integer("_version").notNull().default(0)
         }, (table) => [
           uniqueIndex("idx_email_test").on(table.email),
@@ -229,9 +229,9 @@ describe("generateSchema", () => {
           id: text("id").notNull().$defaultFn(() => createId()),
           title: text("title").notNull(),
           content: text("content").notNull(),
-          userId: blob("userId", { mode: "bigint" }).notNull(),
+          userId: integer("userId").notNull(),
           viewCount: integer("viewCount").notNull().default(0),
-          _internalId: integer("_internalId").primaryKey().autoincrement().notNull(),
+          _internalId: integer("_internalId").primaryKey({ autoIncrement: true }).notNull(),
           _version: integer("_version").notNull().default(0)
         }, (table) => [
           foreignKey({
@@ -612,7 +612,7 @@ describe("generateSchema", () => {
     it("should generate SQLite schema with many relations", () => {
       const generated = generateSchema([{ namespace: "test", schema: oneToManySchema }], "sqlite");
       expect(generated).toMatchInlineSnapshot(`
-        "import { sqliteTable, text, integer, uniqueIndex, blob, foreignKey, index } from "drizzle-orm/sqlite-core"
+        "import { sqliteTable, text, integer, uniqueIndex, foreignKey, index } from "drizzle-orm/sqlite-core"
         import { createId } from "@fragno-dev/db/id"
         import { relations } from "drizzle-orm"
 
@@ -624,7 +624,7 @@ describe("generateSchema", () => {
           id: text("id").notNull().$defaultFn(() => createId()),
           key: text("key").notNull(),
           value: text("value").notNull(),
-          _internalId: integer("_internalId").primaryKey().autoincrement().notNull(),
+          _internalId: integer("_internalId").primaryKey({ autoIncrement: true }).notNull(),
           _version: integer("_version").notNull().default(0)
         }, (table) => [
           uniqueIndex("unique_key").on(table.key)
@@ -639,7 +639,7 @@ describe("generateSchema", () => {
         export const users_test = sqliteTable("users_test", {
           id: text("id").notNull().$defaultFn(() => createId()),
           name: text("name").notNull(),
-          _internalId: integer("_internalId").primaryKey().autoincrement().notNull(),
+          _internalId: integer("_internalId").primaryKey({ autoIncrement: true }).notNull(),
           _version: integer("_version").notNull().default(0)
         })
 
@@ -652,8 +652,8 @@ describe("generateSchema", () => {
         export const posts_test = sqliteTable("posts_test", {
           id: text("id").notNull().$defaultFn(() => createId()),
           title: text("title").notNull(),
-          userId: blob("userId", { mode: "bigint" }).notNull(),
-          _internalId: integer("_internalId").primaryKey().autoincrement().notNull(),
+          userId: integer("userId").notNull(),
+          _internalId: integer("_internalId").primaryKey({ autoIncrement: true }).notNull(),
           _version: integer("_version").notNull().default(0)
         }, (table) => [
           foreignKey({
@@ -1008,7 +1008,7 @@ describe("generateSchema", () => {
     it("should generate SQLite self-referencing foreign key using table parameter", () => {
       const generated = generateSchema([{ namespace: "test", schema: selfRefSchema }], "sqlite");
       expect(generated).toMatchInlineSnapshot(`
-        "import { sqliteTable, text, integer, uniqueIndex, blob, foreignKey, index } from "drizzle-orm/sqlite-core"
+        "import { sqliteTable, text, integer, uniqueIndex, foreignKey, index } from "drizzle-orm/sqlite-core"
         import { createId } from "@fragno-dev/db/id"
         import { relations } from "drizzle-orm"
 
@@ -1020,7 +1020,7 @@ describe("generateSchema", () => {
           id: text("id").notNull().$defaultFn(() => createId()),
           key: text("key").notNull(),
           value: text("value").notNull(),
-          _internalId: integer("_internalId").primaryKey().autoincrement().notNull(),
+          _internalId: integer("_internalId").primaryKey({ autoIncrement: true }).notNull(),
           _version: integer("_version").notNull().default(0)
         }, (table) => [
           uniqueIndex("unique_key").on(table.key)
@@ -1035,8 +1035,8 @@ describe("generateSchema", () => {
         export const comment_test = sqliteTable("comment_test", {
           id: text("id").notNull().$defaultFn(() => createId()),
           content: text("content").notNull(),
-          parentId: blob("parentId", { mode: "bigint" }),
-          _internalId: integer("_internalId").primaryKey().autoincrement().notNull(),
+          parentId: integer("parentId"),
+          _internalId: integer("_internalId").primaryKey({ autoIncrement: true }).notNull(),
           _version: integer("_version").notNull().default(0)
         }, (table) => [
           foreignKey({
@@ -1063,4 +1063,101 @@ describe("generateSchema", () => {
       `);
     });
   });
+
+  describe("namespace sanitization", () => {
+    it("should sanitize namespace with special characters in foreign key references", () => {
+      const generated = generateSchema(
+        [{ namespace: "my-fragment-v2", schema: testSchema }],
+        "postgresql",
+      );
+
+      // Should generate valid JavaScript identifiers (underscores instead of hyphens)
+      expect(generated).toContain("export const users_my_fragment_v2 =");
+      expect(generated).toContain("export const posts_my_fragment_v2 =");
+
+      // Foreign key should reference sanitized table name
+      expect(generated).toContain("foreignColumns: [users_my_fragment_v2._internalId]");
+
+      // Relations should also use sanitized names
+      expect(generated).toContain("author: one(users_my_fragment_v2");
+      expect(generated).toContain("fields: [posts_my_fragment_v2.userId]");
+      expect(generated).toContain("references: [users_my_fragment_v2._internalId]");
+
+      // Physical table names in the database can keep hyphens
+      expect(generated).toContain('pgTable("users_my-fragment-v2"');
+      expect(generated).toContain('pgTable("posts_my-fragment-v2"');
+
+      expect(generated).toMatchInlineSnapshot(`
+        "import { pgTable, varchar, text, bigserial, integer, uniqueIndex, index, bigint, foreignKey } from "drizzle-orm/pg-core"
+        import { createId } from "@fragno-dev/db/id"
+        import { relations } from "drizzle-orm"
+
+        // ============================================================================
+        // Settings Table (shared across all fragments)
+        // ============================================================================
+
+        export const fragno_db_settings = pgTable("fragno_db_settings", {
+          id: varchar("id", { length: 30 }).notNull().$defaultFn(() => createId()),
+          key: text("key").notNull(),
+          value: text("value").notNull(),
+          _internalId: bigserial("_internalId", { mode: "number" }).primaryKey().notNull(),
+          _version: integer("_version").notNull().default(0)
+        }, (table) => [
+          uniqueIndex("unique_key").on(table.key)
+        ])
+
+        export const fragnoDbSettingSchemaVersion = 1;
+
+        // ============================================================================
+        // Fragment: my-fragment-v2
+        // ============================================================================
+
+        export const users_my_fragment_v2 = pgTable("users_my-fragment-v2", {
+          id: varchar("id", { length: 30 }).notNull().$defaultFn(() => createId()),
+          name: text("name").notNull(),
+          email: text("email").notNull(),
+          age: integer("age"),
+          _internalId: bigserial("_internalId", { mode: "number" }).primaryKey().notNull(),
+          _version: integer("_version").notNull().default(0)
+        }, (table) => [
+          uniqueIndex("idx_email_my-fragment-v2").on(table.email),
+          index("idx_name_my-fragment-v2").on(table.name)
+        ])
+
+        export const posts_my_fragment_v2 = pgTable("posts_my-fragment-v2", {
+          id: varchar("id", { length: 30 }).notNull().$defaultFn(() => createId()),
+          title: text("title").notNull(),
+          content: text("content").notNull(),
+          userId: bigint("userId", { mode: "number" }).notNull(),
+          viewCount: integer("viewCount").notNull().default(0),
+          _internalId: bigserial("_internalId", { mode: "number" }).primaryKey().notNull(),
+          _version: integer("_version").notNull().default(0)
+        }, (table) => [
+          foreignKey({
+            columns: [table.userId],
+            foreignColumns: [users_my_fragment_v2._internalId],
+            name: "fk_posts_users_author_my-fragment-v2"
+          }),
+          index("idx_user_my-fragment-v2").on(table.userId),
+          index("idx_title_my-fragment-v2").on(table.title)
+        ])
+
+        export const posts_my_fragment_v2Relations = relations(posts_my_fragment_v2, ({ one }) => ({
+          author: one(users_my_fragment_v2, {
+            relationName: "posts_users",
+            fields: [posts_my_fragment_v2.userId],
+            references: [users_my_fragment_v2._internalId]
+          })
+        }));
+
+        export const my_fragment_v2_schema = {
+          "users_my-fragment-v2": users_my_fragment_v2,
+          users: users_my_fragment_v2,
+          "posts_my-fragment-v2": posts_my_fragment_v2,
+          posts: posts_my_fragment_v2,
+          schemaVersion: 3
+        }"
+      `);
+    });
+  });
 });

package/src/adapters/drizzle/generate.ts

@@ -248,12 +248,16 @@ function generateColumnDefinition(
 
   // Primary key for internal ID
   if (column instanceof InternalIdColumn || column.role === "internal-id") {
-    parts.push("primaryKey()");
-
-    // Auto-increment based on provider
-    // Note: PostgreSQL uses bigserial/serial which handle auto-increment automatically
-    if (ctx.provider === "mysql" || ctx.provider === "sqlite") {
+    if (ctx.provider === "sqlite") {
+      // SQLite uses primaryKey({ autoIncrement: true })
+      parts.push("primaryKey({ autoIncrement: true })");
+    } else if (ctx.provider === "mysql") {
+      // MySQL uses primaryKey().autoincrement()
+      parts.push("primaryKey()");
       parts.push("autoincrement()");
+    } else {
+      // PostgreSQL just uses primaryKey()
+      parts.push("primaryKey()");
     }
   }
 
@@ -334,8 +338,9 @@ function generateForeignKeys(ctx: GeneratorContext, table: AnyTable, namespace?:
         foreignColumns.push(`table.${actualRefCol}`);
       } else {
         // Suffix the foreign table reference with namespace if provided
-        const foreignTableRef =
-          mapper && namespace ? mapper.toPhysical(relation.table.ormName) : relation.table.ormName;
+        const foreignTableRef = namespace
+          ? `${relation.table.ormName}_${sanitizeNamespace(namespace)}`
+          : relation.table.ormName;
         foreignColumns.push(`${foreignTableRef}.${actualRefCol}`);
       }
     }

package/src/adapters/kysely/kysely-adapter.ts

@@ -4,7 +4,7 @@ import type { DatabaseAdapter } from "../adapters";
 import { createMigrator, type Migrator } from "../../migration-engine/create";
 import type { AnySchema } from "../../schema/create";
 import type { CustomOperation, MigrationOperation } from "../../migration-engine/shared";
-import { execute } from "./migration/execute";
+import { execute, preprocessOperations } from "./migration/execute";
 import type { AbstractQuery } from "../../query/query";
 import { fromKysely } from "./kysely-query";
 import { createTableNameMapper } from "./kysely-shared";
@@ -47,40 +47,50 @@ export class KyselyAdapter implements DatabaseAdapter {
     const manager = createSettingsManager(this.#kyselyConfig.db, namespace);
     const mapper = namespace ? createTableNameMapper(namespace) : undefined;
 
-    const onCustomNode = (node: CustomOperation, db: KyselyAny) => {
-      const statement = sql.raw(node["sql"] as string);
+    const preprocessMigrationOperations = (operations: MigrationOperation[]) => {
+      let preprocessed = preprocessOperations(operations, this.#kyselyConfig);
 
-      return {
-        compile() {
-          return statement.compile(db);
-        },
-        execute() {
-          return statement.execute(db);
-        },
-      };
-    };
-
-    const preprocess = (operations: MigrationOperation[], db: KyselyAny) => {
       if (this.#kyselyConfig.provider === "mysql") {
-        operations.unshift({ type: "custom", sql: "SET FOREIGN_KEY_CHECKS = 0" });
-        operations.push({ type: "custom", sql: "SET FOREIGN_KEY_CHECKS = 1" });
-      } else if (this.#kyselyConfig.provider === "sqlite") {
-        operations.unshift({
-          type: "custom",
-          sql: "PRAGMA defer_foreign_keys = ON",
-        });
+        preprocessed.unshift({ type: "custom", sql: "SET FOREIGN_KEY_CHECKS = 0" });
+        preprocessed.push({ type: "custom", sql: "SET FOREIGN_KEY_CHECKS = 1" });
       }
 
+      return preprocessed;
+    };
+
+    // Convert operations to executable nodes bound to specific db instance
+    const toExecutableNodes = (operations: MigrationOperation[], db: KyselyAny) => {
+      const onCustomNode = (node: CustomOperation, db: KyselyAny) => {
+        const statement = sql.raw(node["sql"] as string);
+
+        return {
+          compile() {
+            return statement.compile(db);
+          },
+          execute() {
+            return statement.execute(db);
+          },
+        };
+      };
+
+      const dbConfig: KyselyConfig = { db, provider: this.#kyselyConfig.provider };
       return operations.flatMap((op) =>
-        execute(op, this.#kyselyConfig, (node) => onCustomNode(node, db), mapper),
+        execute(op, dbConfig, (node) => onCustomNode(node, db), mapper),
       );
     };
 
     const migrator = createMigrator({
       schema,
       executor: async (operations) => {
+        // For SQLite, execute PRAGMA defer_foreign_keys BEFORE transaction
+        if (this.#kyselyConfig.provider === "sqlite") {
+          await sql.raw("PRAGMA defer_foreign_keys = ON").execute(this.#kyselyConfig.db);
+        }
+
         await this.#kyselyConfig.db.transaction().execute(async (tx) => {
-          for (const node of preprocess(operations, tx)) {
+          const preprocessed = preprocessMigrationOperations(operations);
+          const nodes = toExecutableNodes(preprocessed, tx);
+          for (const node of nodes) {
             try {
               await node.execute();
             } catch (e) {
@@ -92,11 +102,20 @@ export class KyselyAdapter implements DatabaseAdapter {
       },
       sql: {
         toSql: (operations) => {
-          const compiled = preprocess(operations, this.#kyselyConfig.db).map(
-            (m) => `${m.compile().sql};`,
-          );
+          const parts: string[] = [];
+
+          // Add SQLite PRAGMA at the beginning
+          if (this.#kyselyConfig.provider === "sqlite") {
+            parts.push("PRAGMA defer_foreign_keys = ON;");
+          }
+
+          const preprocessed = preprocessMigrationOperations(operations);
+          const nodes = toExecutableNodes(preprocessed, this.#kyselyConfig.db);
+          const compiled = nodes.map((node) => `${node.compile().sql};`);
+
+          parts.push(...compiled);
 
-          return compiled.join("\n\n");
+          return parts.join("\n\n");
         },
       },
 

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

@@ -0,0 +1,256 @@
+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

@@ -0,0 +1,30 @@
+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";
+
+/**
+ * Create a provider-specific migration executor.
+ */
+export function createMigrationExecutor(config: KyselyConfig): MigrationExecutor {
+  const { db, provider } = config;
+
+  switch (provider) {
+    case "sqlite":
+      return new SqliteMigrationExecutor(db, provider);
+    case "postgresql":
+    case "cockroachdb":
+      return new PostgresMigrationExecutor(db, provider);
+    case "mysql":
+      return new MysqlMigrationExecutor(db, provider);
+    case "mssql":
+      return new MssqlMigrationExecutor(db, provider);
+    default: {
+      // Ensure exhaustive switch
+      const _exhaustive: never = provider;
+      throw new Error(`Unsupported provider: ${_exhaustive}`);
+    }
+  }
+}