@fragno-dev/db 0.1.14 → 0.2.0

package/src/schema/serialize.test.ts

@@ -1,306 +1,43 @@
-import { describe, expect, it } from "vitest";
-import { column, FragnoId } from "./create";
-import { dbToSchemaType, deserialize, schemaToDBType, serialize } from "./serialize";
+import { assert, describe, expect, it } from "vitest";
+import { column, referenceColumn, internalIdColumn } from "./create";
+import { createSQLSerializer } from "../query/serialize/create-sql-serializer";
+import type { AnyColumn } from "./create";
+import type { DriverConfig } from "../adapters/generic-sql/driver-config";
+import {
+  BetterSQLite3DriverConfig,
+  NodePostgresDriverConfig,
+  MySQL2DriverConfig,
+} from "../adapters/generic-sql/driver-config";
+
+function createMockDriverConfig(provider: string): DriverConfig {
+  if (provider === "postgresql" || provider === "cockroachdb") {
+    return new NodePostgresDriverConfig();
+  }
+  if (provider === "mysql") {
+    return new MySQL2DriverConfig();
+  }
+  return new BetterSQLite3DriverConfig();
+}
+
+// Helper functions for testing
+function deserialize(value: unknown, col: AnyColumn, provider: string) {
+  const driverConfig = createMockDriverConfig(provider);
+  const serializer = createSQLSerializer(driverConfig);
+  return serializer.deserialize(value, col);
+}
+
+function serialize(
+  value: unknown,
+  col: AnyColumn,
+  provider: string,
+  skipDriverConversions = false,
+) {
+  const driverConfig = createMockDriverConfig(provider);
+  const serializer = createSQLSerializer(driverConfig);
+  return serializer.serialize(value, col, skipDriverConversions);
+}
 
 describe("serialize", () => {
-  describe("dbToSchemaType", () => {
-    describe("sqlite", () => {
-      it("should map integer types correctly", () => {
-        expect(dbToSchemaType("integer", "sqlite", {})).toEqual([
-          "bool",
-          "date",
-          "timestamp",
-          "bigint",
-          "integer",
-        ]);
-        expect(dbToSchemaType("INTEGER", "sqlite", {})).toEqual([
-          "bool",
-          "date",
-          "timestamp",
-          "bigint",
-          "integer",
-        ]);
-      });
-
-      it("should map text types correctly", () => {
-        expect(dbToSchemaType("text", "sqlite", {})).toEqual([
-          "json",
-          "string",
-          "bigint",
-          "varchar(n)",
-        ]);
-      });
-
-      it("should map numeric types correctly", () => {
-        expect(dbToSchemaType("real", "sqlite", {})).toEqual(["decimal"]);
-        expect(dbToSchemaType("numeric", "sqlite", {})).toEqual(["decimal"]);
-      });
-
-      it("should map blob types correctly", () => {
-        expect(dbToSchemaType("blob", "sqlite", {})).toEqual(["bigint", "binary"]);
-      });
-    });
-
-    describe("postgresql", () => {
-      it("should map decimal types correctly", () => {
-        expect(dbToSchemaType("decimal", "postgresql", {})).toEqual(["decimal"]);
-        expect(dbToSchemaType("real", "postgresql", {})).toEqual(["decimal"]);
-        expect(dbToSchemaType("numeric", "postgresql", {})).toEqual(["decimal"]);
-        expect(dbToSchemaType("double precision", "postgresql", {})).toEqual(["decimal"]);
-      });
-
-      it("should map timestamp types correctly", () => {
-        expect(dbToSchemaType("timestamp", "postgresql", {})).toEqual(["timestamp"]);
-        expect(dbToSchemaType("timestamptz", "postgresql", {})).toEqual(["timestamp"]);
-      });
-
-      it("should map varchar with length correctly", () => {
-        expect(dbToSchemaType("varchar", "postgresql", { length: 255 })).toEqual(["varchar(255)"]);
-      });
-
-      it("should map varchar without length to string", () => {
-        expect(dbToSchemaType("varchar", "postgresql", {})).toEqual(["string"]);
-      });
-
-      it("should map text types correctly", () => {
-        expect(dbToSchemaType("text", "postgresql", {})).toEqual(["string"]);
-      });
-
-      it("should map boolean types correctly", () => {
-        expect(dbToSchemaType("boolean", "postgresql", {})).toEqual(["bool"]);
-        expect(dbToSchemaType("bool", "postgresql", {})).toEqual(["bool"]);
-      });
-
-      it("should map binary types correctly", () => {
-        expect(dbToSchemaType("bytea", "postgresql", {})).toEqual(["binary"]);
-      });
-    });
-
-    describe("cockroachdb", () => {
-      it("should behave like postgresql", () => {
-        expect(dbToSchemaType("timestamp", "cockroachdb", {})).toEqual(["timestamp"]);
-        expect(dbToSchemaType("text", "cockroachdb", {})).toEqual(["string"]);
-      });
-    });
-
-    describe("mysql", () => {
-      it("should map boolean types correctly", () => {
-        expect(dbToSchemaType("bool", "mysql", {})).toEqual(["bool"]);
-        expect(dbToSchemaType("boolean", "mysql", {})).toEqual(["bool"]);
-      });
-
-      it("should map integer types correctly", () => {
-        expect(dbToSchemaType("integer", "mysql", {})).toEqual(["integer"]);
-        expect(dbToSchemaType("int", "mysql", {})).toEqual(["integer"]);
-      });
-
-      it("should map decimal types correctly", () => {
-        expect(dbToSchemaType("decimal", "mysql", {})).toEqual(["decimal"]);
-        expect(dbToSchemaType("numeric", "mysql", {})).toEqual(["decimal"]);
-        expect(dbToSchemaType("float", "mysql", {})).toEqual(["decimal"]);
-        expect(dbToSchemaType("double", "mysql", {})).toEqual(["decimal"]);
-      });
-
-      it("should map datetime types correctly", () => {
-        expect(dbToSchemaType("datetime", "mysql", {})).toEqual(["timestamp"]);
-      });
-
-      it("should map varchar with length correctly", () => {
-        expect(dbToSchemaType("varchar", "mysql", { length: 100 })).toEqual(["varchar(100)"]);
-      });
-
-      it("should map varchar without length to string", () => {
-        expect(dbToSchemaType("varchar", "mysql", {})).toEqual(["string"]);
-      });
-
-      it("should map text types correctly", () => {
-        expect(dbToSchemaType("text", "mysql", {})).toEqual(["string"]);
-      });
-
-      it("should map blob types correctly", () => {
-        expect(dbToSchemaType("longblob", "mysql", {})).toEqual(["binary"]);
-        expect(dbToSchemaType("blob", "mysql", {})).toEqual(["binary"]);
-        expect(dbToSchemaType("mediumblob", "mysql", {})).toEqual(["binary"]);
-        expect(dbToSchemaType("tinyblob", "mysql", {})).toEqual(["binary"]);
-      });
-    });
-
-    describe("mssql", () => {
-      it("should map integer types correctly", () => {
-        expect(dbToSchemaType("int", "mssql", {})).toEqual(["integer"]);
-      });
-
-      it("should map decimal types correctly", () => {
-        expect(dbToSchemaType("decimal", "mssql", {})).toEqual(["decimal"]);
-        expect(dbToSchemaType("float", "mssql", {})).toEqual(["decimal"]);
-        expect(dbToSchemaType("real", "mssql", {})).toEqual(["decimal"]);
-        expect(dbToSchemaType("numeric", "mssql", {})).toEqual(["decimal"]);
-      });
-
-      it("should map bit type correctly", () => {
-        expect(dbToSchemaType("bit", "mssql", {})).toEqual(["bool"]);
-      });
-
-      it("should map datetime types correctly", () => {
-        expect(dbToSchemaType("datetime", "mssql", {})).toEqual(["timestamp"]);
-        expect(dbToSchemaType("datetime2", "mssql", {})).toEqual(["timestamp"]);
-      });
-
-      it("should map varchar with length correctly", () => {
-        expect(dbToSchemaType("varchar", "mssql", { length: 50 })).toEqual(["varchar(50)"]);
-        expect(dbToSchemaType("nvarchar", "mssql", { length: 50 })).toEqual(["varchar(50)"]);
-      });
-
-      it("should map varchar without length to string/json", () => {
-        expect(dbToSchemaType("varchar", "mssql", {})).toEqual(["string", "json"]);
-        expect(dbToSchemaType("nvarchar", "mssql", {})).toEqual(["string", "json"]);
-      });
-
-      it("should map text types correctly", () => {
-        expect(dbToSchemaType("ntext", "mssql", {})).toEqual(["string", "json"]);
-        expect(dbToSchemaType("text", "mssql", {})).toEqual(["string", "json"]);
-        expect(dbToSchemaType("varchar(max)", "mssql", {})).toEqual(["string", "json"]);
-        expect(dbToSchemaType("nvarchar(max)", "mssql", {})).toEqual(["string", "json"]);
-      });
-
-      it("should map binary types correctly", () => {
-        expect(dbToSchemaType("binary", "mssql", {})).toEqual(["binary"]);
-        expect(dbToSchemaType("varbinary", "mssql", {})).toEqual(["binary"]);
-      });
-    });
-  });
-
-  describe("schemaToDBType", () => {
-    describe("sqlite", () => {
-      it("should convert integer types to integer", () => {
-        expect(schemaToDBType(column("integer"), "sqlite")).toBe("integer");
-      });
-
-      it("should convert timestamp to integer", () => {
-        expect(schemaToDBType(column("timestamp"), "sqlite")).toBe("integer");
-      });
-
-      it("should convert date to integer", () => {
-        expect(schemaToDBType(column("date"), "sqlite")).toBe("integer");
-      });
-
-      it("should convert bool to integer", () => {
-        expect(schemaToDBType(column("bool"), "sqlite")).toBe("integer");
-      });
-
-      it("should convert binary to blob", () => {
-        expect(schemaToDBType(column("binary"), "sqlite")).toBe("blob");
-      });
-
-      it("should convert bigint to blob", () => {
-        expect(schemaToDBType(column("bigint"), "sqlite")).toBe("blob");
-      });
-
-      it("should convert json to text", () => {
-        expect(schemaToDBType(column("json"), "sqlite")).toBe("text");
-      });
-
-      it("should convert string to text", () => {
-        expect(schemaToDBType(column("string"), "sqlite")).toBe("text");
-      });
-
-      it("should convert varchar to text", () => {
-        expect(schemaToDBType({ type: "varchar(255)" }, "sqlite")).toBe("text");
-      });
-
-      it("should convert decimal to real", () => {
-        expect(schemaToDBType(column("decimal"), "sqlite")).toBe("real");
-      });
-    });
-
-    describe("mssql", () => {
-      it("should convert bool to bit", () => {
-        expect(schemaToDBType(column("bool"), "mssql")).toBe("bit");
-      });
-
-      it("should convert timestamp to datetime", () => {
-        expect(schemaToDBType(column("timestamp"), "mssql")).toBe("datetime");
-      });
-
-      it("should convert integer to int", () => {
-        expect(schemaToDBType(column("integer"), "mssql")).toBe("int");
-      });
-
-      it("should convert string to varchar(max)", () => {
-        expect(schemaToDBType(column("string"), "mssql")).toBe("varchar(max)");
-      });
-
-      it("should convert binary to varbinary(max)", () => {
-        expect(schemaToDBType(column("binary"), "mssql")).toBe("varbinary(max)");
-      });
-
-      it("should convert json to varchar(max)", () => {
-        expect(schemaToDBType(column("json"), "mssql")).toBe("varchar(max)");
-      });
-
-      it("should preserve varchar with length", () => {
-        expect(schemaToDBType({ type: "varchar(100)" }, "mssql")).toBe("varchar(100)");
-      });
-    });
-
-    describe("postgresql", () => {
-      it("should convert bool to boolean", () => {
-        expect(schemaToDBType(column("bool"), "postgresql")).toBe("boolean");
-      });
-
-      it("should convert json to json", () => {
-        expect(schemaToDBType(column("json"), "postgresql")).toBe("json");
-      });
-
-      it("should convert string to text", () => {
-        expect(schemaToDBType(column("string"), "postgresql")).toBe("text");
-      });
-
-      it("should convert binary to bytea", () => {
-        expect(schemaToDBType(column("binary"), "postgresql")).toBe("bytea");
-      });
-
-      it("should preserve varchar with length", () => {
-        expect(schemaToDBType({ type: "varchar(200)" }, "postgresql")).toBe("varchar(200)");
-      });
-
-      it("should preserve other types", () => {
-        expect(schemaToDBType(column("timestamp"), "postgresql")).toBe("timestamp");
-        expect(schemaToDBType(column("integer"), "postgresql")).toBe("integer");
-      });
-    });
-
-    describe("cockroachdb", () => {
-      it("should behave like postgresql", () => {
-        expect(schemaToDBType(column("bool"), "cockroachdb")).toBe("boolean");
-        expect(schemaToDBType(column("string"), "cockroachdb")).toBe("text");
-      });
-    });
-
-    describe("mysql", () => {
-      it("should convert bool to boolean", () => {
-        expect(schemaToDBType(column("bool"), "mysql")).toBe("boolean");
-      });
-
-      it("should convert string to text", () => {
-        expect(schemaToDBType(column("string"), "mysql")).toBe("text");
-      });
-
-      it("should convert binary to longblob", () => {
-        expect(schemaToDBType(column("binary"), "mysql")).toBe("longblob");
-      });
-
-      it("should preserve varchar with length", () => {
-        expect(schemaToDBType({ type: "varchar(150)" }, "mysql")).toBe("varchar(150)");
-      });
-
-      it("should preserve other types", () => {
-        expect(schemaToDBType(column("integer"), "mysql")).toBe("integer");
-        expect(schemaToDBType(column("json"), "mysql")).toBe("json");
-      });
-    });
-  });
-
   describe("deserialize", () => {
     it("should return null for null values", () => {
       expect(deserialize(null, column("string"), "sqlite")).toBe(null);
@@ -347,7 +84,7 @@ describe("serialize", () => {
         const timestampCol = column("timestamp");
         const time = "2024-06-15T14:30:00+05:30"; // India Standard Time
         const result = deserialize(time, timestampCol, "sqlite");
-        expect(result).toBeInstanceOf(Date);
+        assert.instanceOf(result, Date);
         expect(result.toISOString()).toBe("2024-06-15T09:00:00.000Z");
       });
 
@@ -355,7 +92,7 @@ describe("serialize", () => {
         const timestampCol = column("timestamp");
         const time = "2024-06-15T14:30:00-08:00"; // Pacific Time
         const result = deserialize(time, timestampCol, "sqlite");
-        expect(result).toBeInstanceOf(Date);
+        assert.instanceOf(result, Date);
         expect(result.toISOString()).toBe("2024-06-15T22:30:00.000Z");
       });
 
@@ -366,7 +103,7 @@ describe("serialize", () => {
         const numericTimestamp = specificDate.getTime();
 
         const result = deserialize(numericTimestamp, timestampCol, "sqlite");
-        expect(result).toBeInstanceOf(Date);
+        assert.instanceOf(result, Date);
         expect(result.getTime()).toBe(numericTimestamp);
         expect(result.toISOString()).toBe("2024-06-15T12:00:00.000Z");
       });
@@ -376,6 +113,7 @@ describe("serialize", () => {
         // Start with a date with timezone info
         const originalTime = "2024-06-15T14:30:00+02:00";
         const deserialized = deserialize(originalTime, timestampCol, "sqlite");
+        assert.instanceOf(deserialized, Date);
 
         // SQLite would store this as a number
         const numericValue = deserialized.getTime();
@@ -383,7 +121,7 @@ describe("serialize", () => {
         // Deserialize the numeric value back
         const roundTrip = deserialize(numericValue, timestampCol, "sqlite");
 
-        expect(roundTrip).toBeInstanceOf(Date);
+        assert.instanceOf(roundTrip, Date);
         expect(roundTrip.getTime()).toBe(deserialized.getTime());
         expect(roundTrip.toISOString()).toBe(deserialized.toISOString());
       });
@@ -412,7 +150,7 @@ describe("serialize", () => {
         const timestampCol = column("timestamp");
         const time = "2024-06-15T14:30:00+05:30"; // India Standard Time
         const result = deserialize(time, timestampCol, "postgresql");
-        expect(result).toBeInstanceOf(Date);
+        assert.instanceOf(result, Date);
         expect(result.toISOString()).toBe("2024-06-15T09:00:00.000Z");
       });
 
@@ -420,7 +158,7 @@ describe("serialize", () => {
         const timestampCol = column("timestamp");
         const time = "2024-06-15T14:30:00-08:00"; // Pacific Time
         const result = deserialize(time, timestampCol, "postgresql");
-        expect(result).toBeInstanceOf(Date);
+        assert.instanceOf(result, Date);
         expect(result.toISOString()).toBe("2024-06-15T22:30:00.000Z");
       });
 
@@ -428,7 +166,7 @@ describe("serialize", () => {
         const timestampCol = column("timestamp");
         const time = "2024-06-15T14:30:45.123+01:00"; // Central European Time
         const result = deserialize(time, timestampCol, "postgresql");
-        expect(result).toBeInstanceOf(Date);
+        assert.instanceOf(result, Date);
         expect(result.toISOString()).toBe("2024-06-15T13:30:45.123Z");
         expect(result.getTime()).toBe(new Date("2024-06-15T13:30:45.123Z").getTime());
       });
@@ -444,6 +182,10 @@ describe("serialize", () => {
         const estResult = deserialize(estTime, timestampCol, "postgresql");
         const jstResult = deserialize(jstTime, timestampCol, "postgresql");
 
+        assert.instanceOf(utcResult, Date);
+        assert.instanceOf(estResult, Date);
+        assert.instanceOf(jstResult, Date);
+
         // All should represent the same absolute time
         expect(utcResult.getTime()).toBe(estResult.getTime());
         expect(utcResult.getTime()).toBe(jstResult.getTime());
@@ -474,7 +216,7 @@ describe("serialize", () => {
         const timestampCol = column("timestamp");
         const time = "2024-06-15T14:30:00+05:30"; // India Standard Time
         const result = deserialize(time, timestampCol, "mysql");
-        expect(result).toBeInstanceOf(Date);
+        assert.instanceOf(result, Date);
         expect(result.toISOString()).toBe("2024-06-15T09:00:00.000Z");
       });
 
@@ -482,7 +224,7 @@ describe("serialize", () => {
         const timestampCol = column("timestamp");
         const time = "2024-06-15T14:30:00-08:00"; // Pacific Time
         const result = deserialize(time, timestampCol, "mysql");
-        expect(result).toBeInstanceOf(Date);
+        assert.instanceOf(result, Date);
         expect(result.toISOString()).toBe("2024-06-15T22:30:00.000Z");
       });
 
@@ -490,7 +232,7 @@ describe("serialize", () => {
         const timestampCol = column("timestamp");
         const time = "2024-06-15T14:30:45.123+01:00"; // Central European Time
         const result = deserialize(time, timestampCol, "mysql");
-        expect(result).toBeInstanceOf(Date);
+        assert.instanceOf(result, Date);
         expect(result.toISOString()).toBe("2024-06-15T13:30:45.123Z");
       });
 
@@ -505,6 +247,10 @@ describe("serialize", () => {
         const cstResult = deserialize(cstTime, timestampCol, "mysql");
         const pstResult = deserialize(pstTime, timestampCol, "mysql");
 
+        assert.instanceOf(utcResult, Date);
+        assert.instanceOf(cstResult, Date);
+        assert.instanceOf(pstResult, Date);
+
         // All should represent the same absolute time
         expect(utcResult.getTime()).toBe(cstResult.getTime());
         expect(utcResult.getTime()).toBe(pstResult.getTime());
@@ -529,7 +275,7 @@ describe("serialize", () => {
         const timestampCol = column("timestamp");
         const time = "2024-06-15T14:30:00+05:30"; // India Standard Time
         const result = deserialize(time, timestampCol, "cockroachdb");
-        expect(result).toBeInstanceOf(Date);
+        assert.instanceOf(result, Date);
         expect(result.toISOString()).toBe("2024-06-15T09:00:00.000Z");
       });
 
@@ -537,7 +283,7 @@ describe("serialize", () => {
         const timestampCol = column("timestamp");
         const time = "2024-06-15T14:30:00-08:00"; // Pacific Time
         const result = deserialize(time, timestampCol, "cockroachdb");
-        expect(result).toBeInstanceOf(Date);
+        assert.instanceOf(result, Date);
         expect(result.toISOString()).toBe("2024-06-15T22:30:00.000Z");
       });
 
@@ -545,7 +291,7 @@ describe("serialize", () => {
         const timestampCol = column("timestamp");
         const time = "2024-06-15T14:30:45.123+01:00"; // Central European Time
         const result = deserialize(time, timestampCol, "cockroachdb");
-        expect(result).toBeInstanceOf(Date);
+        assert.instanceOf(result, Date);
         expect(result.toISOString()).toBe("2024-06-15T13:30:45.123Z");
       });
 
@@ -560,6 +306,10 @@ describe("serialize", () => {
         const aestResult = deserialize(aestTime, timestampCol, "cockroachdb");
         const brtResult = deserialize(brtTime, timestampCol, "cockroachdb");
 
+        assert.instanceOf(utcResult, Date);
+        assert.instanceOf(aestResult, Date);
+        assert.instanceOf(brtResult, Date);
+
         // All should represent the same absolute time
         expect(utcResult.getTime()).toBe(aestResult.getTime());
         expect(utcResult.getTime()).toBe(brtResult.getTime());
@@ -607,8 +357,8 @@ describe("serialize", () => {
         const binaryCol = column("binary");
         const buffer = Buffer.from([1, 2, 3, 4]);
         const result = deserialize(buffer, binaryCol, "postgresql");
-        expect(result).toBeInstanceOf(Uint8Array);
-        expect(Array.from(result as Uint8Array)).toEqual([1, 2, 3, 4]);
+        assert.instanceOf(result, Uint8Array);
+        expect(Array.from(result)).toEqual([1, 2, 3, 4]);
       });
     });
   });
@@ -660,8 +410,8 @@ describe("serialize", () => {
       it("should convert bigint to Buffer", () => {
         const bigintValue = 123456789n;
         const result = serialize(bigintValue, column("bigint"), "sqlite");
-        expect(result).toBeInstanceOf(Buffer);
-        expect((result as Buffer).readBigInt64BE(0)).toBe(bigintValue);
+        assert.instanceOf(result, Buffer);
+        expect(result.readBigInt64BE(0)).toBe(bigintValue);
       });
     });
 
@@ -670,8 +420,8 @@ describe("serialize", () => {
         const binaryCol = column("binary");
         const uint8 = new Uint8Array([1, 2, 3, 4]);
         const result = serialize(uint8, binaryCol, "postgresql");
-        expect(result).toBeInstanceOf(Buffer);
-        expect(Array.from(result as Buffer)).toEqual([1, 2, 3, 4]);
+        assert.instanceOf(result, Buffer);
+        expect(Array.from(result)).toEqual([1, 2, 3, 4]);
       });
 
       it("should handle Buffer as-is", () => {
@@ -679,7 +429,7 @@ describe("serialize", () => {
         const buffer = Buffer.from([1, 2, 3, 4]);
         const result = serialize(buffer, binaryCol, "mysql");
         // Buffer is also a Uint8Array, so it should be converted
-        expect(result).toBeInstanceOf(Buffer);
+        assert.instanceOf(result, Buffer);
       });
     });
 
@@ -691,92 +441,100 @@ describe("serialize", () => {
       });
     });
 
-    describe("FragnoId handling", () => {
-      it("should serialize FragnoId for external-id column", () => {
-        const externalIdCol = column("string");
-        externalIdCol.role = "external-id";
-        const fragnoId = FragnoId.fromExternal("user123", 0);
-
-        expect(serialize(fragnoId, externalIdCol, "postgresql")).toBe("user123");
-        expect(serialize(fragnoId, externalIdCol, "sqlite")).toBe("user123");
-        expect(serialize(fragnoId, externalIdCol, "mysql")).toBe("user123");
-      });
-
-      it("should serialize FragnoId for internal-id column", () => {
-        const internalIdCol = column("bigint");
-        internalIdCol.role = "internal-id";
-        const fragnoId = new FragnoId({
-          externalId: "user123",
-          internalId: BigInt(456),
-          version: 0,
-        });
-
-        expect(serialize(fragnoId, internalIdCol, "postgresql")).toBe(BigInt(456));
-        expect(serialize(fragnoId, internalIdCol, "sqlite")).toBe(BigInt(456));
-        expect(serialize(fragnoId, internalIdCol, "mysql")).toBe(BigInt(456));
-      });
-
-      it("should throw error when FragnoId lacks internal ID for internal-id column", () => {
-        const internalIdCol = column("bigint");
-        internalIdCol.role = "internal-id";
-        const fragnoId = FragnoId.fromExternal("user123", 0);
-
-        expect(() => serialize(fragnoId, internalIdCol, "postgresql")).toThrow(
-          "FragnoId must have internalId for internal-id column",
-        );
-      });
-
-      it("should serialize FragnoId for reference column (prefer internal ID)", () => {
-        const referenceCol = column("bigint");
-        referenceCol.role = "reference";
-        const fragnoId = new FragnoId({
-          externalId: "user123",
-          internalId: BigInt(456),
-          version: 0,
-        });
-
-        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", () => {
-        const referenceCol = column("bigint");
-        referenceCol.role = "reference";
-        const fragnoId = FragnoId.fromExternal("user123", 0);
-
-        expect(serialize(fragnoId, referenceCol, "postgresql")).toBe("user123");
-        expect(serialize(fragnoId, referenceCol, "sqlite")).toBe("user123");
-      });
-
-      it("should serialize FragnoId for regular column (use external ID)", () => {
-        const regularCol = column("string");
-        regularCol.role = "regular";
-        const fragnoId = new FragnoId({
-          externalId: "user123",
-          internalId: BigInt(456),
-          version: 0,
-        });
-
-        expect(serialize(fragnoId, regularCol, "postgresql")).toBe("user123");
-        expect(serialize(fragnoId, regularCol, "mysql")).toBe("user123");
-      });
-
-      it("should handle FragnoId serialization with different providers", () => {
-        const externalIdCol = column("string");
-        externalIdCol.role = "external-id";
-        const fragnoId = new FragnoId({
-          externalId: "user123",
-          internalId: BigInt(456),
-          version: 0,
-        });
-
-        // Test across different providers
-        expect(serialize(fragnoId, externalIdCol, "sqlite")).toBe("user123");
-        expect(serialize(fragnoId, externalIdCol, "postgresql")).toBe("user123");
-        expect(serialize(fragnoId, externalIdCol, "mysql")).toBe("user123");
-        expect(serialize(fragnoId, externalIdCol, "mssql")).toBe("user123");
-        expect(serialize(fragnoId, externalIdCol, "cockroachdb")).toBe("user123");
+    describe("skipDriverConversions", () => {
+      it("should skip Date to number conversion for SQLite when enabled", () => {
+        const date = new Date("2024-01-01T00:00:00.000Z");
+        const timestampCol = column("timestamp");
+
+        // Default behavior: converts to number
+        const withConversion = serialize(date, timestampCol, "sqlite", false);
+        expect(withConversion).toBe(date.getTime());
+        expect(typeof withConversion).toBe("number");
+
+        // With skipDriverConversions: passes through Date
+        const withoutConversion = serialize(date, timestampCol, "sqlite", true);
+        expect(withoutConversion).toBe(date);
+        assert.instanceOf(withoutConversion, Date);
+      });
+
+      it("should skip boolean to number conversion for SQLite when enabled", () => {
+        const boolCol = column("bool");
+
+        // Default behavior: converts to 0/1
+        expect(serialize(true, boolCol, "sqlite", false)).toBe(1);
+        expect(serialize(false, boolCol, "sqlite", false)).toBe(0);
+
+        // With skipDriverConversions: passes through boolean
+        expect(serialize(true, boolCol, "sqlite", true)).toBe(true);
+        expect(serialize(false, boolCol, "sqlite", true)).toBe(false);
+      });
+
+      it("should skip bigint to Buffer conversion for SQLite when enabled", () => {
+        const bigintValue = 123456789n;
+        const bigintCol = column("bigint");
+
+        // Default behavior: converts to Buffer
+        const withConversion = serialize(bigintValue, bigintCol, "sqlite", false);
+        assert.instanceOf(withConversion, Buffer);
+        expect(withConversion.readBigInt64BE(0)).toBe(bigintValue);
+
+        // With skipDriverConversions: passes through bigint
+        const withoutConversion = serialize(bigintValue, bigintCol, "sqlite", true);
+        expect(withoutConversion).toBe(bigintValue);
+        expect(typeof withoutConversion).toBe("bigint");
+      });
+
+      it("should skip reference column bigint to Number conversion for SQLite when enabled", () => {
+        const bigintValue = 123456789n;
+        const refCol = referenceColumn();
+
+        // Default behavior: converts to Number for reference columns
+        const withConversion = serialize(bigintValue, refCol, "sqlite", false);
+        expect(withConversion).toBe(123456789);
+        expect(typeof withConversion).toBe("number");
+
+        // With skipDriverConversions: passes through bigint
+        const withoutConversion = serialize(bigintValue, refCol, "sqlite", true);
+        expect(withoutConversion).toBe(bigintValue);
+        expect(typeof withoutConversion).toBe("bigint");
+      });
+
+      it("should skip internal-id column bigint to Number conversion for SQLite when enabled", () => {
+        const bigintValue = 123456789n;
+        const internalIdCol = internalIdColumn();
+
+        // Default behavior: converts to Number for internal-id columns
+        const withConversion = serialize(bigintValue, internalIdCol, "sqlite", false);
+        expect(withConversion).toBe(123456789);
+        expect(typeof withConversion).toBe("number");
+
+        // With skipDriverConversions: passes through bigint
+        const withoutConversion = serialize(bigintValue, internalIdCol, "sqlite", true);
+        expect(withoutConversion).toBe(bigintValue);
+        expect(typeof withoutConversion).toBe("bigint");
+      });
+
+      it("should still handle JSON stringification when skipDriverConversions is enabled", () => {
+        const jsonCol = column("json");
+        const obj = { key: "value" };
+
+        // JSON stringification happens regardless of skipDriverConversions
+        expect(serialize(obj, jsonCol, "sqlite", false)).toBe('{"key":"value"}');
+        expect(serialize(obj, jsonCol, "sqlite", true)).toBe('{"key":"value"}');
+      });
+
+      it("should still handle binary conversion when skipDriverConversions is enabled", () => {
+        const binaryCol = column("binary");
+        const uint8 = new Uint8Array([1, 2, 3, 4]);
+
+        // Binary conversion happens regardless of skipDriverConversions
+        const withConversion = serialize(uint8, binaryCol, "sqlite", false);
+        assert.instanceOf(withConversion, Buffer);
+        expect(Array.from(withConversion)).toEqual([1, 2, 3, 4]);
+
+        const withoutConversion = serialize(uint8, binaryCol, "sqlite", true);
+        assert.instanceOf(withoutConversion, Buffer);
+        expect(Array.from(withoutConversion)).toEqual([1, 2, 3, 4]);
       });
     });
   });