@fragno-dev/db 0.2.2 → 0.4.1

package/src/query/value-decoding.test.ts

@@ -1,14 +1,16 @@
 import { assert, describe, expect, it } from "vitest";
-import { column, idColumn, referenceColumn, schema, FragnoId } from "../schema/create";
-import { decodeResult } from "./value-decoding";
+
 import {
   SQLocalDriverConfig,
   NodePostgresDriverConfig,
+  PGLiteDriverConfig,
   MySQL2DriverConfig,
 } from "../adapters/generic-sql/driver-config";
+import { column, idColumn, referenceColumn, schema, FragnoId } from "../schema/create";
+import { decodeResult } from "./value-decoding";
 
 describe("decodeResult", () => {
-  const testSchema = schema((s) => {
+  const testSchema = schema("test", (s) => {
     return s
       .addTable("users", (t) => {
         return t
@@ -32,6 +34,11 @@ describe("decodeResult", () => {
         type: "one",
         from: { table: "posts", column: "userId" },
         to: { table: "users", column: "id" },
+      })
+      .addReference("posts", {
+        type: "many",
+        from: { table: "users", column: "id" },
+        to: { table: "posts", column: "userId" },
       });
   });
 
@@ -40,6 +47,7 @@ describe("decodeResult", () => {
 
   const sqliteConfig = new SQLocalDriverConfig();
   const postgresqlConfig = new NodePostgresDriverConfig();
+  const pgliteConfig = new PGLiteDriverConfig();
   const mysqlConfig = new MySQL2DriverConfig();
 
   describe("basic decoding", () => {
@@ -105,6 +113,15 @@ describe("decodeResult", () => {
 
       expect(result["createdAt"]).toBe(date);
     });
+
+    it("should normalize Date values from pglite timestamp parsing", () => {
+      const localDate = new Date("2024-01-15T10:30:00");
+      const expected = new Date(localDate.getTime() - localDate.getTimezoneOffset() * 60_000);
+      const result = decodeResult({ createdAt: localDate }, usersTable, pgliteConfig);
+
+      assert.instanceOf(result["createdAt"], Date);
+      expect((result["createdAt"] as Date).toISOString()).toBe(expected.toISOString());
+    });
   });
 
   describe("nullable columns", () => {
@@ -206,7 +223,7 @@ describe("decodeResult", () => {
     });
 
     it("should handle multiple relations in same result", () => {
-      const schemaWithMultipleRelations = schema((s) => {
+      const schemaWithMultipleRelations = schema("schemawithmultiplerelations", (s) => {
         return s
           .addTable("users", (t) => {
             return t.addColumn("id", idColumn()).addColumn("name", column("string"));
@@ -289,6 +306,48 @@ describe("decodeResult", () => {
       expect(author["id"].internalId).toBe(BigInt(200));
       expect(author["name"]).toBe("Alice");
     });
+
+    it("should return null for missing one relations when internal id is null", () => {
+      const result = decodeResult(
+        {
+          id: "post1",
+          title: "My Post",
+          "author:id": null,
+          "author:_internalId": null,
+          "author:_version": null,
+          "author:name": null,
+        },
+        postsTable,
+        sqliteConfig,
+      );
+
+      expect(result).toEqual({
+        id: "post1",
+        title: "My Post",
+        author: null,
+      });
+    });
+
+    it("should return empty array for missing many relations when internal id is null", () => {
+      const result = decodeResult(
+        {
+          id: "user1",
+          name: "Alice",
+          "posts:id": null,
+          "posts:_internalId": null,
+          "posts:_version": null,
+          "posts:title": null,
+        },
+        usersTable,
+        sqliteConfig,
+      );
+
+      expect(result).toEqual({
+        id: "user1",
+        name: "Alice",
+        posts: [],
+      });
+    });
   });
 
   describe("complete record decoding", () => {

package/src/query/value-decoding.ts

@@ -1,7 +1,12 @@
+import type { DriverConfig } from "../adapters/generic-sql/driver-config";
+import type { SQLiteStorageMode } from "../adapters/generic-sql/sqlite-storage";
+import type { NamingResolver } from "../naming/sql-naming";
 import type { AnyTable } from "../schema/create";
-import { createSQLSerializer } from "./serialize/create-sql-serializer";
 import { FragnoId, FragnoReference } from "../schema/create";
-import type { DriverConfig } from "../adapters/generic-sql/driver-config";
+import { createSQLSerializer } from "./serialize/create-sql-serializer";
+
+const isNullish = (value: unknown): value is null | undefined =>
+  value === null || value === undefined;
 
 /**
  * Decodes a database result record to application format.
@@ -15,6 +20,7 @@ import type { DriverConfig } from "../adapters/generic-sql/driver-config";
  * @param result - The raw database result record
  * @param table - The table schema definition containing column and relation information
  * @param driverConfig - The driver configuration containing database type information
+ * @param sqliteStorageMode - Optional SQLite storage mode override
  * @returns A record in application format with deserialized values
  *
  * @example
@@ -31,11 +37,14 @@ export function decodeResult(
   result: Record<string, unknown>,
   table: AnyTable,
   driverConfig: DriverConfig,
+  sqliteStorageMode?: SQLiteStorageMode,
+  resolver?: NamingResolver,
 ): Record<string, unknown> {
-  const serializer = createSQLSerializer(driverConfig);
+  const serializer = createSQLSerializer(driverConfig, sqliteStorageMode);
   const output: Record<string, unknown> = {};
   // First pass: collect all column values
   const columnValues: Record<string, unknown> = {};
+  const columnMap = resolver ? resolver.getColumnNameMap(table) : undefined;
 
   // Collect all relation data (including nested) keyed by relation name
   const relationData: Record<string, Record<string, unknown>> = {};
@@ -46,13 +55,14 @@ export function decodeResult(
 
     // Direct column (no colon)
     if (colonIndex === -1) {
-      const col = table.columns[k];
+      const logicalName = columnMap?.[k] ?? k;
+      const col = table.columns[logicalName];
       if (!col) {
         continue;
       }
 
       // Store all column values (including hidden ones for FragnoId creation)
-      columnValues[k] = serializer.deserialize(value, col);
+      columnValues[logicalName] = serializer.deserialize(value, col);
       continue;
     }
 
@@ -77,8 +87,24 @@ export function decodeResult(
       continue;
     }
 
+    const relationRow = relationData[relationName];
+    const internalIdKey = relation.table.getInternalIdColumn().name;
+    if (
+      Object.prototype.hasOwnProperty.call(relationRow, internalIdKey) &&
+      isNullish(relationRow[internalIdKey])
+    ) {
+      output[relationName] = relation.type === "many" ? [] : null;
+      continue;
+    }
+
     // Recursively decode the relation data
-    output[relationName] = decodeResult(relationData[relationName], relation.table, driverConfig);
+    output[relationName] = decodeResult(
+      relationRow,
+      relation.table,
+      driverConfig,
+      sqliteStorageMode,
+      resolver,
+    );
   }
 
   // Second pass: create output with FragnoId objects where appropriate

package/src/query/value-encoding.test.ts

@@ -1,4 +1,5 @@
 import { describe, expect, it } from "vitest";
+
 import {
   column,
   FragnoId,
@@ -7,10 +8,15 @@ import {
   schema,
   referenceColumn,
 } from "../schema/create";
-import { resolveFragnoIdValue, encodeValues, ReferenceSubquery } from "./value-encoding";
+import {
+  resolveFragnoIdValue,
+  encodeValues,
+  encodeValuesWithDbDefaults,
+  ReferenceSubquery,
+} from "./value-encoding";
 
 describe("encodeValues", () => {
-  const testSchema = schema((s) => {
+  const testSchema = schema("test", (s) => {
     return s
       .addTable("users", (t) => {
         return t
@@ -128,6 +134,84 @@ describe("encodeValues", () => {
 
       expect(result["viewCount"]).toBe(100);
     });
+
+    it("should use injected runtime defaults when provided", () => {
+      const testDate = new Date("2024-02-01T00:00:00Z");
+      const testSchemaWithDefaults = schema("testschemawithdefaults", (s) =>
+        s.addTable("entries", (t) =>
+          t.addColumn("id", idColumn()).addColumn(
+            "createdAt",
+            column("timestamp").defaultTo$((b) => b.now()),
+          ),
+        ),
+      );
+      const entriesTable = testSchemaWithDefaults.tables.entries;
+
+      const result = encodeValues({}, entriesTable, true, {
+        createId: () => "entry_1",
+        now: () => testDate,
+      });
+
+      expect(result["id"]).toBe("entry_1");
+      expect(result["createdAt"]).toBe(testDate);
+    });
+  });
+
+  describe("database defaults in memory", () => {
+    it("should apply static and dbSpecial defaults when requested", () => {
+      const testDate = new Date("2024-03-01T00:00:00Z");
+      const testSchemaWithDbDefaults = schema("testschemawithdbdefaults", (s) =>
+        s.addTable("posts", (t) =>
+          t
+            .addColumn("id", idColumn())
+            .addColumn("title", column("string"))
+            .addColumn("status", column("string").defaultTo("draft"))
+            .addColumn(
+              "createdAt",
+              column("timestamp").defaultTo((b) => b.now()),
+            ),
+        ),
+      );
+      const postsTable = testSchemaWithDbDefaults.tables.posts;
+
+      const result = encodeValuesWithDbDefaults({ title: "Hello" }, postsTable, {
+        createId: () => "post_1",
+        now: () => testDate,
+      });
+
+      expect(result).toEqual({
+        id: "post_1",
+        title: "Hello",
+        _version: 0,
+        status: "draft",
+        createdAt: testDate,
+      });
+    });
+
+    it("should not override explicit values when applying db defaults", () => {
+      const testSchemaWithDbDefaults = schema("testschemawithdbdefaults", (s) =>
+        s.addTable("posts", (t) =>
+          t
+            .addColumn("id", idColumn())
+            .addColumn("title", column("string"))
+            .addColumn("status", column("string").defaultTo("draft")),
+        ),
+      );
+      const postsTable = testSchemaWithDbDefaults.tables.posts;
+
+      const result = encodeValuesWithDbDefaults(
+        { title: "Hello", status: "published" },
+        postsTable,
+        { createId: () => "post_2" },
+      );
+
+      expect(result).toEqual({
+        id: "post_2",
+        title: "Hello",
+        _version: 0,
+        status: "published",
+      });
+    });
   });
 
   describe("complete record encoding", () => {

package/src/query/value-encoding.ts

@@ -1,6 +1,11 @@
+import type { NamingResolver } from "../naming/sql-naming";
 import type { AnyTable, AnyColumn } from "../schema/create";
 import { FragnoId, FragnoReference } from "../schema/create";
-import { generateRuntimeDefault } from "./column-defaults";
+import {
+  generateDatabaseDefault,
+  generateRuntimeDefault,
+  type RuntimeDefaultContext,
+} from "./column-defaults";
 
 /**
  * Marker class for reference column values that need subquery resolution.
@@ -104,6 +109,8 @@ export function encodeValues(
   values: Record<string, unknown>,
   table: AnyTable,
   generateDefault: boolean,
+  runtimeDefaults: RuntimeDefaultContext = {},
+  resolver?: NamingResolver,
 ): Record<string, unknown> {
   const result: Record<string, unknown> = {};
 
@@ -119,10 +126,12 @@ export function encodeValues(
     if (generateDefault && value === undefined) {
       // Only generate runtime defaults (defaultTo$), not static defaults (defaultTo).
       // Static defaults should be handled by the database via DEFAULT constraints.
-      value = generateRuntimeDefault(col);
+      value = generateRuntimeDefault(col, runtimeDefaults);
     }
 
     if (value !== undefined) {
+      const physicalColumnName = resolver ? resolver.getColumnName(table.name, col.name) : col.name;
+
       // Handle reference columns: strings or FragnoIds without internal IDs need subqueries
       if (col.role === "reference") {
         let needsSubquery = false;
@@ -138,11 +147,11 @@ export function encodeValues(
           externalIdForSubquery = value.externalId;
         } else if (value instanceof FragnoId && value.internalId !== undefined) {
           // FragnoId with internal ID - use it directly (will be serialized later)
-          result[col.name] = value.internalId;
+          result[physicalColumnName] = value.internalId;
           continue;
         } else if (value instanceof FragnoReference) {
           // FragnoReference - use internal ID directly (will be serialized later)
-          result[col.name] = value.internalId;
+          result[physicalColumnName] = value.internalId;
           continue;
         }
 
@@ -151,7 +160,10 @@ export function encodeValues(
             rel.on.some(([localCol]) => localCol === k),
           );
           if (relation) {
-            result[col.name] = new ReferenceSubquery(relation.table, externalIdForSubquery!);
+            result[physicalColumnName] = new ReferenceSubquery(
+              relation.table,
+              externalIdForSubquery!,
+            );
             continue;
           }
           throw new Error(`Reference column ${k} not found in table ${table.name}`);
@@ -160,9 +172,47 @@ export function encodeValues(
 
       // Resolve FragnoId/FragnoReference to primitive values (serialization happens later)
       const resolvedValue = resolveFragnoIdValue(value, col);
-      result[col.name] = resolvedValue;
+      result[physicalColumnName] = resolvedValue;
     }
   }
 
   return result;
 }
+
+/**
+ * Encode values and apply database defaults in-process.
+ *
+ * This is intended for adapters that cannot rely on database DEFAULT constraints,
+ * such as the in-memory adapter.
+ *
+ * @internal
+ */
+export function encodeValuesWithDbDefaults(
+  values: Record<string, unknown>,
+  table: AnyTable,
+  runtimeDefaults: RuntimeDefaultContext = {},
+  resolver?: NamingResolver,
+): Record<string, unknown> {
+  const resolved = encodeValues(values, table, true, runtimeDefaults, resolver);
+
+  for (const columnKey of Object.keys(table.columns)) {
+    const column = table.columns[columnKey];
+    if (column.role === "internal-id") {
+      continue;
+    }
+
+    const physicalColumnName = resolver
+      ? resolver.getColumnName(table.name, column.name)
+      : column.name;
+    if (Object.prototype.hasOwnProperty.call(resolved, physicalColumnName)) {
+      continue;
+    }
+
+    const fallback = generateDatabaseDefault(column, runtimeDefaults);
+    if (fallback !== undefined) {
+      resolved[physicalColumnName] = fallback;
+    }
+  }
+
+  return resolved;
+}