@fragno-dev/db 0.2.2 → 0.4.1

package/src/adapters/generic-sql/migration/prepared-migrations.test.ts

@@ -1,13 +1,19 @@
 import { describe, expect, test } from "vitest";
+
+import {
+  createNamingResolver,
+  schemaNamingStrategy,
+  suffixNamingStrategy,
+  type SqlNamingStrategy,
+} from "../../../naming/sql-naming";
 import { column, idColumn, referenceColumn, schema } from "../../../schema/create";
 import { createColdKysely } from "./cold-kysely";
-import { SQLiteSQLGenerator } from "./dialect/sqlite";
-import { PostgresSQLGenerator } from "./dialect/postgres";
 import { MySQLSQLGenerator } from "./dialect/mysql";
+import { PostgresSQLGenerator } from "./dialect/postgres";
+import { SQLiteSQLGenerator } from "./dialect/sqlite";
 import { createPreparedMigrations } from "./prepared-migrations";
-import { createTableNameMapper } from "../../shared/table-name-mapper";
 
-const testSchema = schema((s) => {
+const testSchema = schema("test", (s) => {
   return s
     .addTable("users", (t) => {
       return t.addColumn("id", idColumn()).addColumn("name", column("string"));
@@ -31,9 +37,42 @@ const testSchema = schema((s) => {
     });
 });
 
+const nullableSchema = schema("nullable", (s) => {
+  return s
+    .addTable("users", (t) => {
+      return t.addColumn("id", idColumn()).addColumn("name", column("string"));
+    })
+    .alterTable("users", (t) => {
+      return t.alterColumn("name").nullable();
+    });
+});
+
+const resolver = createNamingResolver(testSchema, "test", suffixNamingStrategy);
+const nullableResolver = createNamingResolver(nullableSchema, "nullable", suffixNamingStrategy);
+const fkLaterSchema = schema("fk_later", (s) => {
+  return s
+    .addTable("users", (t) => {
+      return t.addColumn("id", idColumn()).addColumn("name", column("string"));
+    })
+    .addTable("posts", (t) => {
+      return t
+        .addColumn("id", idColumn())
+        .addColumn("title", column("string"))
+        .addColumn("authorId", referenceColumn());
+    })
+    .addReference("author", {
+      type: "one",
+      from: { table: "posts", column: "authorId" },
+      to: { table: "users", column: "id" },
+    });
+});
+
+const fkLaterResolver = createNamingResolver(fkLaterSchema, "fk_later", suffixNamingStrategy);
+
 describe("PreparedMigrations - PostgreSQL", () => {
   const coldKysely = createColdKysely("postgresql");
   const generator = new PostgresSQLGenerator(coldKysely, "postgresql");
+  const resolver = createNamingResolver(testSchema, "test", suffixNamingStrategy);
 
   test("compile migration 0 -> 1 (create users table)", () => {
     const statements = generator.compile(
@@ -55,7 +94,7 @@ describe("PreparedMigrations - PostgreSQL", () => {
           ],
         },
       ],
-      { toPhysical: (n) => `${n}_test`, toLogical: (n) => n.replace("_test", "") },
+      resolver,
     );
 
     expect(statements.length).toBe(1);
@@ -78,7 +117,7 @@ describe("PreparedMigrations - PostgreSQL", () => {
           ],
         },
       ],
-      { toPhysical: (n) => `${n}_test`, toLogical: (n) => n.replace("_test", "") },
+      resolver,
     );
 
     expect(statements.length).toBe(1);
@@ -98,12 +137,12 @@ describe("PreparedMigrations - PostgreSQL", () => {
           unique: false,
         },
       ],
-      { toPhysical: (n) => `${n}_test`, toLogical: (n) => n.replace("_test", "") },
+      resolver,
     );
 
     expect(statements.length).toBe(1);
     expect(statements[0].sql).toMatchInlineSnapshot(
-      `"create index "name_idx_users_test" on "users_test" ("name")"`,
+      `"create index "idx_users_name_idx_test_92db5054" on "users_test" ("name")"`,
     );
   });
 
@@ -122,11 +161,92 @@ describe("PreparedMigrations - PostgreSQL", () => {
       `"update "fragno_db_settings" set "value" = '2' where "key" = 'test_namespace.schema_version'"`,
     );
   });
+
+  test("compile uses custom naming strategy for columns and constraints", () => {
+    const customStrategy: SqlNamingStrategy = {
+      namespaceScope: "suffix",
+      namespaceToSchema: (namespace) => namespace,
+      tableName: (logicalTable, namespace) =>
+        namespace ? `tbl_${logicalTable}_${namespace}` : `tbl_${logicalTable}`,
+      columnName: (logicalColumn) => `col_${logicalColumn}`,
+      indexName: (logicalIndex, _table, namespace) =>
+        namespace ? `idx_custom_${logicalIndex}_${namespace}` : `idx_custom_${logicalIndex}`,
+      uniqueIndexName: (logicalIndex, _table, namespace) =>
+        namespace ? `uidx_custom_${logicalIndex}_${namespace}` : `uidx_custom_${logicalIndex}`,
+      foreignKeyName: ({ referenceName, namespace }) =>
+        namespace ? `fk_custom_${referenceName}_${namespace}` : `fk_custom_${referenceName}`,
+    };
+    const customResolver = createNamingResolver(testSchema, "custom", customStrategy);
+
+    const statements = generator.compile(
+      [
+        {
+          type: "create-table",
+          name: "users",
+          columns: [
+            { name: "id", type: "string", isNullable: false, role: "external-id" },
+            { name: "name", type: "string", isNullable: false, role: "regular" },
+          ],
+        },
+        {
+          type: "create-table",
+          name: "posts",
+          columns: [
+            { name: "id", type: "string", isNullable: false, role: "external-id" },
+            { name: "authorId", type: "bigint", isNullable: false, role: "reference" },
+          ],
+        },
+        {
+          type: "add-index",
+          table: "users",
+          name: "name_idx",
+          columns: ["name"],
+          unique: false,
+        },
+        {
+          type: "add-foreign-key",
+          table: "posts",
+          value: {
+            name: "author",
+            columns: ["authorId"],
+            referencedTable: "users",
+            referencedColumns: ["_internalId"],
+          },
+        },
+      ],
+      customResolver,
+    );
+
+    const sql = statements.map((stmt) => stmt.sql).join("\\n");
+    expect(sql).toContain(`create table "tbl_users_custom"`);
+    expect(sql).toContain(`"col_name"`);
+    expect(sql).toContain(`create index "idx_custom_name_idx_custom"`);
+    expect(sql).toContain(`add constraint "fk_custom_author_custom"`);
+  });
+
+  test("compile uses schema naming strategy for schema-scoped namespaces", () => {
+    const schemaResolver = createNamingResolver(testSchema, "tenant", schemaNamingStrategy);
+    const statements = generator.compile(
+      [
+        {
+          type: "create-table",
+          name: "users",
+          columns: [{ name: "id", type: "string", isNullable: false, role: "external-id" }],
+        },
+      ],
+      schemaResolver,
+    );
+
+    const sql = statements.map((stmt) => stmt.sql).join("\\n");
+    expect(sql).toContain(`CREATE SCHEMA IF NOT EXISTS "tenant"`);
+    expect(sql).toContain(`create table "tenant"."users"`);
+  });
 });
 
 describe("PreparedMigrations - SQLite FK Merging", () => {
   const coldKysely = createColdKysely("sqlite");
   const generator = new SQLiteSQLGenerator(coldKysely, "sqlite");
+  const resolver = createNamingResolver(testSchema, "test", suffixNamingStrategy);
 
   test("preprocess merges FK into create-table", () => {
     const operations = generator.preprocess([
@@ -191,7 +311,7 @@ describe("PreparedMigrations - SQLite FK Merging", () => {
           },
         },
       ],
-      { toPhysical: (n) => `${n}_test`, toLogical: (n) => n.replace("_test", "") },
+      resolver,
     );
 
     expect(statements.length).toBe(3);
@@ -200,7 +320,7 @@ describe("PreparedMigrations - SQLite FK Merging", () => {
       `"create table "users_test" ("id" text not null unique)"`,
     );
     expect(statements[2].sql).toMatchInlineSnapshot(
-      `"create table "posts_test" ("id" text not null unique, "authorId" integer not null, constraint "posts_users_author_fk" foreign key ("authorId") references "users_test" ("_internalId") on delete restrict on update restrict)"`,
+      `"create table "posts_test" ("id" text not null unique, "authorId" integer not null, foreign key ("authorId") references "users_test" ("_internalId") on delete restrict on update restrict)"`,
     );
   });
 
@@ -286,7 +406,7 @@ describe("PreparedMigrations - MySQL", () => {
     expect(statements.length).toBe(3);
     expect(statements[0].sql).toMatchInlineSnapshot(`"SET FOREIGN_KEY_CHECKS = 0"`);
     expect(statements[1].sql).toMatchInlineSnapshot(
-      `"create table \`users\` (\`_internalId\` bigint not null primary key auto_increment)"`,
+      `"create table \`users\` (\`_internalId\` bigint not null  auto_increment, constraint \`users__internalId\` primary key (\`_internalId\`))"`,
     );
     expect(statements[2].sql).toMatchInlineSnapshot(`"SET FOREIGN_KEY_CHECKS = 1"`);
   });
@@ -335,7 +455,7 @@ describe("PreparedMigrations - Integration", () => {
       schema: testSchema,
       namespace: "test",
       database: "postgresql",
-      mapper: createTableNameMapper("test"),
+      resolver,
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       driver: mockDriver as any,
     });
@@ -345,7 +465,7 @@ describe("PreparedMigrations - Integration", () => {
     expect(transactionStarted).toBe(true);
     expect(executedStatements.length).toBe(2);
     expect(executedStatements[0]).toMatchInlineSnapshot(
-      `"create table "users_test" ("id" varchar(30) not null unique, "name" text not null, "_internalId" bigserial not null primary key, "_version" integer default 0 not null)"`,
+      `"create table "users_test" ("id" varchar(128) not null unique, "name" text not null, "_internalId" bigserial not null primary key, "_version" integer default 0 not null)"`,
     );
     expect(executedStatements[1]).toMatchInlineSnapshot(
       `"insert into "fragno_db_settings" ("id", "key", "value") values ('BflimUWc1NbCMMDD9SM3gQ', 'test.schema_version', '1')"`,
@@ -379,7 +499,7 @@ describe("PreparedMigrations - Integration", () => {
       schema: testSchema,
       namespace: "test",
       database: "postgresql",
-      mapper: createTableNameMapper("test"),
+      resolver,
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       driver: mockDriver as any,
     });
@@ -404,7 +524,7 @@ describe("PreparedMigrations - Integration", () => {
       schema: testSchema,
       namespace: "test",
       database: "postgresql",
-      mapper: createTableNameMapper("test"),
+      resolver,
     });
 
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -426,7 +546,7 @@ describe("PreparedMigrations - Integration", () => {
       schema: testSchema,
       namespace: "test",
       database: "postgresql",
-      mapper: createTableNameMapper("test"),
+      resolver,
     });
 
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -462,7 +582,7 @@ describe("PreparedMigrations - Integration", () => {
       schema: testSchema,
       namespace: "test",
       database: "postgresql",
-      mapper: createTableNameMapper("test"),
+      resolver,
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       driver: mockDriver as any,
     });
@@ -478,7 +598,7 @@ describe("PreparedMigrations - Integration", () => {
       schema: testSchema,
       namespace: "test",
       database: "postgresql",
-      mapper: createTableNameMapper("test"),
+      resolver,
       // No driver provided
     });
 
@@ -494,18 +614,18 @@ describe("PreparedMigrations - Multi-step Migration Scenarios", () => {
       schema: testSchema,
       namespace: "test",
       database: "postgresql",
-      mapper: createTableNameMapper("test"),
+      resolver,
     });
 
     const sql = prepared.getSQL(0, 2, { updateVersionInMigration: true });
     expect(sql).toMatchInlineSnapshot(`
-      "create table "users_test" ("id" varchar(30) not null unique, "name" text not null, "_internalId" bigserial not null primary key, "_version" integer default 0 not null);
+      "create table "users_test" ("id" varchar(128) not null unique, "name" text not null, "_internalId" bigserial not null primary key, "_version" integer default 0 not null);
 
       alter table "users_test" add column "age" integer;
 
-      create index "name_idx_users_test" on "users_test" ("name");
+      create index "idx_users_name_idx_test_92db5054" on "users_test" ("name");
 
-      create index "age_idx_users_test" on "users_test" ("age");
+      create index "idx_users_age_idx_test_1c69311d" on "users_test" ("age");
 
       insert into "fragno_db_settings" ("id", "key", "value") values ('BflimUWc1NbCMMDD9SM3gQ', 'test.schema_version', '2');"
     `);
@@ -516,22 +636,22 @@ describe("PreparedMigrations - Multi-step Migration Scenarios", () => {
       schema: testSchema,
       namespace: "test",
       database: "postgresql",
-      mapper: createTableNameMapper("test"),
+      resolver,
     });
 
     const sql = prepared.getSQL(0, 4, { updateVersionInMigration: true });
     expect(sql).toMatchInlineSnapshot(`
-      "create table "users_test" ("id" varchar(30) not null unique, "name" text not null, "_internalId" bigserial not null primary key, "_version" integer default 0 not null);
+      "create table "users_test" ("id" varchar(128) not null unique, "name" text not null, "_internalId" bigserial not null primary key, "_version" integer default 0 not null);
 
       alter table "users_test" add column "age" integer;
 
-      create index "name_idx_users_test" on "users_test" ("name");
+      create index "idx_users_name_idx_test_92db5054" on "users_test" ("name");
 
-      create index "age_idx_users_test" on "users_test" ("age");
+      create index "idx_users_age_idx_test_1c69311d" on "users_test" ("age");
 
-      create table "posts_test" ("id" varchar(30) not null unique, "title" text not null, "authorId" bigint not null, "_internalId" bigserial not null primary key, "_version" integer default 0 not null);
+      create table "posts_test" ("id" varchar(128) not null unique, "title" text not null, "authorId" bigint not null, "_internalId" bigserial not null primary key, "_version" integer default 0 not null);
 
-      alter table "posts_test" add constraint "posts_users_author_fk" foreign key ("authorId") references "users_test" ("_internalId") on delete restrict on update restrict;
+      alter table "posts_test" add constraint "fk_posts_users_author_test_8d48035c" foreign key ("authorId") references "users_test" ("_internalId") on delete restrict on update restrict;
 
       insert into "fragno_db_settings" ("id", "key", "value") values ('BflimUWc1NbCMMDD9SM3gQ', 'test.schema_version', '4');"
     `);
@@ -542,16 +662,16 @@ describe("PreparedMigrations - Multi-step Migration Scenarios", () => {
       schema: testSchema,
       namespace: "test",
       database: "postgresql",
-      mapper: createTableNameMapper("test"),
+      resolver,
     });
 
     const sql = prepared.getSQL(1, 2, { updateVersionInMigration: true });
     expect(sql).toMatchInlineSnapshot(`
       "alter table "users_test" add column "age" integer;
 
-      create index "name_idx_users_test" on "users_test" ("name");
+      create index "idx_users_name_idx_test_92db5054" on "users_test" ("name");
 
-      create index "age_idx_users_test" on "users_test" ("age");
+      create index "idx_users_age_idx_test_1c69311d" on "users_test" ("age");
 
       update "fragno_db_settings" set "value" = '2' where "key" = 'test.schema_version';"
     `);
@@ -562,12 +682,12 @@ describe("PreparedMigrations - Multi-step Migration Scenarios", () => {
       schema: testSchema,
       namespace: "test",
       database: "postgresql",
-      mapper: createTableNameMapper("test"),
+      resolver,
     });
 
     const sql = prepared.getSQL(2, 3, { updateVersionInMigration: true });
     expect(sql).toMatchInlineSnapshot(`
-      "create table "posts_test" ("id" varchar(30) not null unique, "title" text not null, "authorId" bigint not null, "_internalId" bigserial not null primary key, "_version" integer default 0 not null);
+      "create table "posts_test" ("id" varchar(128) not null unique, "title" text not null, "authorId" bigint not null, "_internalId" bigserial not null primary key, "_version" integer default 0 not null);
 
       update "fragno_db_settings" set "value" = '3' where "key" = 'test.schema_version';"
     `);
@@ -578,7 +698,7 @@ describe("PreparedMigrations - Multi-step Migration Scenarios", () => {
       schema: testSchema,
       namespace: "test",
       database: "sqlite",
-      mapper: createTableNameMapper("test"),
+      resolver,
     });
 
     const sql = prepared.getSQL(0, 4, { updateVersionInMigration: true });
@@ -589,39 +709,53 @@ describe("PreparedMigrations - Multi-step Migration Scenarios", () => {
 
       alter table "users_test" add column "age" integer;
 
-      create index "name_idx_users_test" on "users_test" ("name");
+      create index "idx_users_name_idx_test_92db5054" on "users_test" ("name");
 
-      create index "age_idx_users_test" on "users_test" ("age");
+      create index "idx_users_age_idx_test_1c69311d" on "users_test" ("age");
 
-      create table "posts_test" ("id" text not null unique, "title" text not null, "authorId" integer not null, "_internalId" integer not null primary key autoincrement, "_version" integer default 0 not null, constraint "posts_users_author_fk" foreign key ("authorId") references "users_test" ("_internalId") on delete restrict on update restrict);
+      create table "posts_test" ("id" text not null unique, "title" text not null, "authorId" integer not null, "_internalId" integer not null primary key autoincrement, "_version" integer default 0 not null, foreign key ("authorId") references "users_test" ("_internalId") on delete restrict on update restrict);
 
       insert into "fragno_db_settings" ("id", "key", "value") values ('BflimUWc1NbCMMDD9SM3gQ', 'test.schema_version', '4');"
     `);
   });
 
+  test("SQLite: adding FK after table creation throws", () => {
+    const prepared = createPreparedMigrations({
+      schema: fkLaterSchema,
+      namespace: "fk_later",
+      database: "sqlite",
+      resolver: fkLaterResolver,
+    });
+
+    const previousVersion = fkLaterSchema.version - 1;
+    expect(() =>
+      prepared.getSQL(previousVersion, fkLaterSchema.version, { updateVersionInMigration: false }),
+    ).toThrow("SQLite doesn't support modifying foreign keys");
+  });
+
   test("MySQL: migration 0 -> 4 with FK checks disabled", () => {
     const prepared = createPreparedMigrations({
       schema: testSchema,
       namespace: "test",
       database: "mysql",
-      mapper: createTableNameMapper("test"),
+      resolver,
     });
 
     const sql = prepared.getSQL(0, 4, { updateVersionInMigration: true });
     expect(sql).toMatchInlineSnapshot(`
       "SET FOREIGN_KEY_CHECKS = 0;
 
-      create table \`users_test\` (\`id\` varchar(30) not null unique, \`name\` text not null, \`_internalId\` bigint not null primary key auto_increment, \`_version\` integer default 0 not null);
+      create table \`users_test\` (\`id\` varchar(128) not null unique, \`name\` text not null, \`_internalId\` bigint not null  auto_increment, \`_version\` integer default 0 not null, constraint \`users_test__internalId\` primary key (\`_internalId\`));
 
       alter table \`users_test\` add column \`age\` integer;
 
-      create index \`name_idx_users_test\` on \`users_test\` (\`name\`);
+      create index \`idx_users_name_idx_test_92db5054\` on \`users_test\` (\`name\`);
 
-      create index \`age_idx_users_test\` on \`users_test\` (\`age\`);
+      create index \`idx_users_age_idx_test_1c69311d\` on \`users_test\` (\`age\`);
 
-      create table \`posts_test\` (\`id\` varchar(30) not null unique, \`title\` text not null, \`authorId\` bigint not null, \`_internalId\` bigint not null primary key auto_increment, \`_version\` integer default 0 not null);
+      create table \`posts_test\` (\`id\` varchar(128) not null unique, \`title\` text not null, \`authorId\` bigint not null, \`_internalId\` bigint not null  auto_increment, \`_version\` integer default 0 not null, constraint \`posts_test__internalId\` primary key (\`_internalId\`));
 
-      alter table \`posts_test\` add constraint \`posts_users_author_fk\` foreign key (\`authorId\`) references \`users_test\` (\`_internalId\`) on delete restrict on update restrict;
+      alter table \`posts_test\` add constraint \`fk_posts_users_author_test_8d48035c\` foreign key (\`authorId\`) references \`users_test\` (\`_internalId\`) on delete restrict on update restrict;
 
       SET FOREIGN_KEY_CHECKS = 1;
 
@@ -629,12 +763,70 @@ describe("PreparedMigrations - Multi-step Migration Scenarios", () => {
     `);
   });
 
+  test("PostgreSQL: migration 1 -> 2 (make column nullable)", () => {
+    const prepared = createPreparedMigrations({
+      schema: nullableSchema,
+      namespace: "nullable",
+      database: "postgresql",
+      resolver: nullableResolver,
+    });
+
+    const sql = prepared.getSQL(1, 2, { updateVersionInMigration: false });
+    expect(sql).toMatchInlineSnapshot(
+      `"alter table "users_nullable" alter column "name" drop not null;"`,
+    );
+  });
+
+  test("MySQL: migration 1 -> 2 (make column nullable)", () => {
+    const prepared = createPreparedMigrations({
+      schema: nullableSchema,
+      namespace: "nullable",
+      database: "mysql",
+      resolver: nullableResolver,
+    });
+
+    const sql = prepared.getSQL(1, 2, { updateVersionInMigration: false });
+    expect(sql).toMatchInlineSnapshot(`
+      "SET FOREIGN_KEY_CHECKS = 0;
+
+      alter table \`users_nullable\` modify column \`name\` text;
+
+      SET FOREIGN_KEY_CHECKS = 1;"
+    `);
+  });
+
+  test("SQLite: migration 1 -> 2 (make column nullable)", () => {
+    const prepared = createPreparedMigrations({
+      schema: nullableSchema,
+      namespace: "nullable",
+      database: "sqlite",
+      resolver: nullableResolver,
+    });
+
+    const sql = prepared.getSQL(1, 2, { updateVersionInMigration: false });
+    expect(sql).toMatchInlineSnapshot(`
+      "PRAGMA defer_foreign_keys = ON;
+
+      PRAGMA foreign_keys = OFF;
+
+      create table "users_nullable__fragno_tmp_414fdd" ("id" text not null unique, "name" text, "_internalId" integer not null primary key autoincrement, "_version" integer default 0 not null);
+
+      insert into "users_nullable__fragno_tmp_414fdd" ("id", "name", "_internalId", "_version") select "id", "name", "_internalId", "_version" from "users_nullable";
+
+      drop table "users_nullable";
+
+      alter table "users_nullable__fragno_tmp_414fdd" rename to "users_nullable";
+
+      PRAGMA foreign_keys = ON;"
+    `);
+  });
+
   test("compile returns CompiledMigration with statements array", () => {
     const prepared = createPreparedMigrations({
       schema: testSchema,
       namespace: "test",
       database: "postgresql",
-      mapper: createTableNameMapper("test"),
+      resolver,
     });
 
     const compiled = prepared.compile(0, 2, { updateVersionInMigration: true });
@@ -649,13 +841,13 @@ describe("PreparedMigrations - Multi-step Migration Scenarios", () => {
       schema: testSchema,
       namespace: "test",
       database: "postgresql",
-      mapper: createTableNameMapper("test"),
+      resolver,
     });
 
     const sql = prepared.getSQL(0, 1, { updateVersionInMigration: false });
     expect(sql).not.toContain("fragno_db_settings");
     expect(sql).toMatchInlineSnapshot(
-      `"create table "users_test" ("id" varchar(30) not null unique, "name" text not null, "_internalId" bigserial not null primary key, "_version" integer default 0 not null);"`,
+      `"create table "users_test" ("id" varchar(128) not null unique, "name" text not null, "_internalId" bigserial not null primary key, "_version" integer default 0 not null);"`,
     );
   });
 });

package/src/adapters/generic-sql/migration/prepared-migrations.ts

@@ -1,15 +1,17 @@
+import type { Kysely } from "kysely";
+
+import { generateMigrationFromSchema } from "../../../migration-engine/auto-from-schema";
+import type { NamingResolver } from "../../../naming/sql-naming";
 import type { AnySchema } from "../../../schema/create";
 import type { SqlDriverAdapter } from "../../../sql-driver/sql-driver-adapter";
-import type { TableNameMapper } from "../../shared/table-name-mapper";
-import { generateMigrationFromSchema } from "../../../migration-engine/auto-from-schema";
+import type { DriverConfig, SupportedDatabase } from "../driver-config";
+import type { SQLiteStorageMode } from "../sqlite-storage";
 import { createColdKysely } from "./cold-kysely";
-import { type SQLGenerator } from "./sql-generator";
-import { SQLiteSQLGenerator } from "./dialect/sqlite";
-import { PostgresSQLGenerator } from "./dialect/postgres";
 import { MySQLSQLGenerator } from "./dialect/mysql";
+import { PostgresSQLGenerator } from "./dialect/postgres";
+import { SQLiteSQLGenerator } from "./dialect/sqlite";
 import { executeMigration, type CompiledMigration } from "./executor";
-import type { SupportedDatabase } from "../driver-config";
-import type { Kysely } from "kysely";
+import { type SQLGenerator } from "./sql-generator";
 /**
  * Options for executing a migration.
  */
@@ -85,7 +87,9 @@ export interface PreparedMigrationsConfig {
   schema: AnySchema;
   namespace: string;
   database: SupportedDatabase;
-  mapper?: TableNameMapper;
+  driverConfig?: DriverConfig;
+  sqliteStorageMode?: SQLiteStorageMode;
+  resolver?: NamingResolver;
   driver?: SqlDriverAdapter;
   /**
    * Whether to automatically update the schema version in the database after migration.
@@ -102,6 +106,8 @@ export function createPreparedMigrations(config: PreparedMigrationsConfig): Prep
     schema,
     namespace,
     database,
+    driverConfig,
+    sqliteStorageMode,
     driver,
     updateVersionInMigration: defaultUpdateVersion = true,
   } = config;
@@ -110,7 +116,7 @@ export function createPreparedMigrations(config: PreparedMigrationsConfig): Prep
   const coldKysely = createColdKysely(database);
 
   // Create the appropriate SQL generator for the database
-  const generator = createSQLGenerator(database, coldKysely);
+  const generator = createSQLGenerator(database, coldKysely, driverConfig, sqliteStorageMode);
 
   /**
    * Internal method to compile a migration for a given version range.
@@ -140,7 +146,7 @@ export function createPreparedMigrations(config: PreparedMigrationsConfig): Prep
     const operations = generateMigrationFromSchema(schema, fromVersion, toVersion);
 
     // Phase 2: Compile operations to SQL
-    const statements = generator.compile(operations, config.mapper);
+    const statements = generator.compile(operations, config.resolver);
 
     // Add version update SQL if requested
     if (updateVersionInMigration && toVersion !== fromVersion) {
@@ -202,13 +208,15 @@ function createSQLGenerator(
   database: SupportedDatabase,
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   coldKysely: Kysely<any>,
+  driverConfig?: DriverConfig,
+  sqliteStorageMode?: SQLiteStorageMode,
 ): SQLGenerator {
   switch (database) {
     case "sqlite":
-      return new SQLiteSQLGenerator(coldKysely, database);
+      return new SQLiteSQLGenerator(coldKysely, database, driverConfig, sqliteStorageMode);
     case "postgresql":
-      return new PostgresSQLGenerator(coldKysely, database);
+      return new PostgresSQLGenerator(coldKysely, database, driverConfig, sqliteStorageMode);
     case "mysql":
-      return new MySQLSQLGenerator(coldKysely, database);
+      return new MySQLSQLGenerator(coldKysely, database, driverConfig, sqliteStorageMode);
   }
 }