@fragno-dev/db 0.2.2 → 0.3.0

package/src/adapters/generic-sql/migration/adapter-migration-parity.test.ts

@@ -0,0 +1,118 @@
+import { describe, expect, it } from "vitest";
+import {
+  DummyDriver,
+  MysqlAdapter,
+  MysqlQueryCompiler,
+  PostgresAdapter,
+  PostgresQueryCompiler,
+  SqliteAdapter,
+  SqliteQueryCompiler,
+} from "kysely";
+import { SqlAdapter } from "../generic-sql-adapter";
+import type { Dialect } from "../../../sql-driver/sql-driver";
+import {
+  MySQL2DriverConfig,
+  NodePostgresDriverConfig,
+  SQLocalDriverConfig,
+} from "../driver-config";
+import { column, idColumn, referenceColumn, schema } from "../../../schema/create";
+
+const paritySchema = schema("parity", (s) => {
+  return s
+    .addTable("users", (t) => {
+      return t
+        .addColumn("id", idColumn())
+        .addColumn("email", column("string"))
+        .addColumn(
+          "createdAt",
+          column("timestamp").defaultTo((b) => b.now()),
+        )
+        .createIndex("users_email_idx", ["email"], { unique: true });
+    })
+    .alterTable("users", (t) => {
+      return t.addColumn("age", column("integer").nullable()).createIndex("users_age_idx", ["age"]);
+    })
+    .addTable("posts", (t) => {
+      return t
+        .addColumn("id", idColumn())
+        .addColumn("authorId", referenceColumn())
+        .addColumn("title", column("string"))
+        .addColumn("isPublished", column("bool").defaultTo(false))
+        .createIndex("posts_author_idx", ["authorId"]);
+    })
+    .addReference("author", {
+      type: "one",
+      from: { table: "posts", column: "authorId" },
+      to: { table: "users", column: "id" },
+    });
+});
+
+function createDummyDialect(database: "postgresql" | "mysql" | "sqlite"): Dialect {
+  switch (database) {
+    case "postgresql":
+      return {
+        createAdapter: () => new PostgresAdapter(),
+        createDriver: () => new DummyDriver(),
+        createQueryCompiler: () => new PostgresQueryCompiler(),
+      };
+    case "mysql":
+      return {
+        createAdapter: () => new MysqlAdapter(),
+        createDriver: () => new DummyDriver(),
+        createQueryCompiler: () => new MysqlQueryCompiler(),
+      };
+    case "sqlite":
+      return {
+        createAdapter: () => new SqliteAdapter(),
+        createDriver: () => new DummyDriver(),
+        createQueryCompiler: () => new SqliteQueryCompiler(),
+      };
+  }
+}
+
+function getMigrationSql(adapter: SqlAdapter, namespace: string): string[] {
+  const prepared = adapter.prepareMigrations(paritySchema, namespace);
+  const migration = prepared.compile(0, paritySchema.version, {
+    updateVersionInMigration: false,
+  });
+  return migration.statements.map((statement) => statement.sql);
+}
+
+describe("migration SQL parity across SqlAdapter instances", () => {
+  const cases = [
+    {
+      name: "postgresql",
+      driverConfig: new NodePostgresDriverConfig(),
+    },
+    {
+      name: "sqlite",
+      driverConfig: new SQLocalDriverConfig(),
+    },
+    {
+      name: "mysql",
+      driverConfig: new MySQL2DriverConfig(),
+    },
+  ] as const;
+
+  for (const testCase of cases) {
+    it(`generates identical SQL for ${testCase.name}`, () => {
+      const dialect = createDummyDialect(testCase.name);
+      const namespace = "parity";
+
+      const firstAdapter = new SqlAdapter({
+        dialect,
+        driverConfig: testCase.driverConfig,
+      });
+
+      const secondAdapter = new SqlAdapter({
+        dialect,
+        driverConfig: testCase.driverConfig,
+      });
+
+      const firstSql = getMigrationSql(firstAdapter, namespace);
+      const secondSql = getMigrationSql(secondAdapter, namespace);
+
+      expect(firstSql).toEqual(secondSql);
+    });
+  }
+});

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

