@fragno-dev/db 0.1.15 → 0.2.0

package/src/query/{result-transform.test.ts → value-decoding.test.ts}

@@ -1,397 +1,11 @@
 import { assert, describe, expect, it } from "vitest";
 import { column, idColumn, referenceColumn, schema, FragnoId } from "../schema/create";
-import { decodeResult, encodeValues, ReferenceSubquery } from "./result-transform";
-
-describe("encodeValues", () => {
-  const testSchema = schema((s) => {
-    return s
-      .addTable("users", (t) => {
-        return t
-          .addColumn("id", idColumn())
-          .addColumn("name", column("string"))
-          .addColumn("email", column("string"))
-          .addColumn("age", column("integer").nullable())
-          .addColumn("isActive", column("bool"))
-          .addColumn("createdAt", column("timestamp"));
-      })
-      .addTable("posts", (t) => {
-        return t
-          .addColumn("id", idColumn())
-          .addColumn("title", column("string"))
-          .addColumn("userId", referenceColumn())
-          .addColumn("viewCount", column("integer").defaultTo(0))
-          .addColumn("publishedAt", column("timestamp").nullable());
-      })
-      .addReference("author", {
-        type: "one",
-        from: { table: "posts", column: "userId" },
-        to: { table: "users", column: "id" },
-      });
-  });
-
-  const usersTable = testSchema.tables.users;
-  const postsTable = testSchema.tables.posts;
-
-  describe("basic encoding", () => {
-    it("should encode string values", () => {
-      const result = encodeValues(
-        { id: "user1", name: "John", email: "john@example.com" },
-        usersTable,
-        false,
-        "sqlite",
-      );
-
-      expect(result).toEqual({
-        id: "user1",
-        name: "John",
-        email: "john@example.com",
-      });
-    });
-
-    it("should encode integer values", () => {
-      const result = encodeValues({ age: 25 }, usersTable, false, "sqlite");
-
-      expect(result).toEqual({ age: 25 });
-    });
-
-    it("should encode boolean values for sqlite", () => {
-      const result = encodeValues({ isActive: true }, usersTable, false, "sqlite");
-
-      expect(result).toEqual({ isActive: 1 });
-    });
-
-    it("should encode boolean values for postgresql", () => {
-      const result = encodeValues({ isActive: true }, usersTable, false, "postgresql");
-
-      expect(result).toEqual({ isActive: true });
-    });
-  });
-
-  describe("date encoding", () => {
-    it("should encode Date to number for sqlite", () => {
-      const date = new Date("2024-01-15T10:30:00Z");
-      const result = encodeValues({ createdAt: date }, usersTable, false, "sqlite");
-
-      expect(result).toEqual({ createdAt: date.getTime() });
-    });
-
-    it("should keep Date as Date for postgresql", () => {
-      const date = new Date("2024-01-15T10:30:00Z");
-      const result = encodeValues({ createdAt: date }, usersTable, false, "postgresql");
-
-      expect(result).toEqual({ createdAt: date });
-    });
-
-    it("should keep Date as Date for mysql", () => {
-      const date = new Date("2024-01-15T10:30:00Z");
-      const result = encodeValues({ createdAt: date }, usersTable, false, "mysql");
-
-      expect(result).toEqual({ createdAt: date });
-    });
-  });
-
-  describe("nullable columns", () => {
-    it("should handle null values", () => {
-      const result = encodeValues({ age: null }, usersTable, false, "sqlite");
-
-      expect(result).toEqual({ age: null });
-    });
-
-    it("should omit undefined values", () => {
-      const result = encodeValues({ age: undefined }, usersTable, false, "sqlite");
-
-      expect(result).toEqual({});
-    });
-
-    it("should handle nullable timestamp", () => {
-      const result = encodeValues({ publishedAt: null }, postsTable, false, "sqlite");
-
-      expect(result).toEqual({ publishedAt: null });
-    });
-  });
-
-  describe("default value generation", () => {
-    it("should generate runtime defaults when generateDefault is true", () => {
-      const result = encodeValues(
-        { title: "Test Post", userId: "user1" },
-        postsTable,
-        true,
-        "sqlite",
-      );
-
-      expect(result["title"]).toBe("Test Post");
-      expect(result["userId"]).instanceOf(ReferenceSubquery);
-      // viewCount has static default (defaultTo), so it's omitted to let DB handle it
-      expect(result["viewCount"]).toBeUndefined();
-      expect(result["id"]).toBeDefined();
-      expect(typeof result["id"]).toBe("string");
-    });
-
-    it("should not generate default values when generateDefault is false", () => {
-      const result = encodeValues(
-        { title: "Test Post", userId: "user1" },
-        postsTable,
-        false,
-        "sqlite",
-      );
-
-      expect(result).toEqual({
-        title: "Test Post",
-        userId: expect.any(ReferenceSubquery),
-      });
-    });
-
-    it("should not override explicitly provided values", () => {
-      const result = encodeValues(
-        { title: "Test Post", userId: "user1", viewCount: 100 },
-        postsTable,
-        true,
-        "sqlite",
-      );
-
-      expect(result["viewCount"]).toBe(100);
-    });
-  });
-
-  describe("complete record encoding", () => {
-    it("should encode all fields correctly", () => {
-      const date = new Date("2024-01-15T10:30:00Z");
-      const result = encodeValues(
-        {
-          id: "user1",
-          name: "Alice",
-          email: "alice@example.com",
-          age: 30,
-          isActive: false,
-          createdAt: date,
-        },
-        usersTable,
-        false,
-        "sqlite",
-      );
-
-      expect(result).toEqual({
-        id: "user1",
-        name: "Alice",
-        email: "alice@example.com",
-        age: 30,
-        isActive: 0,
-        createdAt: date.getTime(),
-      });
-    });
-  });
-
-  describe("FragnoId encoding", () => {
-    it("should encode FragnoId with external ID only", () => {
-      const fragnoId = FragnoId.fromExternal("user123", 1);
-      const result = encodeValues({ id: fragnoId, name: "John" }, usersTable, false, "postgresql");
-
-      expect(result).toEqual({
-        id: "user123",
-        name: "John",
-      });
-    });
-
-    it("should encode FragnoId with both IDs", () => {
-      const fragnoId = new FragnoId({
-        externalId: "user123",
-        internalId: BigInt(456),
-        version: 1,
-      });
-      const result = encodeValues({ id: fragnoId, name: "John" }, usersTable, false, "postgresql");
-
-      expect(result).toEqual({
-        id: "user123",
-        name: "John",
-      });
-    });
-
-    it("should encode FragnoId in reference columns", () => {
-      const fragnoId = new FragnoId({
-        externalId: "user123",
-        internalId: BigInt(456),
-        version: 1,
-      });
-      const result = encodeValues(
-        { title: "Test Post", userId: fragnoId },
-        postsTable,
-        false,
-        "postgresql",
-      );
-
-      // Reference columns should use the internal ID (bigint)
-      expect(result).toEqual({
-        title: "Test Post",
-        userId: BigInt(456),
-      });
-    });
-
-    it("should convert FragnoId without internalId to ReferenceSubquery for reference columns", () => {
-      const fragnoId = new FragnoId({
-        externalId: "user123",
-        version: 1,
-      });
-      const result = encodeValues(
-        { title: "Test Post", userId: fragnoId },
-        postsTable,
-        false,
-        "postgresql",
-      );
-
-      // FragnoId without internalId should be converted to ReferenceSubquery for database lookup
-      expect(result["title"]).toBe("Test Post");
-      expect(result["userId"]).toBeInstanceOf(ReferenceSubquery);
-      expect((result["userId"] as ReferenceSubquery).externalIdValue).toBe("user123");
-    });
-
-    it("should handle FragnoId across different providers", () => {
-      const fragnoId = new FragnoId({
-        externalId: "user123",
-        internalId: BigInt(456),
-        version: 1,
-      });
-      const testData = { id: fragnoId, name: "John" };
-
-      // Test across providers
-      const sqliteResult = encodeValues(testData, usersTable, false, "sqlite");
-      const postgresqlResult = encodeValues(testData, usersTable, false, "postgresql");
-      const mysqlResult = encodeValues(testData, usersTable, false, "mysql");
-
-      expect(sqliteResult).toEqual({ id: "user123", name: "John" });
-      expect(postgresqlResult).toEqual({ id: "user123", name: "John" });
-      expect(mysqlResult).toEqual({ id: "user123", name: "John" });
-    });
-  });
-
-  describe("skipDriverConversions parameter", () => {
-    it("should skip Date to number conversion for sqlite when skipDriverConversions is true", () => {
-      const date = new Date("2024-01-15T10:30:00Z");
-      const result = encodeValues({ createdAt: date }, usersTable, false, "sqlite", true);
-
-      // Date should remain as Date object, not converted to timestamp
-      expect(result).toEqual({ createdAt: date });
-    });
-
-    it("should skip boolean to number conversion for sqlite when skipDriverConversions is true", () => {
-      const result = encodeValues({ isActive: true }, usersTable, false, "sqlite", true);
-
-      // Boolean should remain as boolean, not converted to 1
-      expect(result).toEqual({ isActive: true });
-    });
-
-    it("should skip bigint to Buffer conversion for sqlite when skipDriverConversions is true", () => {
-      const schemaWithBigInt = schema((s) => {
-        return s.addTable("items", (t) => {
-          return t.addColumn("id", idColumn()).addColumn("count", column("bigint"));
-        });
-      });
-
-      const result = encodeValues(
-        { count: BigInt(12345) },
-        schemaWithBigInt.tables.items,
-        false,
-        "sqlite",
-        true,
-      );
-
-      // BigInt should remain as bigint, not converted to Buffer
-      expect(result).toEqual({ count: BigInt(12345) });
-    });
-
-    it("should still perform conversions for sqlite when skipDriverConversions is false", () => {
-      const date = new Date("2024-01-15T10:30:00Z");
-      const result = encodeValues(
-        { createdAt: date, isActive: true },
-        usersTable,
-        false,
-        "sqlite",
-        false,
-      );
-
-      // Conversions should happen as normal
-      expect(result).toEqual({ createdAt: date.getTime(), isActive: 1 });
-    });
-
-    it("should not affect PostgreSQL encoding (no conversions to skip)", () => {
-      const date = new Date("2024-01-15T10:30:00Z");
-      const resultWithSkip = encodeValues(
-        { createdAt: date },
-        usersTable,
-        false,
-        "postgresql",
-        true,
-      );
-      const resultWithoutSkip = encodeValues(
-        { createdAt: date },
-        usersTable,
-        false,
-        "postgresql",
-        false,
-      );
-
-      // Both should be the same since PostgreSQL doesn't do these conversions
-      expect(resultWithSkip).toEqual({ createdAt: date });
-      expect(resultWithoutSkip).toEqual({ createdAt: date });
-    });
-
-    it("should work with complete record encoding when skipDriverConversions is true", () => {
-      const date = new Date("2024-01-15T10:30:00Z");
-      const result = encodeValues(
-        {
-          id: "user1",
-          name: "Alice",
-          email: "alice@example.com",
-          age: 30,
-          isActive: false,
-          createdAt: date,
-        },
-        usersTable,
-        false,
-        "sqlite",
-        true,
-      );
-
-      // All values should remain in their original types
-      expect(result).toEqual({
-        id: "user1",
-        name: "Alice",
-        email: "alice@example.com",
-        age: 30,
-        isActive: false, // Not converted to 0
-        createdAt: date, // Not converted to timestamp
-      });
-    });
-
-    it("should still handle FragnoId and ReferenceSubquery correctly with skipDriverConversions", () => {
-      const fragnoId = FragnoId.fromExternal("user123", 1);
-      const result = encodeValues(
-        { id: fragnoId, name: "John" },
-        usersTable,
-        false,
-        "sqlite",
-        true,
-      );
-
-      // FragnoId handling should still work
-      expect(result).toEqual({
-        id: "user123",
-        name: "John",
-      });
-
-      // Test ReferenceSubquery
-      const refResult = encodeValues(
-        { title: "Test Post", userId: "user_external_id" },
-        postsTable,
-        false,
-        "sqlite",
-        true,
-      );
-
-      expect(refResult["title"]).toBe("Test Post");
-      expect(refResult["userId"]).toBeInstanceOf(ReferenceSubquery);
-    });
-  });
-});
+import { decodeResult } from "./value-decoding";
+import {
+  SQLocalDriverConfig,
+  NodePostgresDriverConfig,
+  MySQL2DriverConfig,
+} from "../adapters/generic-sql/driver-config";
 
 describe("decodeResult", () => {
   const testSchema = schema((s) => {
@@ -424,12 +38,16 @@ describe("decodeResult", () => {
   const usersTable = testSchema.tables.users;
   const postsTable = testSchema.tables.posts;
 
+  const sqliteConfig = new SQLocalDriverConfig();
+  const postgresqlConfig = new NodePostgresDriverConfig();
+  const mysqlConfig = new MySQL2DriverConfig();
+
   describe("basic decoding", () => {
     it("should decode string values", () => {
       const result = decodeResult(
         { id: "user1", name: "John", email: "john@example.com" },
         usersTable,
-        "sqlite",
+        sqliteConfig,
       );
 
       expect(result).toEqual({
@@ -440,25 +58,25 @@ describe("decodeResult", () => {
     });
 
     it("should decode integer values", () => {
-      const result = decodeResult({ age: 25 }, usersTable, "sqlite");
+      const result = decodeResult({ age: 25 }, usersTable, sqliteConfig);
 
       expect(result).toEqual({ age: 25 });
     });
 
     it("should decode boolean values from sqlite", () => {
-      const result = decodeResult({ isActive: 1 }, usersTable, "sqlite");
+      const result = decodeResult({ isActive: 1 }, usersTable, sqliteConfig);
 
       expect(result).toEqual({ isActive: true });
     });
 
     it("should decode boolean false from sqlite", () => {
-      const result = decodeResult({ isActive: 0 }, usersTable, "sqlite");
+      const result = decodeResult({ isActive: 0 }, usersTable, sqliteConfig);
 
       expect(result).toEqual({ isActive: false });
     });
 
     it("should decode boolean values from postgresql", () => {
-      const result = decodeResult({ isActive: true }, usersTable, "postgresql");
+      const result = decodeResult({ isActive: true }, usersTable, postgresqlConfig);
 
       expect(result).toEqual({ isActive: true });
     });
@@ -467,7 +85,7 @@ describe("decodeResult", () => {
   describe("date decoding", () => {
     it("should decode number to Date for sqlite timestamp", () => {
       const timestamp = 1705317000000;
-      const result = decodeResult({ createdAt: timestamp }, usersTable, "sqlite");
+      const result = decodeResult({ createdAt: timestamp }, usersTable, sqliteConfig);
 
       expect(result["createdAt"]).toBeInstanceOf(Date);
       expect((result["createdAt"] as Date).getTime()).toBe(timestamp);
@@ -475,7 +93,7 @@ describe("decodeResult", () => {
 
     it("should decode ISO string to Date for sqlite timestamp", () => {
       const isoString = "2024-01-15T10:30:00.000Z";
-      const result = decodeResult({ createdAt: isoString }, usersTable, "sqlite");
+      const result = decodeResult({ createdAt: isoString }, usersTable, sqliteConfig);
 
       expect(result["createdAt"]).toBeInstanceOf(Date);
       expect((result["createdAt"] as Date).toISOString()).toBe(isoString);
@@ -483,7 +101,7 @@ describe("decodeResult", () => {
 
     it("should keep Date as Date for postgresql", () => {
       const date = new Date("2024-01-15T10:30:00Z");
-      const result = decodeResult({ createdAt: date }, usersTable, "postgresql");
+      const result = decodeResult({ createdAt: date }, usersTable, postgresqlConfig);
 
       expect(result["createdAt"]).toBe(date);
     });
@@ -491,13 +109,13 @@ describe("decodeResult", () => {
 
   describe("nullable columns", () => {
     it("should handle null values", () => {
-      const result = decodeResult({ age: null }, usersTable, "sqlite");
+      const result = decodeResult({ age: null }, usersTable, sqliteConfig);
 
       expect(result).toEqual({ age: null });
     });
 
     it("should handle nullable timestamp", () => {
-      const result = decodeResult({ publishedAt: null }, postsTable, "sqlite");
+      const result = decodeResult({ publishedAt: null }, postsTable, sqliteConfig);
 
       expect(result).toEqual({ publishedAt: null });
     });
@@ -514,7 +132,7 @@ describe("decodeResult", () => {
           "author:email": "alice@example.com",
         },
         postsTable,
-        "sqlite",
+        sqliteConfig,
       );
 
       expect(result).toEqual({
@@ -539,7 +157,7 @@ describe("decodeResult", () => {
           "author:createdAt": timestamp,
         },
         postsTable,
-        "sqlite",
+        sqliteConfig,
       );
 
       expect(result["author"]).toEqual({
@@ -557,7 +175,7 @@ describe("decodeResult", () => {
           "unknownRelation:field": "value",
         },
         postsTable,
-        "sqlite",
+        sqliteConfig,
       );
 
       expect(result).toEqual({
@@ -575,7 +193,7 @@ describe("decodeResult", () => {
           "author:unknownField": "value",
         },
         postsTable,
-        "sqlite",
+        sqliteConfig,
       );
 
       expect(result).toEqual({
@@ -625,7 +243,7 @@ describe("decodeResult", () => {
           "category:name": "Technology",
         },
         schemaWithMultipleRelations.tables.posts,
-        "sqlite",
+        sqliteConfig,
       );
 
       expect(result).toEqual({
@@ -655,7 +273,7 @@ describe("decodeResult", () => {
           "author:name": "Alice",
         },
         postsTable,
-        "sqlite",
+        sqliteConfig,
       );
 
       // Main table id should be FragnoId
@@ -686,7 +304,7 @@ describe("decodeResult", () => {
           createdAt: timestamp,
         },
         usersTable,
-        "sqlite",
+        sqliteConfig,
       );
 
       expect(result).toEqual({
@@ -702,7 +320,7 @@ describe("decodeResult", () => {
 
   describe("edge cases", () => {
     it("should handle empty result", () => {
-      const result = decodeResult({}, usersTable, "sqlite");
+      const result = decodeResult({}, usersTable, sqliteConfig);
 
       expect(result).toEqual({});
     });
@@ -714,7 +332,7 @@ describe("decodeResult", () => {
           "author:name": "Alice",
         },
         postsTable,
-        "sqlite",
+        sqliteConfig,
       );
 
       expect(result).toEqual({
@@ -737,7 +355,7 @@ describe("decodeResult", () => {
           "author:name": "Alice",
         },
         postsTable,
-        "sqlite",
+        sqliteConfig,
       );
 
       expect(result).toEqual({
@@ -762,14 +380,14 @@ describe("decodeResult", () => {
           name: "John",
         },
         usersTable,
-        "postgresql",
+        postgresqlConfig,
       );
 
       const fragnoId = result["id"];
       assert(fragnoId instanceof FragnoId);
 
       expect(fragnoId.externalId).toBe("user123");
-      expect(fragnoId.internalId).toBe(456);
+      expect(fragnoId.internalId).toBe(456n);
       expect(result["name"]).toBe("John");
     });
 
@@ -781,7 +399,7 @@ describe("decodeResult", () => {
           name: "John",
         },
         usersTable,
-        "postgresql",
+        postgresqlConfig,
       );
 
       const fragnoId = result["id"];
@@ -799,7 +417,7 @@ describe("decodeResult", () => {
           name: "John",
         },
         usersTable,
-        "postgresql",
+        postgresqlConfig,
       );
 
       expect(result).toEqual({
@@ -817,9 +435,9 @@ describe("decodeResult", () => {
       };
 
       // Test across providers
-      const sqliteResult = decodeResult(testData, usersTable, "sqlite");
-      const postgresqlResult = decodeResult(testData, usersTable, "postgresql");
-      const mysqlResult = decodeResult(testData, usersTable, "mysql");
+      const sqliteResult = decodeResult(testData, usersTable, sqliteConfig);
+      const postgresqlResult = decodeResult(testData, usersTable, postgresqlConfig);
+      const mysqlResult = decodeResult(testData, usersTable, mysqlConfig);
 
       // All should create FragnoId objects
       expect(sqliteResult["id"]).toBeInstanceOf(FragnoId);
@@ -827,7 +445,7 @@ describe("decodeResult", () => {
       expect(mysqlResult["id"]).toBeInstanceOf(FragnoId);
 
       expect((sqliteResult["id"] as FragnoId).externalId).toBe("user123");
-      expect((sqliteResult["id"] as FragnoId).internalId).toBe(456);
+      expect((sqliteResult["id"] as FragnoId).internalId).toBe(456n);
     });
 
     it("should create FragnoId in relation data when both IDs present", () => {
@@ -841,7 +459,7 @@ describe("decodeResult", () => {
           "author:name": "Alice",
         },
         postsTable,
-        "postgresql",
+        postgresqlConfig,
       );
 
       expect(result["id"]).toBe("post1");
@@ -850,7 +468,7 @@ describe("decodeResult", () => {
       const author: Record<string, unknown> = result["author"] as Record<string, unknown>;
       assert(author["id"] instanceof FragnoId);
       expect(author["id"].externalId).toBe("user123");
-      expect(author["id"].internalId).toBe(456);
+      expect(author["id"].internalId).toBe(456n);
       expect(author["name"]).toBe("Alice");
     });
 
@@ -863,7 +481,7 @@ describe("decodeResult", () => {
           "author:name": "Alice",
         },
         postsTable,
-        "postgresql",
+        postgresqlConfig,
       );
 
       expect(result).toEqual({
@@ -891,12 +509,12 @@ describe("decodeResult", () => {
           createdAt: timestamp,
         },
         usersTable,
-        "sqlite",
+        sqliteConfig,
       );
 
       expect(result["id"]).toBeInstanceOf(FragnoId);
       expect((result["id"] as FragnoId).externalId).toBe("user123");
-      expect((result["id"] as FragnoId).internalId).toBe(456);
+      expect((result["id"] as FragnoId).internalId).toBe(456n);
       expect(result["name"]).toBe("Alice");
       expect(result["email"]).toBe("alice@example.com");
       expect(result["age"]).toBe(30);
@@ -912,12 +530,12 @@ describe("decodeResult", () => {
           name: "John",
         },
         usersTable,
-        "postgresql",
+        postgresqlConfig,
       );
 
       expect(result["id"]).toBeInstanceOf(FragnoId);
       expect((result["id"] as FragnoId).externalId).toBe("user123");
-      expect((result["id"] as FragnoId).internalId).toBe(789);
+      expect((result["id"] as FragnoId).internalId).toBe(789n);
       expect(result["name"]).toBe("John");
     });
   });