@fragno-dev/db 0.1.14 → 0.2.0

package/src/adapters/{kysely/migration/execute-mysql.test.ts → generic-sql/migration/dialect/mysql.test.ts}

@@ -1,28 +1,37 @@
-import { Kysely, MysqlDialect } from "kysely";
-import { describe, expect, it, beforeAll } from "vitest";
-import { execute } from "./execute";
-import type { MigrationOperation } from "../../../migration-engine/shared";
-import type { KyselyConfig } from "../kysely-adapter";
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-type KyselyAny = Kysely<any>;
-
-function assertSingleResult<T>(result: T | T[]): asserts result is T {
-  if (Array.isArray(result)) {
-    throw new Error("Expected single result, got array");
+import { describe, expect, it } from "vitest";
+import type { MigrationOperation } from "../../../../migration-engine/shared";
+import { createColdKysely } from "../cold-kysely";
+import { MySQLSQLGenerator } from "./mysql";
+
+describe("MySQLSQLGenerator", () => {
+  const coldKysely = createColdKysely("mysql");
+  const generator = new MySQLSQLGenerator(coldKysely, "mysql");
+
+  /**
+   * Helper to compile a single operation and extract the main SQL statement.
+   * MySQL wraps operations with FK checks, so the main statement is at index 1.
+   */
+  function compileOne(operation: MigrationOperation): string {
+    const statements = generator.compile([operation]);
+    // MySQL wraps with FK checks: [SET FK=0, ...operations..., SET FK=1]
+    expect(statements.length).toBeGreaterThanOrEqual(3);
+    expect(statements[0].sql).toBe("SET FOREIGN_KEY_CHECKS = 0");
+    expect(statements[statements.length - 1].sql).toBe("SET FOREIGN_KEY_CHECKS = 1");
+    return statements[1].sql;
   }
-}
 
-describe("execute() - MySQL", () => {
-  let db: KyselyAny;
-  let config: KyselyConfig;
-
-  beforeAll(async () => {
-    // Create a Kysely instance with a MysqlDialect, but not actually connected to a database
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    db = new Kysely({ dialect: new MysqlDialect({} as any) });
-    config = { db, provider: "mysql" };
-  });
+  /**
+   * Helper to compile a single operation and extract all main SQL statements.
+   * For alter-table operations that generate multiple statements.
+   */
+  function compileMany(operation: MigrationOperation): string[] {
+    const statements = generator.compile([operation]);
+    expect(statements.length).toBeGreaterThanOrEqual(2);
+    expect(statements[0].sql).toBe("SET FOREIGN_KEY_CHECKS = 0");
+    expect(statements[statements.length - 1].sql).toBe("SET FOREIGN_KEY_CHECKS = 1");
+    // Return everything except FK check statements
+    return statements.slice(1, -1).map((s) => s.sql);
+  }
 
   describe("create-table", () => {
     it("should generate SQL for simple table with columns", () => {
@@ -51,14 +60,8 @@ describe("execute() - MySQL", () => {
         ],
       };
 
-      const result = execute(operation, config, () => {
-        throw new Error("No custom operations");
-      });
-
-      assertSingleResult(result);
-
-      const compiled = result.compile();
-      expect(compiled.sql).toMatchInlineSnapshot(
+      const sql = compileOne(operation);
+      expect(sql).toMatchInlineSnapshot(
         `"create table \`users\` (\`id\` integer not null unique, \`name\` text not null, \`email\` text not null)"`,
       );
     });
@@ -80,15 +83,9 @@ describe("execute() - MySQL", () => {
         ],
       };
 
-      const result = execute(operation, config, () => {
-        throw new Error("No custom operations");
-      });
-
-      assertSingleResult(result);
-
-      const compiled = result.compile();
-      expect(compiled.sql).toMatchInlineSnapshot(
-        `"create table \`test_types\` (\`col_int\` integer not null unique, \`col_bigint\` bigint not null, \`col_decimal\` decimal not null, \`col_bool\` boolean not null, \`col_date\` date not null, \`col_timestamp\` timestamp not null, \`col_json\` json not null, \`col_binary\` longblob not null, \`col_varchar\` varchar(255) not null)"`,
+      const sql = compileOne(operation);
+      expect(sql).toMatchInlineSnapshot(
+        `"create table \`test_types\` (\`col_int\` integer not null unique, \`col_bigint\` bigint not null, \`col_decimal\` decimal not null, \`col_bool\` boolean not null, \`col_date\` date not null, \`col_timestamp\` datetime not null, \`col_json\` json not null, \`col_binary\` longblob not null, \`col_varchar\` varchar(255) not null)"`,
       );
     });
 
@@ -103,14 +100,8 @@ describe("execute() - MySQL", () => {
         ],
       };
 
-      const result = execute(operation, config, () => {
-        throw new Error("No custom operations");
-      });
-
-      assertSingleResult(result);
-
-      const compiled = result.compile();
-      expect(compiled.sql).toMatchInlineSnapshot(
+      const sql = compileOne(operation);
+      expect(sql).toMatchInlineSnapshot(
         `"create table \`nullable_test\` (\`id\` integer not null unique, \`optional_name\` text, \`optional_age\` integer)"`,
       );
     });
@@ -145,14 +136,9 @@ describe("execute() - MySQL", () => {
         ],
       };
 
-      const result = execute(operation, config, () => {
-        throw new Error("No custom operations");
-      });
-
-      assertSingleResult(result);
-
-      const compiled = result.compile();
-      expect(compiled.sql).toMatchInlineSnapshot(
+      const sql = compileOne(operation);
+      // Note: MySQL doesn't support defaults on TEXT columns, so 'status' won't have a default
+      expect(sql).toMatchInlineSnapshot(
         `"create table \`defaults_test\` (\`id\` integer not null unique, \`status\` text not null, \`count\` integer default 0 not null, \`is_active\` boolean default true not null)"`,
       );
     });
@@ -173,15 +159,9 @@ describe("execute() - MySQL", () => {
         ],
       };
 
-      const result = execute(operation, config, () => {
-        throw new Error("No custom operations");
-      });
-
-      assertSingleResult(result);
-
-      const compiled = result.compile();
-      expect(compiled.sql).toMatchInlineSnapshot(
-        `"create table \`timestamps_test\` (\`id\` integer not null unique, \`created_at\` timestamp default CURRENT_TIMESTAMP not null)"`,
+      const sql = compileOne(operation);
+      expect(sql).toMatchInlineSnapshot(
+        `"create table \`timestamps_test\` (\`id\` integer not null unique, \`created_at\` datetime default CURRENT_TIMESTAMP not null)"`,
       );
     });
 
@@ -196,15 +176,25 @@ describe("execute() - MySQL", () => {
         ],
       };
 
-      const result = execute(operation, config, () => {
-        throw new Error("No custom operations");
-      });
+      const sql = compileOne(operation);
+      expect(sql).toMatchInlineSnapshot(
+        `"create table \`posts\` (\`id\` integer not null unique, \`user_id\` integer not null, \`title\` text not null)"`,
+      );
+    });
 
-      assertSingleResult(result);
+    it("should generate SQL for table with internal-id column (auto_increment)", () => {
+      const operation: MigrationOperation = {
+        type: "create-table",
+        name: "users",
+        columns: [
+          { name: "_internalId", type: "bigint", isNullable: false, role: "internal-id" },
+          { name: "name", type: "string", isNullable: false, role: "regular" },
+        ],
+      };
 
-      const compiled = result.compile();
-      expect(compiled.sql).toMatchInlineSnapshot(
-        `"create table \`posts\` (\`id\` integer not null unique, \`user_id\` integer not null, \`title\` text not null)"`,
+      const sql = compileOne(operation);
+      expect(sql).toMatchInlineSnapshot(
+        `"create table \`users\` (\`_internalId\` bigint not null primary key auto_increment, \`name\` text not null)"`,
       );
     });
   });
@@ -217,16 +207,8 @@ describe("execute() - MySQL", () => {
         to: "new_name",
       };
 
-      const result = execute(operation, config, () => {
-        throw new Error("No custom operations");
-      });
-
-      assertSingleResult(result);
-
-      const compiled = result.compile();
-      expect(compiled.sql).toMatchInlineSnapshot(
-        `"alter table \`old_name\` rename to \`new_name\`"`,
-      );
+      const sql = compileOne(operation);
+      expect(sql).toMatchInlineSnapshot(`"alter table \`old_name\` rename to \`new_name\`"`);
     });
   });
 