@@ -2,6 +2,8 @@ import { describe, expect, it } from "vitest";
 import type { MigrationOperation } from "../../../../migration-engine/shared";
 import { createColdKysely } from "../cold-kysely";
 import { MySQLSQLGenerator } from "./mysql";
+import { column, idColumn, schema } from "../../../../schema/create";
+import { createNamingResolver, type SqlNamingStrategy } from "../../../../naming/sql-naming";
 
 describe("MySQLSQLGenerator", () => {
   const coldKysely = createColdKysely("mysql");
@@ -194,7 +196,7 @@ describe("MySQLSQLGenerator", () => {
 
       const sql = compileOne(operation);
       expect(sql).toMatchInlineSnapshot(
-        `"create table \`users\` (\`_internalId\` bigint not null primary key auto_increment, \`name\` text not null)"`,
+        `"create table \`users\` (\`_internalId\` bigint not null  auto_increment, \`name\` text not null, constraint \`users__internalId\` primary key (\`_internalId\`))"`,
       );
     });
   });
@@ -628,6 +630,7 @@ describe("MySQLSQLGenerator", () => {
         type: "drop-foreign-key",
         table: "posts",
         name: "posts_user_id_fk",
+        referencedTable: "users",
       };
 
       const sql = compileOne(operation);
@@ -893,10 +896,25 @@ describe("MySQLSQLGenerator", () => {
   });
 
   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")),
+        )
+        .addTable("posts", (t) =>
+          t.addColumn("id", idColumn()).addColumn("user_id", 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 = {
@@ -905,7 +923,7 @@ describe("MySQLSQLGenerator", () => {
         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)"`,
       );
@@ -923,7 +941,7 @@ describe("MySQLSQLGenerator", () => {
         },
       };
 
-      const statements = generator.compile([operation], mapper);
+      const statements = generator.compile([operation], resolver);
       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"`,
       );
@@ -938,9 +956,9 @@ describe("MySQLSQLGenerator", () => {
         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\`)"`,
       );
     });
   });

package/src/adapters/generic-sql/migration/dialect/mysql.ts

@@ -5,7 +5,7 @@ import type {
   MigrationOperation,
 } from "../../../../migration-engine/shared";
 import { isUpdated } from "../../../../migration-engine/shared";
