@fragno-dev/db 0.2.2 → 0.4.1

package/src/adapters/generic-sql/migration/dialect/sqlite.test.ts

@@ -1,5 +1,9 @@
 import { describe, expect, it } from "vitest";
+
 import type { MigrationOperation } from "../../../../migration-engine/shared";
+import { createNamingResolver, type SqlNamingStrategy } from "../../../../naming/sql-naming";
+import { column, idColumn, schema } from "../../../../schema/create";
+import { sqliteStoragePrisma } from "../../sqlite-storage";
 import { createColdKysely } from "../cold-kysely";
 import { SQLiteSQLGenerator } from "./sqlite";
 
@@ -7,6 +11,13 @@ describe("SQLiteSQLGenerator", () => {
   const coldKysely = createColdKysely("sqlite");
   const generator = new SQLiteSQLGenerator(coldKysely, "sqlite");
 
+  const prismaGenerator = new SQLiteSQLGenerator(
+    coldKysely,
+    "sqlite",
+    undefined,
+    sqliteStoragePrisma,
+  );
+
   /**
    * Helper to compile a single operation and extract the main SQL statement.
    * SQLite preprocessing adds PRAGMA statement, so main statement is at index 1.
@@ -158,7 +169,25 @@ describe("SQLiteSQLGenerator", () => {
 
       const sql = compileOne(operation);
       expect(sql).toMatchInlineSnapshot(
-        `"create table "timestamps_test" ("id" integer not null unique, "created_at" integer default CURRENT_TIMESTAMP not null)"`,
+        `"create table "timestamps_test" ("id" integer not null unique, "created_at" integer default (cast((julianday('now') - 2440587.5)*86400000 as integer)) not null)"`,
+      );
+    });
+
+    it("should use text for timestamp/date in prisma storage", () => {
+      const operation: MigrationOperation = {
+        type: "create-table",
+        name: "prisma_timestamps",
+        columns: [
+          { name: "id", type: "integer", isNullable: false, role: "external-id" },
+          { name: "created_at", type: "timestamp", isNullable: false, role: "regular" },
+          { name: "published_on", type: "date", isNullable: false, role: "regular" },
+        ],
+      };
+
+      const statements = prismaGenerator.compile([operation]);
+      expect(statements[0].sql).toBe("PRAGMA defer_foreign_keys = ON");
+      expect(statements[1].sql).toMatchInlineSnapshot(
+        `"create table "prisma_timestamps" ("id" integer not null unique, "created_at" text not null, "published_on" text not null)"`,
       );
     });
 
@@ -329,6 +358,542 @@ describe("SQLiteSQLGenerator", () => {
   });
 
   describe("alter-table - update-column", () => {
+    it("should not rename the original table to a temp name during recreation", () => {
+      const operation: MigrationOperation = {
+        type: "alter-table",
+        name: "test_table",
+        value: [
+          {
+            type: "update-column",
+            name: "test_col",
+            value: {
+              name: "test_col",
+              type: "string",
+              isNullable: true,
+              role: "regular",
+            },
+            updateDataType: false,
+            updateNullable: true,
+            updateDefault: false,
+          },
+        ],
+        metadata: {
+          recreateTable: {
+            columns: [
+              {
+                name: "id",
+                type: "string",
+                isNullable: false,
+                role: "external-id",
+              },
+              {
+                name: "test_col",
+                type: "string",
+                isNullable: true,
+                role: "regular",
+              },
+              {
+                name: "_internalId",
+                type: "bigint",
+                isNullable: false,
+                role: "internal-id",
+              },
+              {
+                name: "_version",
+                type: "integer",
+                isNullable: false,
+                role: "version",
+                default: { value: 0 },
+              },
+            ],
+            copyColumns: ["id", "test_col", "_internalId", "_version"],
+            indexes: [],
+            foreignKeys: [],
+          },
+        },
+      };
+
+      const sql = compileMany(operation).join("\n");
+      expect(sql).toMatchInlineSnapshot(`
+        "PRAGMA foreign_keys = OFF
+        create table "test_table__fragno_tmp_e1aa88" ("id" text not null unique, "test_col" text, "_internalId" integer not null primary key autoincrement, "_version" integer default 0 not null)
+        insert into "test_table__fragno_tmp_e1aa88" ("id", "test_col", "_internalId", "_version") select "id", "test_col", "_internalId", "_version" from "test_table"
+        drop table "test_table"
+        alter table "test_table__fragno_tmp_e1aa88" rename to "test_table"
+        PRAGMA foreign_keys = ON"
+      `);
+    });
+
+    it("should recreate table when updating nullable constraint", () => {
+      const operation: MigrationOperation = {
+        type: "alter-table",
+        name: "test_table",
+        value: [
+          {
+            type: "update-column",
+            name: "test_col",
+            value: {
+              name: "test_col",
+              type: "string",
+              isNullable: true,
+              role: "regular",
+            },
+            updateDataType: false,
+            updateNullable: true,
+            updateDefault: false,
+          },
+        ],
+        metadata: {
+          recreateTable: {
+            columns: [
+              {
+                name: "id",
+                type: "string",
+                isNullable: false,
+                role: "external-id",
+              },
+              {
+                name: "test_col",
+                type: "string",
+                isNullable: true,
+                role: "regular",
+              },
+              {
+                name: "_internalId",
+                type: "bigint",
+                isNullable: false,
+                role: "internal-id",
+              },
+              {
+                name: "_version",
+                type: "integer",
+                isNullable: false,
+                role: "version",
+                default: { value: 0 },
+              },
+            ],
+            copyColumns: ["id", "test_col", "_internalId", "_version"],
+            indexes: [
+              {
+                name: "idx_test_col",
+                columns: ["test_col"],
+                unique: false,
+              },
+            ],
+            foreignKeys: [],
+          },
+        },
+      };
+
+      const sql = compileMany(operation).join("\n");
+      expect(sql).toMatchInlineSnapshot(`
+        "PRAGMA foreign_keys = OFF
+        create table "test_table__fragno_tmp_e1aa88" ("id" text not null unique, "test_col" text, "_internalId" integer not null primary key autoincrement, "_version" integer default 0 not null)
+        insert into "test_table__fragno_tmp_e1aa88" ("id", "test_col", "_internalId", "_version") select "id", "test_col", "_internalId", "_version" from "test_table"
+        drop table "test_table"
+        alter table "test_table__fragno_tmp_e1aa88" rename to "test_table"
+        create index "idx_test_col" on "test_table" ("test_col")
+        PRAGMA foreign_keys = ON"
+      `);
+    });
+
+    it("should preserve rename and drop operations during recreation", () => {
+      const operation: MigrationOperation = {
+        type: "alter-table",
+        name: "test_table",
+        value: [
+          {
+            type: "update-column",
+            name: "title",
+            value: {
+              name: "title",
+              type: "string",
+              isNullable: true,
+              role: "regular",
+            },
+            updateDataType: false,
+            updateNullable: true,
+            updateDefault: false,
+          },
+          {
+            type: "rename-column",
+            from: "title",
+            to: "headline",
+          },
+          {
+            type: "drop-column",
+            name: "old_field",
+          },
+        ],
+        metadata: {
+          recreateTable: {
+            columns: [
+              {
+                name: "id",
+                type: "string",
+                isNullable: false,
+                role: "external-id",
+              },
+              {
+                name: "title",
+                type: "string",
+                isNullable: true,
+                role: "regular",
+              },
+              {
+                name: "old_field",
+                type: "string",
+                isNullable: true,
+                role: "regular",
+              },
+              {
+                name: "_internalId",
+                type: "bigint",
+                isNullable: false,
+                role: "internal-id",
+              },
+              {
+                name: "_version",
+                type: "integer",
+                isNullable: false,
+                role: "version",
+                default: { value: 0 },
+              },
+            ],
+            copyColumns: ["id", "title", "old_field", "_internalId", "_version"],
+            indexes: [
+              {
+                name: "idx_title",
+                columns: ["title"],
+                unique: false,
+              },
+              {
+                name: "idx_old_field",
+                columns: ["old_field"],
+                unique: false,
+              },
+            ],
+            foreignKeys: [],
+          },
+        },
+      };
+
+      const sql = compileMany(operation).join("\n");
+      expect(sql).toMatchInlineSnapshot(`
+        "PRAGMA foreign_keys = OFF
+        create table "test_table__fragno_tmp_e1aa88" ("id" text not null unique, "headline" text, "_internalId" integer not null primary key autoincrement, "_version" integer default 0 not null)
+        insert into "test_table__fragno_tmp_e1aa88" ("id", "headline", "_internalId", "_version") select "id", "title", "_internalId", "_version" from "test_table"
+        drop table "test_table"
+        alter table "test_table__fragno_tmp_e1aa88" rename to "test_table"
+        create index "idx_title" on "test_table" ("headline")
+        PRAGMA foreign_keys = ON"
+      `);
+    });
+
+    it("should update foreign keys and indexes when rename/drop are applied during recreation", () => {
+      const operation: MigrationOperation = {
+        type: "alter-table",
+        name: "test_table",
+        value: [
+          {
+            type: "update-column",
+            name: "obsolete",
+            value: {
+              name: "obsolete",
+              type: "string",
+              isNullable: false,
+              role: "regular",
+            },
+            updateDataType: false,
+            updateNullable: true,
+            updateDefault: false,
+          },
+          {
+            type: "rename-column",
+            from: "author_id",
+            to: "writer_id",
+          },
+          {
+            type: "drop-column",
+            name: "obsolete",
+          },
+        ],
+        metadata: {
+          recreateTable: {
+            columns: [
+              {
+                name: "id",
+                type: "string",
+                isNullable: false,
+                role: "external-id",
+              },
+              {
+                name: "author_id",
+                type: "integer",
+                isNullable: false,
+                role: "reference",
+              },
+              {
+                name: "obsolete",
+                type: "string",
+                isNullable: true,
+                role: "regular",
+              },
+              {
+                name: "_internalId",
+                type: "bigint",
+                isNullable: false,
+                role: "internal-id",
+              },
+              {
+                name: "_version",
+                type: "integer",
+                isNullable: false,
+                role: "version",
+                default: { value: 0 },
+              },
+            ],
+            copyColumns: ["id", "author_id", "obsolete", "_internalId", "_version"],
+            indexes: [
+              {
+                name: "idx_author",
+                columns: ["author_id"],
+                unique: false,
+              },
+              {
+                name: "idx_obsolete",
+                columns: ["obsolete"],
+                unique: false,
+              },
+            ],
+            foreignKeys: [
+              {
+                name: "test_users_author_fk",
+                columns: ["author_id"],
+                referencedTable: "users",
+                referencedColumns: ["id"],
+              },
+            ],
+          },
+        },
+      };
+
+      const sql = compileMany(operation).join("\n");
+      expect(sql).toMatchInlineSnapshot(`
+        "PRAGMA foreign_keys = OFF
+        create table "test_table__fragno_tmp_e1aa88" ("id" text not null unique, "writer_id" integer not null, "_internalId" integer not null primary key autoincrement, "_version" integer default 0 not null, foreign key ("writer_id") references "users" ("id") on delete restrict on update restrict)
+        insert into "test_table__fragno_tmp_e1aa88" ("id", "writer_id", "_internalId", "_version") select "id", "author_id", "_internalId", "_version" from "test_table"
+        drop table "test_table"
+        alter table "test_table__fragno_tmp_e1aa88" rename to "test_table"
+        create index "idx_author" on "test_table" ("writer_id")
+        PRAGMA foreign_keys = ON"
+      `);
+    });
+
+    it("should honor copy column mappings during recreation", () => {
+      const operation: MigrationOperation = {
+        type: "alter-table",
+        name: "test_table",
+        value: [
+          {
+            type: "update-column",
+            name: "old_name",
+            value: {
+              name: "old_name",
+              type: "string",
+              isNullable: true,
+              role: "regular",
+            },
+            updateDataType: false,
+            updateNullable: true,
+            updateDefault: false,
+          },
+        ],
+        metadata: {
+          recreateTable: {
+            columns: [
+              {
+                name: "id",
+                type: "string",
+                isNullable: false,
+                role: "external-id",
+              },
+              {
+                name: "new_name",
+                type: "string",
+                isNullable: true,
+                role: "regular",
+              },
+              {
+                name: "_internalId",
+                type: "bigint",
+                isNullable: false,
+                role: "internal-id",
+              },
+              {
+                name: "_version",
+                type: "integer",
+                isNullable: false,
+                role: "version",
+                default: { value: 0 },
+              },
+            ],
+            copyColumns: ["id", { from: "old_name", to: "new_name" }, "_internalId", "_version"],
+            indexes: [],
+            foreignKeys: [],
+          },
+        },
+      };
+
+      const sql = compileMany(operation).join("\n");
+      expect(sql).toMatchInlineSnapshot(`
+        "PRAGMA foreign_keys = OFF
+        create table "test_table__fragno_tmp_e1aa88" ("id" text not null unique, "new_name" text, "_internalId" integer not null primary key autoincrement, "_version" integer default 0 not null)
+        insert into "test_table__fragno_tmp_e1aa88" ("id", "new_name", "_internalId", "_version") select "id", "old_name", "_internalId", "_version" from "test_table"
+        drop table "test_table"
+        alter table "test_table__fragno_tmp_e1aa88" rename to "test_table"
+        PRAGMA foreign_keys = ON"
+      `);
+    });
+
+    it("should omit data copy when no copy columns are provided", () => {
+      const operation: MigrationOperation = {
+        type: "alter-table",
+        name: "test_table",
+        value: [
+          {
+            type: "update-column",
+            name: "test_col",
+            value: {
+              name: "test_col",
+              type: "string",
+              isNullable: true,
+              role: "regular",
+            },
+            updateDataType: false,
+            updateNullable: true,
+            updateDefault: false,
+          },
+        ],
+        metadata: {
+          recreateTable: {
+            columns: [
+              {
+                name: "id",
+                type: "string",
+                isNullable: false,
+                role: "external-id",
+              },
+              {
+                name: "test_col",
+                type: "string",
+                isNullable: true,
+                role: "regular",
+              },
+              {
+                name: "_internalId",
+                type: "bigint",
+                isNullable: false,
+                role: "internal-id",
+              },
+              {
+                name: "_version",
+                type: "integer",
+                isNullable: false,
+                role: "version",
+                default: { value: 0 },
+              },
+            ],
+            copyColumns: [],
+            indexes: [],
+            foreignKeys: [],
+          },
+        },
+      };
+
+      const sql = compileMany(operation).join("\n");
+      expect(sql).toMatchInlineSnapshot(`
+        "PRAGMA foreign_keys = OFF
+        create table "test_table__fragno_tmp_e1aa88" ("id" text not null unique, "test_col" text, "_internalId" integer not null primary key autoincrement, "_version" integer default 0 not null)
+        drop table "test_table"
+        alter table "test_table__fragno_tmp_e1aa88" rename to "test_table"
+        PRAGMA foreign_keys = ON"
+      `);
+    });
+
+    it("should recreate unique indexes after table recreation", () => {
+      const operation: MigrationOperation = {
+        type: "alter-table",
+        name: "test_table",
+        value: [
+          {
+            type: "update-column",
+            name: "test_col",
+            value: {
+              name: "test_col",
+              type: "string",
+              isNullable: true,
+              role: "regular",
+            },
+            updateDataType: false,
+            updateNullable: true,
+            updateDefault: false,
+          },
+        ],
+        metadata: {
+          recreateTable: {
+            columns: [
+              {
+                name: "id",
+                type: "string",
+                isNullable: false,
+                role: "external-id",
+              },
+              {
+                name: "test_col",
+                type: "string",
+                isNullable: true,
+                role: "regular",
+              },
+              {
+                name: "_internalId",
+                type: "bigint",
+                isNullable: false,
+                role: "internal-id",
+              },
+              {
+                name: "_version",
+                type: "integer",
+                isNullable: false,
+                role: "version",
+                default: { value: 0 },
+              },
+            ],
+            copyColumns: ["id", "test_col", "_internalId", "_version"],
+            indexes: [
+              {
+                name: "uidx_test_col",
+                columns: ["test_col"],
+                unique: true,
+              },
+            ],
+            foreignKeys: [],
+          },
+        },
+      };
+
+      const sql = compileMany(operation).join("\n");
+      expect(sql).toMatchInlineSnapshot(`
+        "PRAGMA foreign_keys = OFF
+        create table "test_table__fragno_tmp_e1aa88" ("id" text not null unique, "test_col" text, "_internalId" integer not null primary key autoincrement, "_version" integer default 0 not null)
+        insert into "test_table__fragno_tmp_e1aa88" ("id", "test_col", "_internalId", "_version") select "id", "test_col", "_internalId", "_version" from "test_table"
+        drop table "test_table"
+        alter table "test_table__fragno_tmp_e1aa88" rename to "test_table"
+        create unique index "uidx_test_col" on "test_table" ("test_col")
+        PRAGMA foreign_keys = ON"
+      `);
+    });
+
     it("should throw error when trying to update column (SQLite limitation)", () => {
       const operation: MigrationOperation = {
         type: "alter-table",
@@ -480,6 +1045,30 @@ describe("SQLiteSQLGenerator", () => {
       );
     });
 
+    it("should throw error when add-foreign-key targets an existing table in a batch", () => {
+      const operations: MigrationOperation[] = [
+        {
+          type: "create-table",
+          name: "users",
+          columns: [{ name: "id", type: "integer", isNullable: false, role: "external-id" }],
+        },
+        {
+          type: "add-foreign-key",
+          table: "posts",
+          value: {
+            name: "posts_user_id_fk",
+            columns: ["user_id"],
+            referencedTable: "users",
+            referencedColumns: ["id"],
+          },
+        },
+      ];
+
+      expect(() => generator.compile(operations)).toThrow(
+        "SQLite doesn't support modifying foreign keys",
+      );
+    });
+
     it("should throw error for composite foreign key", () => {
       const operation: MigrationOperation = {
         type: "add-foreign-key",
@@ -504,6 +1093,7 @@ describe("SQLiteSQLGenerator", () => {
         type: "drop-foreign-key",
         table: "posts",
         name: "posts_user_id_fk",
+        referencedTable: "users",
       };
 
       expect(() => generator.compile([operation])).toThrow(
@@ -913,6 +1503,139 @@ describe("SQLiteSQLGenerator", () => {
       }
     });
 
+    it("should preserve create-table metadata when merging inline foreign keys", () => {
+      const operations: MigrationOperation[] = [
+        {
+          type: "create-table",
+          name: "posts",
+          columns: [
+            { name: "id", type: "integer", isNullable: false, role: "internal-id" },
+            { name: "author_id", type: "integer", isNullable: false, role: "reference" },
+            { name: "org_id", type: "integer", isNullable: false, role: "reference" },
+          ],
+          metadata: {
+            preserve: "keep",
+            inlineForeignKeys: [
+              {
+                name: "posts_orgs_org_fk",
+                columns: ["org_id"],
+                referencedTable: "orgs",
+                referencedColumns: ["id"],
+              },
+            ],
+          },
+        },
+        {
+          type: "add-foreign-key",
+          table: "posts",
+          value: {
+            name: "posts_users_author_fk",
+            columns: ["author_id"],
+            referencedTable: "users",
+            referencedColumns: ["id"],
+          },
+        },
+      ];
+
+      const preprocessed = generator.preprocess(operations);
+
+      expect(preprocessed).toHaveLength(2);
+      expect(preprocessed[0]).toEqual({ type: "custom", sql: "PRAGMA defer_foreign_keys = ON" });
+      expect(preprocessed[1]).toMatchObject({
+        type: "create-table",
+        name: "posts",
+      });
+
+      if (preprocessed[1].type === "create-table") {
+        const metadata = preprocessed[1].metadata as {
+          preserve?: string;
+          inlineForeignKeys?: {
+            name: string;
+            columns: string[];
+            referencedTable: string;
+            referencedColumns: string[];
+          }[];
+        };
+        expect(metadata?.preserve).toBe("keep");
+        expect(metadata?.inlineForeignKeys).toHaveLength(2);
+        expect(metadata?.inlineForeignKeys?.[0].name).toBe("posts_orgs_org_fk");
+        expect(metadata?.inlineForeignKeys?.[1].name).toBe("posts_users_author_fk");
+      }
+    });
+
+    it("should lift FK columns from alter-table into create-table", () => {
+      const operations: MigrationOperation[] = [
+        {
+          type: "create-table",
+          name: "session",
+          columns: [
+            { name: "id", type: "integer", isNullable: false, role: "internal-id" },
+            { name: "user_id", type: "integer", isNullable: false, role: "reference" },
+          ],
+        },
+        {
+          type: "alter-table",
+          name: "session",
+          value: [
+            {
+              type: "create-column",
+              value: {
+                name: "active_org_id",
+                type: "integer",
+                isNullable: true,
+                role: "reference",
+              },
+            },
+          ],
+        },
+        {
+          type: "create-table",
+          name: "organization",
+          columns: [{ name: "id", type: "integer", isNullable: false, role: "internal-id" }],
+        },
+        {
+          type: "add-foreign-key",
+          table: "session",
+          value: {
+            name: "session_org_fk",
+            columns: ["active_org_id"],
+            referencedTable: "organization",
+            referencedColumns: ["id"],
+          },
+        },
+      ];
+
+      const preprocessed = generator.preprocess(operations);
+
+      expect(preprocessed).toHaveLength(3);
+      expect(preprocessed.some((op) => op.type === "alter-table")).toBe(false);
+
+      const sessionOp = preprocessed[1];
+      expect(sessionOp).toMatchObject({
+        type: "create-table",
+        name: "session",
+      });
+
+      if (sessionOp.type === "create-table") {
+        expect(sessionOp.columns.some((col) => col.name === "active_org_id")).toBe(true);
+        const metadata = sessionOp.metadata as {
+          inlineForeignKeys?: {
+            name: string;
+            columns: string[];
+            referencedTable: string;
+            referencedColumns: string[];
+          }[];
+        };
+        expect(metadata?.inlineForeignKeys).toHaveLength(1);
+        expect(metadata?.inlineForeignKeys?.[0]).toMatchObject({
+          name: "session_org_fk",
+          columns: ["active_org_id"],
+          referencedTable: "organization",
+          referencedColumns: ["id"],
+        });
+      }
+    });
+
     it("should generate SQL with inline foreign key constraints", () => {
       const operations: MigrationOperation[] = [
         {
@@ -949,13 +1672,77 @@ describe("SQLiteSQLGenerator", () => {
 
       // Posts table should contain inline FK constraint
       const postsSql = statements[2].sql;
-      expect(postsSql).toContain("posts_users_author_fk");
       expect(postsSql).toContain("foreign key");
       expect(postsSql).toContain("author_id");
       expect(postsSql).toContain("references");
       expect(postsSql).toContain("users");
     });
 
+    it("should emit full SQL with pragma and merged inline foreign keys", () => {
+      const operations: MigrationOperation[] = [
+        {
+          type: "create-table",
+          name: "users",
+          columns: [{ name: "id", type: "bigint", isNullable: false, role: "internal-id" }],
+        },
+        {
+          type: "create-table",
+          name: "posts",
+          columns: [
+            { name: "id", type: "bigint", isNullable: false, role: "internal-id" },
+            { name: "author_id", type: "integer", isNullable: false, role: "reference" },
+          ],
+        },
+        {
+          type: "add-foreign-key",
+          table: "posts",
+          value: {
+            name: "posts_users_author_fk",
+            columns: ["author_id"],
+            referencedTable: "users",
+            referencedColumns: ["id"],
+          },
+        },
+      ];
+
+      const sql = generator
+        .compile(operations)
+        .map((statement) => statement.sql)
+        .join("\n");
+      expect(sql).toMatchInlineSnapshot(`
+        "PRAGMA defer_foreign_keys = ON
+        create table "users" ("id" integer not null primary key autoincrement)
+        create table "posts" ("id" integer not null primary key autoincrement, "author_id" integer not null, foreign key ("author_id") references "users" ("id") on delete restrict on update restrict)"
+      `);
+    });
+
+    it("should strip constraint names from inline foreign keys in create-table SQL", () => {
+      const operation: MigrationOperation = {
+        type: "create-table",
+        name: "posts",
+        columns: [
+          { name: "id", type: "integer", isNullable: false, role: "external-id" },
+          { name: "author_id", type: "integer", isNullable: false, role: "reference" },
+        ],
+        metadata: {
+          inlineForeignKeys: [
+            {
+              name: "posts_users_author_fk",
+              columns: ["author_id"],
+              referencedTable: "users",
+              referencedColumns: ["id"],
+            },
+          ],
+        },
+      };
+
+      const sql = compileOne(operation);
+      expect(sql).not.toContain("constraint");
+      expect(sql).toMatchInlineSnapshot(
+        `"create table "posts" ("id" integer not null unique, "author_id" integer not null, foreign key ("author_id") references "users" ("id") on delete restrict on update restrict)"`,
+      );
+    });
+
     it("should keep add-foreign-key operations for existing tables (will throw error)", () => {
       const operations: MigrationOperation[] = [
         {
@@ -1050,13 +1837,57 @@ describe("SQLiteSQLGenerator", () => {
         expect(metadata?.inlineForeignKeys?.[1].name).toBe("posts_categories_category_fk");
       }
     });
+
+    it("should generate SQL with multiple inline foreign keys", () => {
+      const operation: MigrationOperation = {
+        type: "create-table",
+        name: "posts",
+        columns: [
+          { name: "id", type: "integer", isNullable: false, role: "external-id" },
+          { name: "author_id", type: "integer", isNullable: false, role: "reference" },
+          { name: "category_id", type: "integer", isNullable: false, role: "reference" },
+        ],
+        metadata: {
+          inlineForeignKeys: [
+            {
+              name: "posts_users_author_fk",
+              columns: ["author_id"],
+              referencedTable: "users",
+              referencedColumns: ["id"],
+            },
+            {
+              name: "posts_categories_category_fk",
+              columns: ["category_id"],
+              referencedTable: "categories",
+              referencedColumns: ["id"],
+            },
+          ],
+        },
+      };
+
+      const sql = compileOne(operation);
+      expect(sql).toMatchInlineSnapshot(
+        `"create table "posts" ("id" integer not null unique, "author_id" integer not null, "category_id" integer not null, foreign key ("author_id") references "users" ("id") on delete restrict on update restrict, foreign key ("category_id") references "categories" ("id") on delete restrict on update restrict)"`,
+      );
+    });
   });
 
   describe("table name mapping", () => {
-    const mapper = {
-      toPhysical: (name: string) => `prefix_${name}`,
-      toLogical: (name: string) => name.replace("prefix_", ""),
+    const mappingSchema = schema("mapping", (s) =>
+      s.addTable("users", (t) =>
+        t.addColumn("id", idColumn()).addColumn("email", column("string")),
+      ),
+    );
+    const namingStrategy: SqlNamingStrategy = {
+      namespaceScope: "suffix",
+      namespaceToSchema: (namespace) => namespace,
+      tableName: (logicalTable) => `prefix_${logicalTable}`,
+      columnName: (logicalColumn) => logicalColumn,
+      indexName: (logicalIndex) => `idx_${logicalIndex}`,
+      uniqueIndexName: (logicalIndex) => `uidx_${logicalIndex}`,
+      foreignKeyName: ({ referenceName }) => referenceName,
     };
+    const resolver = createNamingResolver(mappingSchema, null, namingStrategy);
 
     it("should apply table name mapping to create-table", () => {
       const operation: MigrationOperation = {
@@ -1065,7 +1896,7 @@ describe("SQLiteSQLGenerator", () => {
         columns: [{ name: "id", type: "integer", isNullable: false, role: "external-id" }],
       };
 
-      const statements = generator.compile([operation], mapper);
+      const statements = generator.compile([operation], resolver);
       expect(statements[1].sql).toMatchInlineSnapshot(
         `"create table "prefix_users" ("id" integer not null unique)"`,
       );
@@ -1080,9 +1911,9 @@ describe("SQLiteSQLGenerator", () => {
         unique: true,
       };
 
-      const statements = generator.compile([operation], mapper);
+      const statements = generator.compile([operation], resolver);
       expect(statements[1].sql).toMatchInlineSnapshot(
-        `"create unique index "idx_email_prefix_users" on "prefix_users" ("email")"`,
+        `"create unique index "uidx_idx_email" on "prefix_users" ("email")"`,
       );
     });
   });