@@ -237,14 +219,8 @@ describe("execute() - MySQL", () => {
         name: "to_drop",
       };
 
-      const result = execute(operation, config, () => {
-        throw new Error("No custom operations");
-      });
-
-      assertSingleResult(result);
-
-      const compiled = result.compile();
-      expect(compiled.sql).toMatchInlineSnapshot(`"drop table \`to_drop\`"`);
+      const sql = compileOne(operation);
+      expect(sql).toMatchInlineSnapshot(`"drop table \`to_drop\`"`);
     });
   });
 
@@ -266,17 +242,9 @@ describe("execute() - MySQL", () => {
         ],
       };
 
-      const results = execute(operation, config, () => {
-        throw new Error("No custom operations");
-      });
-
-      if (!Array.isArray(results)) {
-        throw new Error("Expected array of results");
-      }
-
-      expect(results).toHaveLength(1);
-      const compiled = results[0].compile();
-      expect(compiled.sql).toMatchInlineSnapshot(
+      const statements = compileMany(operation);
+      expect(statements).toHaveLength(1);
+      expect(statements[0]).toMatchInlineSnapshot(
         `"alter table \`test_table\` add column \`new_column\` text"`,
       );
     });
@@ -308,19 +276,12 @@ describe("execute() - MySQL", () => {
         ],
       };
 