-import type { TableNameMapper } from "../../../shared/table-name-mapper";
+import type { NamingResolver } from "../../../../naming/sql-naming";
 import { SQLGenerator } from "../sql-generator";
 
 const errors = {
@@ -69,7 +69,9 @@ export class MySQLSQLGenerator extends SQLGenerator {
    */
   protected override compileUpdateColumn(
     tableName: string,
+    logicalTableName: string,
     operation: Extract<ColumnOperation, { type: "update-column" }>,
+    resolver?: NamingResolver,
   ): CompiledQuery | CompiledQuery[] {
     const col = operation.value;
 
@@ -82,9 +84,13 @@ export class MySQLSQLGenerator extends SQLGenerator {
     }
 
     // MySQL: Use modifyColumn which requires the full column definition
-    return this.db.schema
+    return this.getSchemaBuilder(resolver)
       .alterTable(tableName)
-      .modifyColumn(operation.name, sql.raw(this.getDBType(col)), (b) => this.buildColumn(col, b))
+      .modifyColumn(
+        this.getColumnName(operation.name, logicalTableName, resolver),
+        sql.raw(this.getDBType(col)),
+        (b) => this.buildColumn(col, b),
+      )
       .compile();
   }
 
@@ -93,12 +99,44 @@ export class MySQLSQLGenerator extends SQLGenerator {
    */
   protected override compileDropForeignKey(
     operation: Extract<MigrationOperation, { type: "drop-foreign-key" }>,
-    mapper?: TableNameMapper,
+    resolver?: NamingResolver,
   ): CompiledQuery {
-    const { table, name } = operation;
-    return this.db.schema
-      .alterTable(this.getTableName(table, mapper))
-      .dropConstraint(name)
+    const { table, name, referencedTable } = operation;
+    return this.getSchemaBuilder(resolver)
+      .alterTable(this.getTableName(table, resolver))
+      .dropConstraint(this.getForeignKeyName(name, table, referencedTable, resolver))
       .compile();
   }
+
+  /**
+   * MySQL: add a named primary key constraint for the internal ID column to align naming.
+   */
+  protected override compileCreateTable(
+    operation: Extract<MigrationOperation, { type: "create-table" }>,
+    resolver?: NamingResolver,
+  ): CompiledQuery {
+    const compiled = super.compileCreateTable(operation, resolver);
+    const tableName = this.getTableName(operation.name, resolver);
+    const internalIdColumn = operation.columns.find((col) => col.role === "internal-id");
+
+    if (!internalIdColumn) {
+      return compiled;
+    }
+
+    const pkColumn = this.getColumnName(internalIdColumn.name, operation.name, resolver);
+    const pkName = `${tableName}__${pkColumn.replace(/^_+/, "")}`;
+    const escapedPkColumn = pkColumn.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const columnRegex = new RegExp("`" + escapedPkColumn + "`([^,]*?)\\bprimary key\\b", "i");
+
+    let sqlText = compiled.sql.replace(columnRegex, "`" + pkColumn + "`$1");
+    sqlText = sqlText.replace(
+      /\)\s*$/,
+      ", constraint `" + pkName + "` primary key (`" + pkColumn + "`))",
+    );
+
+    return {
+      ...compiled,
+      sql: sqlText,
+    };
+  }
 }

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

@@ -2,6 +2,8 @@ import { describe, expect, it } from "vitest";
 import type { MigrationOperation } from "../../../../migration-engine/shared";
 import { createColdKysely } from "../cold-kysely";
 import { PostgresSQLGenerator } from "./postgres";
+import { column, idColumn, schema } from "../../../../schema/create";
+import { createNamingResolver, type SqlNamingStrategy } from "../../../../naming/sql-naming";
 
 describe("PostgresSQLGenerator", () => {
   const coldKysely = createColdKysely("postgresql");
@@ -646,6 +648,7 @@ describe("PostgresSQLGenerator", () => {
         type: "drop-foreign-key",
         table: "posts",
         name: "posts_user_id_fk",
+        referencedTable: "users",
       };
 
       const sql = compileOne(operation);
@@ -890,10 +893,25 @@ describe("PostgresSQLGenerator", () => {
   });
 
   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")),
+        )
+        .addTable("posts", (t) =>
+          t.addColumn("id", idColumn()).addColumn("user_id", 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 = {
@@ -902,7 +920,7 @@ describe("PostgresSQLGenerator", () => {
         columns: [{ name: "id", type: "integer", isNullable: false, role: "external-id" }],
       };
 
-      const statements = generator.compile([operation], mapper);
+      const statements = generator.compile([operation], resolver);
       expect(statements[0].sql).toMatchInlineSnapshot(
         `"create table "prefix_users" ("id" integer not null unique)"`,
       );
@@ -920,7 +938,7 @@ describe("PostgresSQLGenerator", () => {
         },
       };
 
-      const statements = generator.compile([operation], mapper);
+      const statements = generator.compile([operation], resolver);
       expect(statements[0].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"`,
       );
@@ -935,9 +953,9 @@ describe("PostgresSQLGenerator", () => {
         unique: true,
       };
 
-      const statements = generator.compile([operation], mapper);
+      const statements = generator.compile([operation], resolver);
       expect(statements[0].sql).toMatchInlineSnapshot(
-        `"create unique index "idx_email_prefix_users" on "prefix_users" ("email")"`,
+        `"create unique index "uidx_idx_email" on "prefix_users" ("email")"`,
       );
     });
   });

package/src/adapters/generic-sql/migration/dialect/postgres.ts

@@ -6,6 +6,7 @@ import type {
 } from "../../../../migration-engine/shared";
 import { isUpdated } from "../../../../migration-engine/shared";
 import { SQLGenerator } from "../sql-generator";
+import type { NamingResolver } from "../../../../naming/sql-naming";
 
 const errors = {
   IdColumnUpdate:
@@ -59,7 +60,9 @@ export class PostgresSQLGenerator extends SQLGenerator {
    */
   protected override compileUpdateColumn(
     tableName: string,
+    logicalTableName: string,
     operation: Extract<ColumnOperation, { type: "update-column" }>,
+    resolver?: NamingResolver,
   ): CompiledQuery | CompiledQuery[] {
     const col = operation.value;
 
@@ -72,13 +75,14 @@ export class PostgresSQLGenerator extends SQLGenerator {
     }
 
     const queries: CompiledQuery[] = [];
-    const alter = () => this.db.schema.alterTable(tableName);
+    const alter = () => this.getSchemaBuilder(resolver).alterTable(tableName);
+    const physicalColumnName = this.getColumnName(operation.name, logicalTableName, resolver);
 
     // PostgreSQL: Use explicit USING clause for type conversion
     if (operation.updateDataType) {
       const dbType = sql.raw(this.getDBType(col));
       queries.push(
-        sql`ALTER TABLE ${sql.ref(tableName)} ALTER COLUMN ${sql.ref(operation.name)} TYPE ${dbType} USING (${sql.ref(operation.name)}::${dbType})`.compile(
+        sql`ALTER TABLE ${sql.ref(tableName)} ALTER COLUMN ${sql.ref(physicalColumnName)} TYPE ${dbType} USING (${sql.ref(physicalColumnName)}::${dbType})`.compile(
           this.db,
         ),
       );
@@ -87,7 +91,7 @@ export class PostgresSQLGenerator extends SQLGenerator {
     if (operation.updateNullable) {
       queries.push(
         alter()
-          .alterColumn(operation.name, (build) =>
+          .alterColumn(physicalColumnName, (build) =>
             col.isNullable ? build.dropNotNull() : build.setNotNull(),
           )
           .compile(),
@@ -98,7 +102,7 @@ export class PostgresSQLGenerator extends SQLGenerator {
       const defaultValue = this.getDefaultValue(col);
       queries.push(
         alter()
-          .alterColumn(operation.name, (build) => {
+          .alterColumn(physicalColumnName, (build) => {
             if (!defaultValue) {
               return build.dropDefault();
             }

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

@@ -2,11 +2,21 @@ import { describe, expect, it } from "vitest";
 import type { MigrationOperation } from "../../../../migration-engine/shared";
 import { createColdKysely } from "../cold-kysely";
 import { SQLiteSQLGenerator } from "./sqlite";
+import { sqliteStoragePrisma } from "../../sqlite-storage";
+import { column, idColumn, schema } from "../../../../schema/create";
+import { createNamingResolver, type SqlNamingStrategy } from "../../../../naming/sql-naming";
 
 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 +168,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)"`,
       );
     });
 
@@ -504,6 +532,7 @@ describe("SQLiteSQLGenerator", () => {
         type: "drop-foreign-key",
         table: "posts",
         name: "posts_user_id_fk",
+        referencedTable: "users",
       };
 
       expect(() => generator.compile([operation])).toThrow(
@@ -949,7 +978,6 @@ 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");
@@ -1053,10 +1081,21 @@ describe("SQLiteSQLGenerator", () => {
   });
 
   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 +1104,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 +1119,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")"`,
       );
     });
   });

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

@@ -5,7 +5,7 @@ import type {
   ForeignKeyInfo,
   MigrationOperation,
 } from "../../../../migration-engine/shared";
-import type { TableNameMapper } from "../../../shared/table-name-mapper";
+import type { NamingResolver } from "../../../../naming/sql-naming";
 import { SQLGenerator } from "../sql-generator";
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -105,6 +105,10 @@ export class SQLiteSQLGenerator extends SQLGenerator {
     }
 
     if ("dbSpecial" in value && value.dbSpecial === "now") {
+      const dbType = this.typeMapper.getDatabaseType(column);
+      if (dbType === "integer" && (column.type === "timestamp" || column.type === "date")) {
+        return sql`(cast((julianday('now') - 2440587.5)*86400000 as integer))`;
+      }
       return sql`CURRENT_TIMESTAMP`;
     }
 
@@ -121,15 +125,16 @@ export class SQLiteSQLGenerator extends SQLGenerator {
    */
   protected override compileCreateTable(
     operation: Extract<MigrationOperation, { type: "create-table" }>,
-    mapper?: TableNameMapper,
+    resolver?: NamingResolver,
   ): CompiledQuery {
-    const tableName = this.getTableName(operation.name, mapper);
-    let builder: CreateTableBuilderAny = this.db.schema.createTable(tableName);
+    const tableName = this.getTableName(operation.name, resolver);
+    let builder: CreateTableBuilderAny = this.getSchemaBuilder(resolver).createTable(tableName);
 
     // Add columns
     for (const col of operation.columns) {
+      const columnName = this.getColumnName(col.name, operation.name, resolver);
       builder = builder.addColumn(
-        col.name,
+        columnName,
         sql.raw(this.getDBType(col)),
         (b: ColumnDefinitionBuilder) => this.buildColumn(col, b),
       );
@@ -140,17 +145,25 @@ export class SQLiteSQLGenerator extends SQLGenerator {
     if (metadata?.inlineForeignKeys) {
       for (const fk of metadata.inlineForeignKeys) {
         builder = builder.addForeignKeyConstraint(
-          fk.name,
-          fk.columns,
-          this.getTableName(fk.referencedTable, mapper),
-          fk.referencedColumns,
+          this.getForeignKeyName(fk.name, operation.name, fk.referencedTable, resolver),
+          fk.columns.map((columnName) => this.getColumnName(columnName, operation.name, resolver)),
+          this.getTableName(fk.referencedTable, resolver),
+          fk.referencedColumns.map((columnName) =>
+            this.getColumnName(columnName, fk.referencedTable, resolver),
+          ),
           // eslint-disable-next-line @typescript-eslint/no-explicit-any
           (cb: any) => cb.onUpdate("restrict").onDelete("restrict"),
         );
       }
     }
 
-    return builder.compile();
+    const compiled = builder.compile();
+    // SQLite constraint names are ignored by Drizzle migrations; strip them for parity.
+    const sqlText = compiled.sql.replace(/\bconstraint\s+"[^"]+"\s+foreign key\b/gi, "foreign key");
+    return {
+      ...compiled,
+      sql: sqlText,
+    };
   }
 
   /**
@@ -158,7 +171,7 @@ export class SQLiteSQLGenerator extends SQLGenerator {
    */
   protected override compileAddForeignKey(
     _operation: Extract<MigrationOperation, { type: "add-foreign-key" }>,
-    _mapper?: TableNameMapper,
+    _resolver?: NamingResolver,
   ): CompiledQuery {
     throw new Error(errors.SQLiteUpdateForeignKeys);
   }
@@ -168,7 +181,7 @@ export class SQLiteSQLGenerator extends SQLGenerator {
    */
   protected override compileDropForeignKey(
     _operation: Extract<MigrationOperation, { type: "drop-foreign-key" }>,
-    _mapper?: TableNameMapper,
+    _resolver?: NamingResolver,
   ): CompiledQuery {
     throw new Error(errors.SQLiteUpdateForeignKeys);
   }
@@ -178,7 +191,9 @@ export class SQLiteSQLGenerator extends SQLGenerator {
    */
   protected override compileUpdateColumn(
     _tableName: string,
+    _logicalTableName: string,
     operation: Extract<ColumnOperation, { type: "update-column" }>,
+    _resolver?: NamingResolver,
   ): CompiledQuery | CompiledQuery[] {
     const col = operation.value;
     if (col.role === "external-id" || col.role === "internal-id") {