@fragno-dev/db 0.1.2 → 0.1.3

package/src/adapters/drizzle/drizzle-adapter.test.ts

@@ -80,7 +80,7 @@ describe("DrizzleAdapter", () => {
         id: text("id").notNull().$defaultFn(() => createId()),
         key: text("key").notNull(),
         value: text("value").notNull(),
-        _internalId: integer("_internalId").primaryKey().autoincrement().notNull(),
+        _internalId: integer("_internalId").primaryKey({ autoIncrement: true }).notNull(),
         _version: integer("_version").notNull().default(0)
       }, (table) => [
         uniqueIndex("unique_key").on(table.key)
@@ -95,7 +95,7 @@ describe("DrizzleAdapter", () => {
       export const users_test = sqliteTable("users_test", {
         id: text("id").notNull().$defaultFn(() => createId()),
         name: text("name").notNull(),
-        _internalId: integer("_internalId").primaryKey().autoincrement().notNull(),
+        _internalId: integer("_internalId").primaryKey({ autoIncrement: true }).notNull(),
         _version: integer("_version").notNull().default(0)
       })
 

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

@@ -26,10 +26,17 @@ export class DrizzleAdapter implements DatabaseAdapter<DrizzleUOWConfig> {
 
   async isConnectionHealthy(): Promise<boolean> {
     try {
-      const result = (await (this.#drizzleConfig.db as DBType).execute(
-        sql`SELECT 1 as healthy`,
-      )) as DrizzleResult;
-      return result.rows[0]["healthy"] === 1;
+      const result = await (this.#drizzleConfig.db as DBType).execute(sql`SELECT 1 as healthy`);
+
+      // Handle different result formats across providers
+      // PostgreSQL/MySQL: { rows: [...] }
+      // SQLite: array directly or { rows: [...] }
+      if (Array.isArray(result)) {
+        return result.length > 0 && result[0]["healthy"] === 1;
+      } else {
+        const drizzleResult = result as DrizzleResult;
+        return drizzleResult.rows[0]["healthy"] === 1;
+      }
     } catch {
       return false;
     }

package/src/adapters/drizzle/drizzle-query.ts

@@ -54,9 +54,9 @@ export function fromDrizzle<T extends AnySchema>(
 
     const executor: UOWExecutor<DrizzleCompiledQuery, DrizzleResult> = {
       executeRetrievalPhase: (retrievalBatch: DrizzleCompiledQuery[]) =>
-        executeDrizzleRetrievalPhase(db, retrievalBatch),
+        executeDrizzleRetrievalPhase(db, retrievalBatch, provider),
       executeMutationPhase: (mutationBatch: CompiledMutation<DrizzleCompiledQuery>[]) =>
-        executeDrizzleMutationPhase(db, mutationBatch),
+        executeDrizzleMutationPhase(db, mutationBatch, provider),
     };
 
     const decoder = createDrizzleUOWDecoder(schema, provider);

package/src/adapters/drizzle/drizzle-uow-compiler.test.ts

@@ -953,7 +953,7 @@ describe("drizzle-uow-compiler", () => {
       return async () => {
         await cleanup();
       };
-    }, 15000);
+    }, 20000);
 
     function createNestedUOW(name?: string) {
       const compiler = createDrizzleUOWCompiler(nestedSchema, nestedConfig);

package/src/adapters/drizzle/drizzle-uow-decoder.ts

@@ -92,6 +92,7 @@ function transformJoinArraysToObjects(
       joins?: JoinInfo[];
     };
   },
+  provider: SQLProvider,
 ): Record<string, unknown> {
   // Only process find operations with joins
   if (op.type !== "find" || !op.options?.joins) {
@@ -102,7 +103,17 @@ function transformJoinArraysToObjects(
 
   for (const join of op.options.joins) {
     const relationName = join.relation.name;
-    const value = row[relationName];
+    let value = row[relationName];
+
+    // For SQLite, json_array returns a JSON string that needs to be parsed
+    if (provider === "sqlite" && typeof value === "string") {
+      try {
+        value = JSON.parse(value) as unknown;
+      } catch {
+        // If parsing fails, skip this join
+        continue;
+      }
+    }
 
     // Skip if not an array (join didn't return data)
     if (!Array.isArray(value)) {
@@ -149,15 +160,21 @@ export function createDrizzleUOWDecoder<TSchema extends AnySchema>(
       // Handle count operations - return the count value directly
       if (op.type === "count") {
         if (result.rows.length > 0 && result.rows[0]) {
-          const row = result.rows[0];
-          return (row as Record<string, unknown>)["count"] as number;
+          const row = result.rows[0] as Record<string, unknown>;
+          const countValue = row["count"] ?? row["count(*)"];
+
+          if (typeof countValue !== "number") {
+            throw new Error(`Unexpected result for count, received: ${countValue}`);
+          }
+
+          return countValue;
         }
         return 0;
       }
 
       // Handle find operations - decode each row
       return result.rows.map((row) => {
-        const transformedRow = transformJoinArraysToObjects(row, op);
+        const transformedRow = transformJoinArraysToObjects(row, op, provider);
         return decodeResult(transformedRow, op.table, provider);
       });
     });

package/src/adapters/drizzle/drizzle-uow-executor.ts

@@ -3,88 +3,105 @@ import type { CompiledMutation, MutationResult } from "../../query/unit-of-work"
 import type { DBType } from "./shared";
 import type { DrizzleCompiledQuery } from "./drizzle-uow-compiler";
 import type { DrizzleResult } from "./shared";
+import { BaseSQLiteDatabase } from "drizzle-orm/sqlite-core";
+import { SQLiteSyncDialect } from "drizzle-orm/sqlite-core";
+
+type SyncSQLiteDB = BaseSQLiteDatabase<
+  "sync",
+  unknown,
+  Record<string, never>,
+  Record<string, never>
+>;
+
+function isSyncSQLite(db: unknown): boolean {
+  return (
+    db instanceof BaseSQLiteDatabase &&
+    "dialect" in db &&
+    (db as { dialect?: unknown }).dialect instanceof SQLiteSyncDialect
+  );
+}
 
-/**
- * Convert a DrizzleCompiledQuery (SQL string + params) to a Drizzle SQL object
- *
- * This reconstructs the SQL object with proper parameter chunks by parsing
- * the SQL string and replacing placeholders ($1, $2, etc.) with Param objects.
- * Uses Drizzle's exported classes (StringChunk, Param, SQL) to build the queryChunks.
- */
-function toSQL(query: DrizzleCompiledQuery): SQL {
-  const { sql: sqlString, params } = query;
+function assertSyncSQLite(db: unknown): asserts db is SyncSQLiteDB {
+  if (!isSyncSQLite(db)) {
+    throw new Error("Expected synchronous SQLite database (better-sqlite3)");
+  }
+}
 
-  // Match parameter placeholders like $1, $2, etc.
+function postgresToSQL(sqlString: string, params: unknown[]): SQLChunk[] {
   const placeholderRegex = /\$(\d+)/g;
   const queryChunks: SQLChunk[] = [];
   let lastIndex = 0;
   let match: RegExpExecArray | null;
 
   while ((match = placeholderRegex.exec(sqlString)) !== null) {
-    // Add the string chunk before the placeholder
     const textBefore = sqlString.substring(lastIndex, match.index);
     if (textBefore) {
       queryChunks.push(new StringChunk(textBefore));
     }
 
-    // Add the parameter value as a Param
-    const paramIndex = parseInt(match[1]!, 10) - 1; // $1 is index 0
+    const paramIndex = parseInt(match[1]!, 10) - 1;
     queryChunks.push(sql.param(params[paramIndex]));
 
     lastIndex = match.index + match[0].length;
   }
 
-  // Add any remaining string after the last placeholder
   const textAfter = sqlString.substring(lastIndex);
   if (textAfter) {
     queryChunks.push(new StringChunk(textAfter));
   }
 
-  // Construct SQL object directly with queryChunks (same pattern as sql`` tagged template)
-  // Safe: We're reusing Drizzle's SQL constructor the same way the sql`` function does
+  return queryChunks;
+}
+
+function sqliteToSQL(sqlString: string, params: unknown[]): SQLChunk[] {
+  const chunks: SQLChunk[] = [];
+  let currentIndex = 0;
+
+  const parts = sqlString.split("?");
+  for (let i = 0; i < parts.length; i++) {
+    if (parts[i]) {
+      chunks.push(new StringChunk(parts[i]));
+    }
+    if (i < parts.length - 1 && currentIndex < params.length) {
+      chunks.push(sql.param(params[currentIndex++]));
+    }
+  }
+
+  return chunks;
+}
+
+function toSQL(query: DrizzleCompiledQuery, provider: "sqlite" | "mysql" | "postgresql"): SQL {
+  const { sql: sqlString, params } = query;
+
+  const queryChunks =
+    provider === "sqlite" ? sqliteToSQL(sqlString, params) : postgresToSQL(sqlString, params);
+
   return new SQL(queryChunks);
 }
 
-/**
- * Get the number of affected rows from a Drizzle query result
- */
 function getAffectedRows(result: unknown): number {
-  // Drizzle returns different formats depending on the database
-  // For MySQL: array with affectedRows property
-  // For PostgreSQL/SQLite: array with rowCount or similar
   if (Array.isArray(result)) {
-    // This is likely a select/returning result
     return result.length;
   }
 
-  // Check for MySQL-style result
-  if (
-    result &&
-    typeof result === "object" &&
-    "affectedRows" in result &&
-    typeof result["affectedRows"] === "number"
-  ) {
-    return result["affectedRows"];
-  }
+  if (result && typeof result === "object") {
+    if ("affectedRows" in result && typeof result["affectedRows"] === "number") {
+      return result["affectedRows"];
+    }
 
-  // Check for PostgreSQL-style result with rowCount
-  if (
-    result &&
-    typeof result === "object" &&
-    "rowCount" in result &&
-    (typeof result["rowCount"] === "number" || typeof result["rowCount"] === "bigint")
-  ) {
-    const rowCount = result["rowCount"];
-    if (rowCount > Number.MAX_SAFE_INTEGER) {
-      throw new Error(`rowCount BigInt value ${rowCount.toString()} exceeds JS safe integer range`);
+    if (
+      "rowCount" in result &&
+      (typeof result["rowCount"] === "number" || typeof result["rowCount"] === "bigint")
+    ) {
+      const rowCount = result["rowCount"];
+      if (rowCount > Number.MAX_SAFE_INTEGER) {
+        throw new Error(
+          `rowCount BigInt value ${rowCount.toString()} exceeds JS safe integer range`,
+        );
+      }
+      return Number(rowCount);
     }
-    return Number(rowCount);
-  }
 
-  // For update/delete operations, Drizzle might return an object with affected rows info
-  // Try to extract it from common patterns
-  if (result && typeof result === "object") {
-    // Check for changes/changes count
     if ("changes" in result && typeof result["changes"] === "number") {
       return result["changes"];
     }
@@ -93,40 +110,87 @@ function getAffectedRows(result: unknown): number {
   throw new Error(`Unable to determine affected rows from result: ${JSON.stringify(result)}`);
 }
 
+async function executeInTransaction(
+  db: DBType,
+  provider: "sqlite" | "mysql" | "postgresql",
+  syncExecutor: (db: SyncSQLiteDB) => void,
+  asyncExecutor: (tx: { execute: (sql: SQL) => Promise<unknown> }) => Promise<void>,
+): Promise<void> {
+  if (provider === "sqlite" && isSyncSQLite(db)) {
+    assertSyncSQLite(db);
+    db.transaction(() => syncExecutor(db));
+  } else {
+    await db.transaction(
+      async (tx) => await asyncExecutor(tx as { execute: (sql: SQL) => Promise<unknown> }),
+    );
+  }
+}
+
+function extractCreatedInternalId(result: unknown): bigint | null {
+  if (result && typeof result === "object" && "lastInsertRowid" in result) {
+    if (typeof result.lastInsertRowid === "bigint") {
+      return result.lastInsertRowid;
+    }
+
+    if (typeof result.lastInsertRowid === "number") {
+      return BigInt(result.lastInsertRowid);
+    }
+
+    throw new Error(`Unexpected lastInsertRowid type: ${typeof result.lastInsertRowid}`);
+  }
+
+  if (Array.isArray(result) && result.length > 0) {
+    const row = result[0] as Record<string, unknown>;
+    if ("_internalId" in row || "_internal_id" in row) {
+      return (row["_internalId"] ?? row["_internal_id"]) as bigint;
+    }
+  }
+
+  return null;
+}
+
+function validateAffectedRows(result: unknown, expected: number): void {
+  const actual = getAffectedRows(result);
+  if (actual !== expected) {
+    throw new Error(`Version conflict: expected ${expected} rows affected, but got ${actual}`);
+  }
+}
+
 /**
  * Execute the retrieval phase of a Unit of Work using Drizzle
  *
  * All retrieval queries are executed inside a single transaction to ensure
  * snapshot isolation - all reads see a consistent view of the database.
- *
- * @param db - The Drizzle database instance
- * @param retrievalBatch - Array of Drizzle SQL queries
- * @returns Array of query results matching the retrieval operations order
- *
- * @example
- * ```ts
- * const retrievalResults = await executeDrizzleRetrievalPhase(db, compiled.retrievalBatch);
- * const [users, posts] = retrievalResults;
- * ```
  */
 export async function executeDrizzleRetrievalPhase(
   db: DBType,
   retrievalBatch: DrizzleCompiledQuery[],
+  provider: "sqlite" | "mysql" | "postgresql",
 ): Promise<DrizzleResult[]> {
-  // If no retrieval operations, return empty array immediately
   if (retrievalBatch.length === 0) {
     return [];
   }
 
   const retrievalResults: DrizzleResult[] = [];
 
-  // Execute all retrieval queries inside a transaction for snapshot isolation
-  await db.transaction(async (tx) => {
-    for (const query of retrievalBatch) {
-      const result = (await tx.execute(toSQL(query))) as DrizzleResult;
-      retrievalResults.push(result);
-    }
-  });
+  await executeInTransaction(
+    db,
+    provider,
+    (syncDb) => {
+      for (const query of retrievalBatch) {
+        const sqlObj = toSQL(query, provider);
+        const rows = syncDb.all(sqlObj as never) as Record<string, unknown>[];
+        const result: DrizzleResult = { rows, affectedRows: 0 };
+        retrievalResults.push(result);
+      }
+    },
+    async (tx) => {
+      for (const query of retrievalBatch) {
+        const result = (await tx.execute(toSQL(query, provider))) as DrizzleResult;
+        retrievalResults.push(result);
+      }
+    },
+  );
 
   return retrievalResults;
 }
@@ -137,77 +201,53 @@ export async function executeDrizzleRetrievalPhase(
  * All mutation queries are executed in a transaction with optimistic locking.
  * If any version check fails, the entire transaction is rolled back and
  * success=false is returned.
- *
- * @param db - The Drizzle database instance
- * @param mutationBatch - Array of compiled mutation SQL queries with expected affected rows
- * @returns Object with success flag and internal IDs from create operations
- *
- * @example
- * ```ts
- * const { success } = await executeDrizzleMutationPhase(db, compiled.mutationBatch);
- * if (!success) {
- *   console.log("Version conflict detected, retrying...");
- * }
- * ```
  */
 export async function executeDrizzleMutationPhase(
   db: DBType,
   mutationBatch: CompiledMutation<DrizzleCompiledQuery>[],
+  provider: "sqlite" | "mysql" | "postgresql",
 ): Promise<MutationResult> {
-  // If there are no mutations, return success immediately
   if (mutationBatch.length === 0) {
     return { success: true, createdInternalIds: [] };
   }
 
   const createdInternalIds: (bigint | null)[] = [];
 
-  // Execute mutation batch in a transaction
   try {
-    await db.transaction(async (tx) => {
-      for (const compiledMutation of mutationBatch) {
-        const result = await tx.execute(toSQL(compiledMutation.query));
-
-        // For creates (expectedAffectedRows === null), try to extract internal ID
-        if (compiledMutation.expectedAffectedRows === null) {
-          // Check if result is an array with rows (RETURNING clause supported)
-          if (Array.isArray(result) && result.length > 0) {
-            const row = result[0] as Record<string, unknown>;
-            // Look for _internalId column in the returned row
-            if ("_internalId" in row || "_internal_id" in row) {
-              const internalId = (row["_internalId"] ?? row["_internal_id"]) as bigint;
-              createdInternalIds.push(internalId);
-            } else {
-              // RETURNING supported but _internalId not found
-              createdInternalIds.push(null);
-            }
+    await executeInTransaction(
+      db,
+      provider,
+      (syncDb) => {
+        for (const { query, expectedAffectedRows } of mutationBatch) {
+          const sqlObj = toSQL(query, provider);
+          // Type assertion needed due to drizzle-orm version mismatch in dependencies
+          const result = syncDb.run(sqlObj as never);
+
+          if (expectedAffectedRows === null) {
+            createdInternalIds.push(extractCreatedInternalId(result));
           } else {
-            // No RETURNING support (e.g., MySQL)
-            createdInternalIds.push(null);
+            validateAffectedRows(result, expectedAffectedRows);
           }
-        } else {
-          // Check affected rows for updates/deletes
-          const affectedRows = getAffectedRows(result);
-
-          if (affectedRows !== compiledMutation.expectedAffectedRows) {
-            // Version conflict detected - the UPDATE/DELETE didn't affect the expected number of rows
-            // This means either the row doesn't exist or the version has changed
-            throw new Error(
-              `Version conflict: expected ${compiledMutation.expectedAffectedRows} rows affected, but got ${affectedRows}`,
-            );
+        }
+      },
+      async (tx) => {
+        for (const { query, expectedAffectedRows } of mutationBatch) {
+          const result = await tx.execute(toSQL(query, provider));
+
+          if (expectedAffectedRows === null) {
+            createdInternalIds.push(extractCreatedInternalId(result));
+          } else {
+            validateAffectedRows(result, expectedAffectedRows);
           }
         }
-      }
-    });
+      },
+    );
 
     return { success: true, createdInternalIds };
   } catch (error) {
-    // Transaction failed - could be version conflict or other constraint violation
-    // Return success=false to indicate the UOW should be retried
     if (error instanceof Error && error.message.includes("Version conflict")) {
       return { success: false };
     }
-
-    // Other database errors should be thrown
     throw error;
   }
 }

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

@@ -189,7 +189,7 @@ describe("generateSchema", () => {
     it("should generate SQLite schema", () => {
       const generated = generateSchema([{ namespace: "test", schema: testSchema }], "sqlite");
       expect(generated).toMatchInlineSnapshot(`
-        "import { sqliteTable, text, integer, uniqueIndex, index, blob, foreignKey } from "drizzle-orm/sqlite-core"
+        "import { sqliteTable, text, integer, uniqueIndex, index, foreignKey } from "drizzle-orm/sqlite-core"
         import { createId } from "@fragno-dev/db/id"
         import { relations } from "drizzle-orm"
 
@@ -201,7 +201,7 @@ describe("generateSchema", () => {
           id: text("id").notNull().$defaultFn(() => createId()),
           key: text("key").notNull(),
           value: text("value").notNull(),
-          _internalId: integer("_internalId").primaryKey().autoincrement().notNull(),
+          _internalId: integer("_internalId").primaryKey({ autoIncrement: true }).notNull(),
           _version: integer("_version").notNull().default(0)
         }, (table) => [
           uniqueIndex("unique_key").on(table.key)
@@ -218,7 +218,7 @@ describe("generateSchema", () => {
           name: text("name").notNull(),
           email: text("email").notNull(),
           age: integer("age"),
-          _internalId: integer("_internalId").primaryKey().autoincrement().notNull(),
+          _internalId: integer("_internalId").primaryKey({ autoIncrement: true }).notNull(),
           _version: integer("_version").notNull().default(0)
         }, (table) => [
           uniqueIndex("idx_email_test").on(table.email),
@@ -229,9 +229,9 @@ describe("generateSchema", () => {
           id: text("id").notNull().$defaultFn(() => createId()),
           title: text("title").notNull(),
           content: text("content").notNull(),
-          userId: blob("userId", { mode: "bigint" }).notNull(),
+          userId: integer("userId").notNull(),
           viewCount: integer("viewCount").notNull().default(0),
-          _internalId: integer("_internalId").primaryKey().autoincrement().notNull(),
+          _internalId: integer("_internalId").primaryKey({ autoIncrement: true }).notNull(),
           _version: integer("_version").notNull().default(0)
         }, (table) => [
           foreignKey({
@@ -612,7 +612,7 @@ describe("generateSchema", () => {
     it("should generate SQLite schema with many relations", () => {
       const generated = generateSchema([{ namespace: "test", schema: oneToManySchema }], "sqlite");
       expect(generated).toMatchInlineSnapshot(`
-        "import { sqliteTable, text, integer, uniqueIndex, blob, foreignKey, index } from "drizzle-orm/sqlite-core"
+        "import { sqliteTable, text, integer, uniqueIndex, foreignKey, index } from "drizzle-orm/sqlite-core"
         import { createId } from "@fragno-dev/db/id"
         import { relations } from "drizzle-orm"
 
@@ -624,7 +624,7 @@ describe("generateSchema", () => {
           id: text("id").notNull().$defaultFn(() => createId()),
           key: text("key").notNull(),
           value: text("value").notNull(),
-          _internalId: integer("_internalId").primaryKey().autoincrement().notNull(),
+          _internalId: integer("_internalId").primaryKey({ autoIncrement: true }).notNull(),
           _version: integer("_version").notNull().default(0)
         }, (table) => [
           uniqueIndex("unique_key").on(table.key)
@@ -639,7 +639,7 @@ describe("generateSchema", () => {
         export const users_test = sqliteTable("users_test", {
           id: text("id").notNull().$defaultFn(() => createId()),
           name: text("name").notNull(),
-          _internalId: integer("_internalId").primaryKey().autoincrement().notNull(),
+          _internalId: integer("_internalId").primaryKey({ autoIncrement: true }).notNull(),
           _version: integer("_version").notNull().default(0)
         })
 
@@ -652,8 +652,8 @@ describe("generateSchema", () => {
         export const posts_test = sqliteTable("posts_test", {
           id: text("id").notNull().$defaultFn(() => createId()),
           title: text("title").notNull(),
-          userId: blob("userId", { mode: "bigint" }).notNull(),
-          _internalId: integer("_internalId").primaryKey().autoincrement().notNull(),
+          userId: integer("userId").notNull(),
+          _internalId: integer("_internalId").primaryKey({ autoIncrement: true }).notNull(),
           _version: integer("_version").notNull().default(0)
         }, (table) => [
           foreignKey({
@@ -1008,7 +1008,7 @@ describe("generateSchema", () => {
     it("should generate SQLite self-referencing foreign key using table parameter", () => {
       const generated = generateSchema([{ namespace: "test", schema: selfRefSchema }], "sqlite");
       expect(generated).toMatchInlineSnapshot(`
-        "import { sqliteTable, text, integer, uniqueIndex, blob, foreignKey, index } from "drizzle-orm/sqlite-core"
+        "import { sqliteTable, text, integer, uniqueIndex, foreignKey, index } from "drizzle-orm/sqlite-core"
         import { createId } from "@fragno-dev/db/id"
         import { relations } from "drizzle-orm"
 
@@ -1020,7 +1020,7 @@ describe("generateSchema", () => {
           id: text("id").notNull().$defaultFn(() => createId()),
           key: text("key").notNull(),
           value: text("value").notNull(),
-          _internalId: integer("_internalId").primaryKey().autoincrement().notNull(),
+          _internalId: integer("_internalId").primaryKey({ autoIncrement: true }).notNull(),
           _version: integer("_version").notNull().default(0)
         }, (table) => [
           uniqueIndex("unique_key").on(table.key)
@@ -1035,8 +1035,8 @@ describe("generateSchema", () => {
         export const comment_test = sqliteTable("comment_test", {
           id: text("id").notNull().$defaultFn(() => createId()),
           content: text("content").notNull(),
-          parentId: blob("parentId", { mode: "bigint" }),
-          _internalId: integer("_internalId").primaryKey().autoincrement().notNull(),
+          parentId: integer("parentId"),
+          _internalId: integer("_internalId").primaryKey({ autoIncrement: true }).notNull(),
           _version: integer("_version").notNull().default(0)
         }, (table) => [
           foreignKey({

package/src/adapters/drizzle/generate.ts

@@ -248,12 +248,16 @@ function generateColumnDefinition(
 
   // Primary key for internal ID
   if (column instanceof InternalIdColumn || column.role === "internal-id") {
-    parts.push("primaryKey()");
-
-    // Auto-increment based on provider
-    // Note: PostgreSQL uses bigserial/serial which handle auto-increment automatically
-    if (ctx.provider === "mysql" || ctx.provider === "sqlite") {
+    if (ctx.provider === "sqlite") {
+      // SQLite uses primaryKey({ autoIncrement: true })
+      parts.push("primaryKey({ autoIncrement: true })");
+    } else if (ctx.provider === "mysql") {
+      // MySQL uses primaryKey().autoincrement()
+      parts.push("primaryKey()");
       parts.push("autoincrement()");
+    } else {
+      // PostgreSQL just uses primaryKey()
+      parts.push("primaryKey()");
     }
   }
 

package/src/schema/serialize.test.ts

@@ -514,6 +514,7 @@ describe("serialize", () => {
 
         expect(serialize(fragnoId, referenceCol, "postgresql")).toBe(BigInt(456));
         expect(serialize(fragnoId, referenceCol, "sqlite")).toBe(BigInt(456));
+        expect(serialize(fragnoId, referenceCol, "mysql")).toBe(BigInt(456));
       });
 
       it("should fallback to external ID for reference column when internal ID unavailable", () => {

package/src/schema/serialize.ts

@@ -188,6 +188,13 @@ export function schemaToDBType(
     }
   }
 
+  if ("role" in column && column.role === "reference") {
+    if (provider === "sqlite") {
+      return "integer";
+    }
+    // Other providers use bigint for references
+  }
+
   if (provider === "sqlite") {
     switch (type) {
       case "integer":

package/dist/node_modules/.bun/drizzle-orm@0.44.6_4fae081eecb963e2/node_modules/drizzle-orm/column-builder.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"column-builder.js","names":[],"sources":["../../../../../../../../node_modules/.bun/drizzle-orm@0.44.6+4fae081eecb963e2/node_modules/drizzle-orm/column-builder.js"],"sourcesContent":["import { entityKind } from \"./entity.js\";\nclass ColumnBuilder {\n  static [entityKind] = \"ColumnBuilder\";\n  config;\n  constructor(name, dataType, columnType) {\n    this.config = {\n      name,\n      keyAsName: name === \"\",\n      notNull: false,\n      default: void 0,\n      hasDefault: false,\n      primaryKey: false,\n      isUnique: false,\n      uniqueName: void 0,\n      uniqueType: void 0,\n      dataType,\n      columnType,\n      generated: void 0\n    };\n  }\n  /**\n   * Changes the data type of the column. Commonly used with `json` columns. Also, useful for branded types.\n   *\n   * @example\n   * ```ts\n   * const users = pgTable('users', {\n   * \tid: integer('id').$type<UserId>().primaryKey(),\n   * \tdetails: json('details').$type<UserDetails>().notNull(),\n   * });\n   * ```\n   */\n  $type() {\n    return this;\n  }\n  /**\n   * Adds a `not null` clause to the column definition.\n   *\n   * Affects the `select` model of the table - columns *without* `not null` will be nullable on select.\n   */\n  notNull() {\n    this.config.notNull = true;\n    return this;\n  }\n  /**\n   * Adds a `default <value>` clause to the column definition.\n   *\n   * Affects the `insert` model of the table - columns *with* `default` are optional on insert.\n   *\n   * If you need to set a dynamic default value, use {@link $defaultFn} instead.\n   */\n  default(value) {\n    this.config.default = value;\n    this.config.hasDefault = true;\n    return this;\n  }\n  /**\n   * Adds a dynamic default value to the column.\n   * The function will be called when the row is inserted, and the returned value will be used as the column value.\n   *\n   * **Note:** This value does not affect the `drizzle-kit` behavior, it is only used at runtime in `drizzle-orm`.\n   */\n  $defaultFn(fn) {\n    this.config.defaultFn = fn;\n    this.config.hasDefault = true;\n    return this;\n  }\n  /**\n   * Alias for {@link $defaultFn}.\n   */\n  $default = this.$defaultFn;\n  /**\n   * Adds a dynamic update value to the column.\n   * The function will be called when the row is updated, and the returned value will be used as the column value if none is provided.\n   * If no `default` (or `$defaultFn`) value is provided, the function will be called when the row is inserted as well, and the returned value will be used as the column value.\n   *\n   * **Note:** This value does not affect the `drizzle-kit` behavior, it is only used at runtime in `drizzle-orm`.\n   */\n  $onUpdateFn(fn) {\n    this.config.onUpdateFn = fn;\n    this.config.hasDefault = true;\n    return this;\n  }\n  /**\n   * Alias for {@link $onUpdateFn}.\n   */\n  $onUpdate = this.$onUpdateFn;\n  /**\n   * Adds a `primary key` clause to the column definition. This implicitly makes the column `not null`.\n   *\n   * In SQLite, `integer primary key` implicitly makes the column auto-incrementing.\n   */\n  primaryKey() {\n    this.config.primaryKey = true;\n    this.config.notNull = true;\n    return this;\n  }\n  /** @internal Sets the name of the column to the key within the table definition if a name was not given. */\n  setName(name) {\n    if (this.config.name !== \"\") return;\n    this.config.name = name;\n  }\n}\nexport {\n  ColumnBuilder\n};\n//# sourceMappingURL=column-builder.js.map"],"x_google_ignoreList":[0],"mappings":";;;AACA,IAAM,gBAAN,MAAoB;CAClB,QAAQ,cAAc;CACtB;CACA,YAAY,MAAM,UAAU,YAAY;AACtC,OAAK,SAAS;GACZ;GACA,WAAW,SAAS;GACpB,SAAS;GACT,SAAS,KAAK;GACd,YAAY;GACZ,YAAY;GACZ,UAAU;GACV,YAAY,KAAK;GACjB,YAAY,KAAK;GACjB;GACA;GACA,WAAW,KAAK;GACjB;;;;;;;;;;;;;CAaH,QAAQ;AACN,SAAO;;;;;;;CAOT,UAAU;AACR,OAAK,OAAO,UAAU;AACtB,SAAO;;;;;;;;;CAST,QAAQ,OAAO;AACb,OAAK,OAAO,UAAU;AACtB,OAAK,OAAO,aAAa;AACzB,SAAO;;;;;;;;CAQT,WAAW,IAAI;AACb,OAAK,OAAO,YAAY;AACxB,OAAK,OAAO,aAAa;AACzB,SAAO;;;;;CAKT,WAAW,KAAK;;;;;;;;CAQhB,YAAY,IAAI;AACd,OAAK,OAAO,aAAa;AACzB,OAAK,OAAO,aAAa;AACzB,SAAO;;;;;CAKT,YAAY,KAAK;;;;;;CAMjB,aAAa;AACX,OAAK,OAAO,aAAa;AACzB,OAAK,OAAO,UAAU;AACtB,SAAO;;;CAGT,QAAQ,MAAM;AACZ,MAAI,KAAK,OAAO,SAAS,GAAI;AAC7B,OAAK,OAAO,OAAO"}

package/dist/node_modules/.bun/drizzle-orm@0.44.6_4fae081eecb963e2/node_modules/drizzle-orm/column.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"column.js","names":[],"sources":["../../../../../../../../node_modules/.bun/drizzle-orm@0.44.6+4fae081eecb963e2/node_modules/drizzle-orm/column.js"],"sourcesContent":["import { entityKind } from \"./entity.js\";\nclass Column {\n  constructor(table, config) {\n    this.table = table;\n    this.config = config;\n    this.name = config.name;\n    this.keyAsName = config.keyAsName;\n    this.notNull = config.notNull;\n    this.default = config.default;\n    this.defaultFn = config.defaultFn;\n    this.onUpdateFn = config.onUpdateFn;\n    this.hasDefault = config.hasDefault;\n    this.primary = config.primaryKey;\n    this.isUnique = config.isUnique;\n    this.uniqueName = config.uniqueName;\n    this.uniqueType = config.uniqueType;\n    this.dataType = config.dataType;\n    this.columnType = config.columnType;\n    this.generated = config.generated;\n    this.generatedIdentity = config.generatedIdentity;\n  }\n  static [entityKind] = \"Column\";\n  name;\n  keyAsName;\n  primary;\n  notNull;\n  default;\n  defaultFn;\n  onUpdateFn;\n  hasDefault;\n  isUnique;\n  uniqueName;\n  uniqueType;\n  dataType;\n  columnType;\n  enumValues = void 0;\n  generated = void 0;\n  generatedIdentity = void 0;\n  config;\n  mapFromDriverValue(value) {\n    return value;\n  }\n  mapToDriverValue(value) {\n    return value;\n  }\n  // ** @internal */\n  shouldDisableInsert() {\n    return this.config.generated !== void 0 && this.config.generated.type !== \"byDefault\";\n  }\n}\nexport {\n  Column\n};\n//# sourceMappingURL=column.js.map"],"x_google_ignoreList":[0],"mappings":";;;AACA,IAAM,SAAN,MAAa;CACX,YAAY,OAAO,QAAQ;AACzB,OAAK,QAAQ;AACb,OAAK,SAAS;AACd,OAAK,OAAO,OAAO;AACnB,OAAK,YAAY,OAAO;AACxB,OAAK,UAAU,OAAO;AACtB,OAAK,UAAU,OAAO;AACtB,OAAK,YAAY,OAAO;AACxB,OAAK,aAAa,OAAO;AACzB,OAAK,aAAa,OAAO;AACzB,OAAK,UAAU,OAAO;AACtB,OAAK,WAAW,OAAO;AACvB,OAAK,aAAa,OAAO;AACzB,OAAK,aAAa,OAAO;AACzB,OAAK,WAAW,OAAO;AACvB,OAAK,aAAa,OAAO;AACzB,OAAK,YAAY,OAAO;AACxB,OAAK,oBAAoB,OAAO;;CAElC,QAAQ,cAAc;CACtB;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA,aAAa,KAAK;CAClB,YAAY,KAAK;CACjB,oBAAoB,KAAK;CACzB;CACA,mBAAmB,OAAO;AACxB,SAAO;;CAET,iBAAiB,OAAO;AACtB,SAAO;;CAGT,sBAAsB;AACpB,SAAO,KAAK,OAAO,cAAc,KAAK,KAAK,KAAK,OAAO,UAAU,SAAS"}