-      const results = execute(operation, config, () => {
-        throw new Error("No custom operations");
-      });
-
-      if (!Array.isArray(results)) {
-        throw new Error("Expected array of results");
-      }
-
-      expect(results).toHaveLength(2);
-      expect(results[0].compile().sql).toMatchInlineSnapshot(
+      const statements = compileMany(operation);
+      expect(statements).toHaveLength(2);
+      expect(statements[0]).toMatchInlineSnapshot(
         `"alter table \`test_table\` add column \`col1\` text"`,
       );
-      expect(results[1].compile().sql).toMatchInlineSnapshot(
+      expect(statements[1]).toMatchInlineSnapshot(
         `"alter table \`test_table\` add column \`col2\` integer default 0 not null"`,
       );
     });
@@ -340,17 +301,9 @@ describe("execute() - MySQL", () => {
         ],
       };
 
-      const results = execute(operation, config, () => {
-        throw new Error("No custom operations");
-      });
-
-      if (!Array.isArray(results)) {
-        throw new Error("Expected array of results");
-      }
-
-      expect(results).toHaveLength(1);
-      const compiled = results[0].compile();
-      expect(compiled.sql).toMatchInlineSnapshot(
+      const statements = compileMany(operation);
+      expect(statements).toHaveLength(1);
+      expect(statements[0]).toMatchInlineSnapshot(
         `"alter table \`test_table\` rename column \`old_name\` to \`new_name\`"`,
       );
     });
@@ -369,24 +322,16 @@ describe("execute() - MySQL", () => {
         ],
       };
 
-      const results = execute(operation, config, () => {
-        throw new Error("No custom operations");
-      });
-
-      if (!Array.isArray(results)) {
-        throw new Error("Expected array of results");
-      }
-
-      expect(results).toHaveLength(1);
-      const compiled = results[0].compile();
-      expect(compiled.sql).toMatchInlineSnapshot(
+      const statements = compileMany(operation);
+      expect(statements).toHaveLength(1);
+      expect(statements[0]).toMatchInlineSnapshot(
         `"alter table \`test_table\` drop column \`to_drop\`"`,
       );
     });
   });
 
   describe("alter-table - update-column", () => {
-    it("should generate SQL to update column data type (MySQL doesn't use USING clause)", () => {
+    it("should generate SQL to update column data type (MySQL uses MODIFY COLUMN)", () => {
       const operation: MigrationOperation = {
         type: "alter-table",
         name: "test_table",
@@ -407,17 +352,9 @@ describe("execute() - MySQL", () => {
         ],
       };
 
-      const results = execute(operation, config, () => {
-        throw new Error("No custom operations");
-      });
-
-      if (!Array.isArray(results)) {
-        throw new Error("Expected array of results");
-      }
-
-      expect(results).toHaveLength(1);
-      const compiled = results[0].compile();
-      expect(compiled.sql).toMatchInlineSnapshot(
+      const statements = compileMany(operation);
+      expect(statements).toHaveLength(1);
+      expect(statements[0]).toMatchInlineSnapshot(
         `"alter table \`test_table\` modify column \`test_col\` integer"`,
       );
     });
@@ -443,17 +380,9 @@ describe("execute() - MySQL", () => {
         ],
       };
 
-      const results = execute(operation, config, () => {
-        throw new Error("No custom operations");
-      });
-
-      if (!Array.isArray(results)) {
-        throw new Error("Expected array of results");
-      }
-
-      expect(results).toHaveLength(1);
-      const compiled = results[0].compile();
-      expect(compiled.sql).toMatchInlineSnapshot(
+      const statements = compileMany(operation);
+      expect(statements).toHaveLength(1);
+      expect(statements[0]).toMatchInlineSnapshot(
         `"alter table \`test_table\` modify column \`test_col\` text not null"`,
       );
     });
@@ -479,17 +408,9 @@ describe("execute() - MySQL", () => {
         ],
       };
 
-      const results = execute(operation, config, () => {
-        throw new Error("No custom operations");
-      });
-
-      if (!Array.isArray(results)) {
-        throw new Error("Expected array of results");
-      }
-
-      expect(results).toHaveLength(1);
-      const compiled = results[0].compile();
-      expect(compiled.sql).toMatchInlineSnapshot(
+      const statements = compileMany(operation);
+      expect(statements).toHaveLength(1);
+      expect(statements[0]).toMatchInlineSnapshot(
         `"alter table \`test_table\` modify column \`test_col\` text"`,
       );
     });
@@ -516,17 +437,10 @@ describe("execute() - MySQL", () => {
         ],
       };
 
-      const results = execute(operation, config, () => {
-        throw new Error("No custom operations");
-      });
-
-      if (!Array.isArray(results)) {
-        throw new Error("Expected array of results");
-      }
-
-      expect(results).toHaveLength(1);
-      const compiled = results[0].compile();
-      expect(compiled.sql).toMatchInlineSnapshot(
+      const statements = compileMany(operation);
+      expect(statements).toHaveLength(1);
+      // Note: MySQL doesn't support defaults on TEXT columns
+      expect(statements[0]).toMatchInlineSnapshot(
         `"alter table \`test_table\` modify column \`test_col\` text not null"`,
       );
     });
@@ -552,17 +466,9 @@ describe("execute() - MySQL", () => {
         ],
       };
 
-      const results = execute(operation, config, () => {
-        throw new Error("No custom operations");
-      });
-
-      if (!Array.isArray(results)) {
-        throw new Error("Expected array of results");
-      }
-
-      expect(results).toHaveLength(1);
-      const compiled = results[0].compile();
-      expect(compiled.sql).toMatchInlineSnapshot(
+      const statements = compileMany(operation);
+      expect(statements).toHaveLength(1);
+      expect(statements[0]).toMatchInlineSnapshot(
         `"alter table \`test_table\` modify column \`test_col\` text"`,
       );
     });
@@ -589,16 +495,9 @@ describe("execute() - MySQL", () => {
         ],
       };
 
-      const results = execute(operation, config, () => {
-        throw new Error("No custom operations");
-      });
-
-      if (!Array.isArray(results)) {
-        throw new Error("Expected array of results");
-      }
-
-      expect(results).toHaveLength(1);
-      expect(results[0].compile().sql).toMatchInlineSnapshot(
+      const statements = compileMany(operation);
+      expect(statements).toHaveLength(1);
+      expect(statements[0]).toMatchInlineSnapshot(
         `"alter table \`test_table\` modify column \`test_col\` integer default 0 not null"`,
       );
     });
@@ -624,11 +523,7 @@ describe("execute() - MySQL", () => {
         ],
       };
 
-      expect(() => {
-        execute(operation, config, () => {
-          throw new Error("No custom operations");
-        });
-      }).toThrow(
+      expect(() => generator.compile([operation])).toThrow(
         "ID columns cannot be updated. Not every database supports updating primary keys and often requires workarounds.",
       );
     });
@@ -654,16 +549,9 @@ describe("execute() - MySQL", () => {
         ],
       };
 
-      const results = execute(operation, config, () => {
-        throw new Error("No custom operations");
-      });
-
-      if (!Array.isArray(results)) {
-        throw new Error("Expected array of results");
-      }
-
-      // No-op should return empty array
-      expect(results).toHaveLength(0);
+      const statements = compileMany(operation);
+      // No-op should return empty array (only FK check statements remain)
+      expect(statements).toHaveLength(0);
     });
 
     it("should generate SQL for timestamp default", () => {
@@ -688,18 +576,10 @@ describe("execute() - MySQL", () => {
         ],
       };
 
-      const results = execute(operation, config, () => {
-        throw new Error("No custom operations");
-      });
-
-      if (!Array.isArray(results)) {
-        throw new Error("Expected array of results");
-      }
-
-      expect(results).toHaveLength(1);
-      const compiled = results[0].compile();
-      expect(compiled.sql).toMatchInlineSnapshot(
-        `"alter table \`test_table\` modify column \`updated_at\` timestamp default CURRENT_TIMESTAMP not null"`,
+      const statements = compileMany(operation);
+      expect(statements).toHaveLength(1);
+      expect(statements[0]).toMatchInlineSnapshot(
+        `"alter table \`test_table\` modify column \`updated_at\` datetime default CURRENT_TIMESTAMP not null"`,
       );
     });
   });
@@ -717,14 +597,8 @@ describe("execute() - MySQL", () => {
         },
       };
 
-      const result = execute(operation, config, () => {
-        throw new Error("No custom operations");
-      });
-
-      assertSingleResult(result);
-
-      const compiled = result.compile();
-      expect(compiled.sql).toMatchInlineSnapshot(
+      const sql = compileOne(operation);
+      expect(sql).toMatchInlineSnapshot(
         `"alter table \`posts\` add constraint \`posts_user_id_fk\` foreign key (\`user_id\`) references \`users\` (\`id\`) on delete restrict on update restrict"`,
       );
     });
@@ -741,14 +615,8 @@ describe("execute() - MySQL", () => {
         },
       };
 
-      const result = execute(operation, config, () => {
-        throw new Error("No custom operations");
-      });
-
-      assertSingleResult(result);
-
-      const compiled = result.compile();
-      expect(compiled.sql).toMatchInlineSnapshot(
+      const sql = compileOne(operation);
+      expect(sql).toMatchInlineSnapshot(
         `"alter table \`posts\` add constraint \`posts_user_fk\` foreign key (\`org_id\`, \`user_id\`) references \`users\` (\`org_id\`, \`user_id\`) on delete restrict on update restrict"`,
       );
     });
@@ -762,14 +630,8 @@ describe("execute() - MySQL", () => {
         name: "posts_user_id_fk",
       };
 
-      const result = execute(operation, config, () => {
-        throw new Error("No custom operations");
-      });
-
-      assertSingleResult(result);
-
-      const compiled = result.compile();
-      expect(compiled.sql).toMatchInlineSnapshot(
+      const sql = compileOne(operation);
+      expect(sql).toMatchInlineSnapshot(
         `"alter table \`posts\` drop constraint \`posts_user_id_fk\`"`,
       );
     });
@@ -785,14 +647,8 @@ describe("execute() - MySQL", () => {
         unique: false,
       };
 
-      const result = execute(operation, config, () => {
-        throw new Error("No custom operations");
-      });
-
-      assertSingleResult(result);
-
-      const compiled = result.compile();
-      expect(compiled.sql).toMatchInlineSnapshot(
+      const sql = compileOne(operation);
+      expect(sql).toMatchInlineSnapshot(
         `"create index \`idx_email\` on \`test_table\` (\`email\`)"`,
       );
     });
@@ -806,14 +662,8 @@ describe("execute() - MySQL", () => {
         unique: true,
       };
 
-      const result = execute(operation, config, () => {
-        throw new Error("No custom operations");
-      });
-
-      assertSingleResult(result);
-
-      const compiled = result.compile();
-      expect(compiled.sql).toMatchInlineSnapshot(
+      const sql = compileOne(operation);
+      expect(sql).toMatchInlineSnapshot(
         `"create unique index \`idx_unique_email\` on \`test_table\` (\`email\`)"`,
       );
     });
@@ -827,14 +677,8 @@ describe("execute() - MySQL", () => {
         unique: false,
       };
 
-      const result = execute(operation, config, () => {
-        throw new Error("No custom operations");
-      });
-
-      assertSingleResult(result);
-
-      const compiled = result.compile();
-      expect(compiled.sql).toMatchInlineSnapshot(
+      const sql = compileOne(operation);
+      expect(sql).toMatchInlineSnapshot(
         `"create index \`idx_email_name\` on \`test_table\` (\`email\`, \`name\`)"`,
       );
     });
@@ -848,14 +692,8 @@ describe("execute() - MySQL", () => {
         unique: true,
       };
 
-      const result = execute(operation, config, () => {
-        throw new Error("No custom operations");
-      });
-
-      assertSingleResult(result);
-
-      const compiled = result.compile();
-      expect(compiled.sql).toMatchInlineSnapshot(
+      const sql = compileOne(operation);
+      expect(sql).toMatchInlineSnapshot(
         `"create unique index \`idx_unique_email_name\` on \`test_table\` (\`email\`, \`name\`)"`,
       );
     });
@@ -869,192 +707,99 @@ describe("execute() - MySQL", () => {
         name: "idx_email",
       };
 
-      const result = execute(operation, config, () => {
-        throw new Error("No custom operations");
-      });
-
-      assertSingleResult(result);
-
-      const compiled = result.compile();
-      expect(compiled.sql).toMatchInlineSnapshot(`"drop index if exists \`idx_email\`"`);
+      const sql = compileOne(operation);
+      expect(sql).toMatchInlineSnapshot(`"drop index if exists \`idx_email\` on \`test_table\`"`);
     });
   });
 
-  describe("custom operations", () => {
-    it("should handle custom operations via callback", () => {
-      const operation: MigrationOperation = {
-        type: "custom",
-        customType: "test-operation",
-        data: "test-data",
+  describe("complex migration scenarios", () => {
+    it("should generate correct SQL for full schema migration", () => {
+      // Create multiple operations in sequence
+      const createUsersOp: MigrationOperation = {
+        type: "create-table",
+        name: "users",
+        columns: [
+          { name: "id", type: "integer", isNullable: false, role: "external-id" },
+          { name: "email", type: "string", isNullable: false, role: "regular" },
+          { name: "name", type: "string", isNullable: false, role: "regular" },
+        ],
       };
 
-      let customCallbackCalled = false;
-
-      const result = execute(operation, config, (op) => {
-        customCallbackCalled = true;
-        expect(op).toEqual(operation);
-
-        // Return a kysely query
-        return db.schema.createTable("custom_table").addColumn("id", "integer");
-      });
-
-      expect(customCallbackCalled).toBe(true);
-
-      assertSingleResult(result);
-
-      const compiled = result.compile();
-      expect(compiled.sql).toContain("create table");
-      expect(compiled.sql).toContain("custom_table");
-    });
-
-    it("should support custom operations returning array of nodes", () => {
-      const operation: MigrationOperation = {
-        type: "custom",
-        customType: "multi-operation",
+      const addIndexOp: MigrationOperation = {
+        type: "add-index",
+        table: "users",
+        columns: ["email"],
+        name: "idx_unique_email",
+        unique: true,
       };
 
-      const results = execute(operation, config, () => {
-        return [
-          db.schema.createTable("table1").addColumn("id", "integer"),
-          db.schema.createTable("table2").addColumn("id", "integer"),
-        ];
-      });
-
-      if (!Array.isArray(results)) {
-        throw new Error("Expected array of results");
-      }
-
-      expect(results).toHaveLength(2);
-      expect(results[0].compile().sql).toContain("table1");
-      expect(results[1].compile().sql).toContain("table2");
-    });
-  });
+      const createPostsOp: MigrationOperation = {
+        type: "create-table",
+        name: "posts",
+        columns: [
+          { name: "id", type: "integer", isNullable: false, role: "external-id" },
+          { name: "user_id", type: "integer", isNullable: false, role: "reference" },
+          { name: "title", type: "string", isNullable: false, role: "regular" },
+          { name: "content", type: "string", isNullable: false, role: "regular" },
+        ],
+      };
 
-  describe("complex migration scenarios", () => {
-    it("should generate correct SQL for full schema migration", () => {
-      // 1. Create users table
-      const createUsers = execute(
-        {
-          type: "create-table",
-          name: "users",
-          columns: [
-            { name: "id", type: "integer", isNullable: false, role: "external-id" },
-            { name: "email", type: "string", isNullable: false, role: "regular" },
-            { name: "name", type: "string", isNullable: false, role: "regular" },
-          ],
-        },
-        config,
-        () => {
-          throw new Error("No custom operations");
+      const addFkOp: MigrationOperation = {
+        type: "add-foreign-key",
+        table: "posts",
+        value: {
+          name: "posts_user_id_fk",
+          columns: ["user_id"],
+          referencedTable: "users",
+          referencedColumns: ["id"],
         },
-      );
+      };
 
-      assertSingleResult(createUsers);
+      const alterPostsOp: MigrationOperation = {
+        type: "alter-table",
+        name: "posts",
+        value: [
+          {
+            type: "create-column",
+            value: {
+              name: "published",
+              type: "bool",
+              isNullable: false,
+              role: "regular",
+              default: { value: false },
+            },
+          },
+        ],
+      };
 
-      expect(createUsers.compile().sql).toMatchInlineSnapshot(
+      // Compile all operations together
+      const statements = generator.compile([
+        createUsersOp,
+        addIndexOp,
+        createPostsOp,
+        addFkOp,
+        alterPostsOp,
+      ]);
+
+      // Should have FK check wrapper + 5 operations
+      expect(statements.length).toBe(7);
+      expect(statements[0].sql).toBe("SET FOREIGN_KEY_CHECKS = 0");
+      expect(statements[1].sql).toMatchInlineSnapshot(
         `"create table \`users\` (\`id\` integer not null unique, \`email\` text not null, \`name\` text not null)"`,
       );
-
-      // 2. Add unique index on email
-      const addIndex = execute(
-        {
-          type: "add-index",
-          table: "users",
-          columns: ["email"],
-          name: "idx_unique_email",
-          unique: true,
-        },
-        config,
-        () => {
-          throw new Error("No custom operations");
-        },
-      );
-
-      assertSingleResult(addIndex);
-
-      expect(addIndex.compile().sql).toMatchInlineSnapshot(
+      expect(statements[2].sql).toMatchInlineSnapshot(
         `"create unique index \`idx_unique_email\` on \`users\` (\`email\`)"`,
       );
-
-      // 3. Create posts table
-      const createPosts = execute(
-        {
-          type: "create-table",
-          name: "posts",
-          columns: [
-            { name: "id", type: "integer", isNullable: false, role: "external-id" },
-            { name: "user_id", type: "integer", isNullable: false, role: "reference" },
-            { name: "title", type: "string", isNullable: false, role: "regular" },
-            { name: "content", type: "string", isNullable: false, role: "regular" },
-          ],
-        },
-        config,
-        () => {
-          throw new Error("No custom operations");
-        },
-      );
-
-      assertSingleResult(createPosts);
-
-      expect(createPosts.compile().sql).toMatchInlineSnapshot(
+      expect(statements[3].sql).toMatchInlineSnapshot(
         `"create table \`posts\` (\`id\` integer not null unique, \`user_id\` integer not null, \`title\` text not null, \`content\` text not null)"`,
       );
-
-      // 4. Add foreign key
-      const addFk = execute(
-        {
-          type: "add-foreign-key",
-          table: "posts",
-          value: {
-            name: "posts_user_id_fk",
-            columns: ["user_id"],
-            referencedTable: "users",
-            referencedColumns: ["id"],
-          },
-        },
-        config,
-        () => {
-          throw new Error("No custom operations");
-        },
-      );
-
-      assertSingleResult(addFk);
-
-      expect(addFk.compile().sql).toMatchInlineSnapshot(
+      expect(statements[4].sql).toMatchInlineSnapshot(
         `"alter table \`posts\` add constraint \`posts_user_id_fk\` foreign key (\`user_id\`) references \`users\` (\`id\`) on delete restrict on update restrict"`,
       );
-
-      // 5. Alter posts table to add a new column
-      const alterResults = execute(
-        {
-          type: "alter-table",
-          name: "posts",
-          value: [
-            {
-              type: "create-column",
-              value: {
-                name: "published",
-                type: "bool",
-                isNullable: false,
-                role: "regular",
-                default: { value: false },
-              },
-            },
-          ],
-        },
-        config,
-        () => {
-          throw new Error("No custom operations");
-        },
-      );
-
-      if (!Array.isArray(alterResults)) {
-        throw new Error("Expected array of results");
-      }
-
-      expect(alterResults[0].compile().sql).toMatchInlineSnapshot(
+      expect(statements[5].sql).toMatchInlineSnapshot(
         `"alter table \`posts\` add column \`published\` boolean default false not null"`,
       );
+      expect(statements[6].sql).toBe("SET FOREIGN_KEY_CHECKS = 1");
     });
 
     it("should handle multiple alter-table operations", () => {
@@ -1083,22 +828,15 @@ describe("execute() - MySQL", () => {
         ],
       };
 
-      const results = execute(operation, config, () => {
-        throw new Error("No custom operations");
-      });
-
-      if (!Array.isArray(results)) {
-        throw new Error("Expected array of results");
-      }
-
-      expect(results).toHaveLength(3);
-      expect(results[0].compile().sql).toMatchInlineSnapshot(
+      const statements = compileMany(operation);
+      expect(statements).toHaveLength(3);
+      expect(statements[0]).toMatchInlineSnapshot(
         `"alter table \`users\` add column \`age\` integer"`,
       );
-      expect(results[1].compile().sql).toMatchInlineSnapshot(
+      expect(statements[1]).toMatchInlineSnapshot(
         `"alter table \`users\` rename column \`name\` to \`full_name\`"`,
       );
-      expect(results[2].compile().sql).toMatchInlineSnapshot(
+      expect(statements[2]).toMatchInlineSnapshot(
         `"alter table \`users\` drop column \`old_field\`"`,
       );
     });
@@ -1112,14 +850,8 @@ describe("execute() - MySQL", () => {
         columns: [{ name: "id", type: "integer", isNullable: false, role: "external-id" }],
       };
 
-      const result = execute(operation, config, () => {
-        throw new Error("No custom operations");
-      });
-
-      assertSingleResult(result);
-
-      const compiled = result.compile();
-      expect(compiled.sql).toContain("`user-profiles`");
+      const sql = compileOne(operation);
+      expect(sql).toContain("`user-profiles`");
     });
 
     it("should handle column names with special characters", () => {
@@ -1132,17 +864,11 @@ describe("execute() - MySQL", () => {
         ],
       };
 
-      const result = execute(operation, config, () => {
-        throw new Error("No custom operations");
-      });
-
-      assertSingleResult(result);
-
-      const compiled = result.compile();
-      expect(compiled.sql).toContain("`user-name`");
+      const sql = compileOne(operation);
+      expect(sql).toContain("`user-name`");
     });
 
-    it("should properly escape string default values", () => {
+    it("should properly handle string default values (not applied for TEXT columns)", () => {
       const operation: MigrationOperation = {
         type: "create-table",
         name: "test",
@@ -1158,16 +884,148 @@ describe("execute() - MySQL", () => {
         ],
       };
 
-      const result = execute(operation, config, () => {
-        throw new Error("No custom operations");
-      });
+      const sql = compileOne(operation);
+      // MySQL doesn't support defaults on TEXT columns, so the default is not applied
+      expect(sql).toMatchInlineSnapshot(
+        `"create table \`test\` (\`id\` integer not null unique, \`status\` text not null)"`,
+      );
+    });
+  });
 
-      assertSingleResult(result);
+  describe("table name mapping", () => {
+    const mapper = {
+      toPhysical: (name: string) => `prefix_${name}`,
+      toLogical: (name: string) => name.replace("prefix_", ""),
+    };
 
-      const compiled = result.compile();
-      expect(compiled.sql).toMatchInlineSnapshot(
-        `"create table \`test\` (\`id\` integer not null unique, \`status\` text not null)"`,
+    it("should apply table name mapping to create-table", () => {
+      const operation: MigrationOperation = {
+        type: "create-table",
+        name: "users",
+        columns: [{ name: "id", type: "integer", isNullable: false, role: "external-id" }],
+      };
+
+      const statements = generator.compile([operation], mapper);
+      expect(statements[1].sql).toMatchInlineSnapshot(
+        `"create table \`prefix_users\` (\`id\` integer not null unique)"`,
+      );
+    });
+
+    it("should apply table name mapping to foreign keys", () => {
+      const operation: MigrationOperation = {
+        type: "add-foreign-key",
+        table: "posts",
+        value: {
+          name: "posts_user_id_fk",
+          columns: ["user_id"],
+          referencedTable: "users",
+          referencedColumns: ["id"],
+        },
+      };
+
+      const statements = generator.compile([operation], mapper);
+      expect(statements[1].sql).toMatchInlineSnapshot(
+        `"alter table \`prefix_posts\` add constraint \`posts_user_id_fk\` foreign key (\`user_id\`) references \`prefix_users\` (\`id\`) on delete restrict on update restrict"`,
+      );
+    });
+
+    it("should apply table name mapping to indexes", () => {
+      const operation: MigrationOperation = {
+        type: "add-index",
+        table: "users",
+        columns: ["email"],
+        name: "idx_email",
+        unique: true,
+      };
+
+      const statements = generator.compile([operation], mapper);
+      expect(statements[1].sql).toMatchInlineSnapshot(
+        `"create unique index \`idx_email_prefix_users\` on \`prefix_users\` (\`email\`)"`,
       );
     });
   });
+
+  describe("preprocessing", () => {
+    it("should wrap operations with FK checks disabled", () => {
+      const operations: MigrationOperation[] = [
+        {
+          type: "create-table",
+          name: "users",
+          columns: [{ name: "id", type: "string", isNullable: false, role: "external-id" }],
+        },
+      ];
+
+      const preprocessed = generator.preprocess(operations);
+      expect(preprocessed.length).toBe(3);
+      expect(preprocessed[0]).toEqual({ type: "custom", sql: "SET FOREIGN_KEY_CHECKS = 0" });
+      expect(preprocessed[1]).toEqual(operations[0]);
+      expect(preprocessed[2]).toEqual({ type: "custom", sql: "SET FOREIGN_KEY_CHECKS = 1" });
+    });
+
+    it("should return empty array for empty operations", () => {
+      const preprocessed = generator.preprocess([]);
+      expect(preprocessed).toHaveLength(0);
+    });
+  });
+
+  describe("getDefaultValue", () => {
+    it("should return undefined for TEXT column defaults", () => {
+      const defaultValue = generator.getDefaultValue({
+        name: "description",
+        type: "string",
+        isNullable: true,
+        role: "regular",
+        default: { value: "default text" },
+      });
+
+      expect(defaultValue).toBeUndefined();
+    });
+
+    it("should return literal value for non-TEXT columns", () => {
+      const defaultValue = generator.getDefaultValue({
+        name: "count",
+        type: "integer",
+        isNullable: false,
+        role: "regular",
+        default: { value: 42 },
+      });
+
+      expect(defaultValue).toBeDefined();
+    });
+
+    it("should return CURRENT_TIMESTAMP for dbSpecial: now", () => {
+      const defaultValue = generator.getDefaultValue({
+        name: "created_at",
+        type: "timestamp",
+        isNullable: false,
+        role: "regular",
+        default: { dbSpecial: "now" },
+      });
+
+      expect(defaultValue).toBeDefined();
+    });
+
+    it("should return undefined for runtime defaults", () => {
+      const defaultValue = generator.getDefaultValue({
+        name: "id",
+        type: "string",
+        isNullable: false,
+        role: "regular",
+        default: { runtime: "cuid" },
+      });
+
+      expect(defaultValue).toBeUndefined();
+    });
+
+    it("should return undefined when no default is set", () => {
+      const defaultValue = generator.getDefaultValue({
+        name: "name",
+        type: "string",
+        isNullable: false,
+        role: "regular",
+      });
+
+      expect(defaultValue).toBeUndefined();
+    });
+  });
 });