@fragno-dev/db 0.2.2 → 0.4.1

package/src/query/serialize/dialect/sqlite-serializer.ts

@@ -1,23 +1,72 @@
+import type { DriverConfig } from "../../../adapters/generic-sql/driver-config";
+import type { SQLiteStorageMode } from "../../../adapters/generic-sql/sqlite-storage";
+import { sqliteStorageDefault } from "../../../adapters/generic-sql/sqlite-storage";
 import type { AnyColumn } from "../../../schema/create";
 import { SQLSerializer } from "../sql-serializer";
-import type { DriverConfig } from "../../../adapters/generic-sql/driver-config";
+
+const SQLITE_UTC_TIMESTAMP_REGEX =
+  /^(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})(?:\.(\d{1,3}))?$/;
+
+function parseSQLiteUtcTimestamp(value: string): Date | null {
+  const match = SQLITE_UTC_TIMESTAMP_REGEX.exec(value);
+  if (!match) {
+    return null;
+  }
+
+  const [, year, month, day, hour, minute, second, millis] = match;
+  const milliseconds = millis ? Number(millis.padEnd(3, "0")) : 0;
+  return new Date(
+    Date.UTC(
+      Number(year),
+      Number(month) - 1,
+      Number(day),
+      Number(hour),
+      Number(minute),
+      Number(second),
+      milliseconds,
+    ),
+  );
+}
+
+function readBigInt64BEFromBytes(value: ArrayBuffer | ArrayBufferView): bigint {
+  if (value.byteLength !== 8) {
+    throw new Error(`Cannot deserialize bigint from ${value.byteLength} bytes; expected 8.`);
+  }
+
+  const view =
+    value instanceof ArrayBuffer
+      ? new DataView(value)
+      : new DataView(value.buffer, value.byteOffset, value.byteLength);
+
+  return view.getBigInt64(0, false);
+}
 
 /**
  * SQLite-specific serializer.
  *
  * SQLite has limited native type support and requires conversions:
  * - JSON → strings (no native JSON support)
- * - Dates → numbers (timestamps)
+ * - Dates → numbers or ISO strings (storage-mode dependent)
  * - Booleans → 0/1
- * - BigInts → Buffer (except for internal-id and reference columns → number)
+ * - BigInts → Buffer or integer (storage-mode dependent; internal-id/reference stay integer)
  * - Numbers/strings → Date for timestamps/dates
  */
 export class SQLiteSerializer extends SQLSerializer {
-  constructor(driverConfig: DriverConfig) {
+  private readonly sqliteStorageMode: SQLiteStorageMode;
+
+  constructor(driverConfig: DriverConfig, sqliteStorageMode?: SQLiteStorageMode) {
     super(driverConfig);
+    this.sqliteStorageMode = sqliteStorageMode ?? sqliteStorageDefault;
   }
 
-  protected serializeDate(value: Date): number {
+  protected serializeDate(value: Date, col: AnyColumn): number | string {
+    const storage =
+      col.type === "date"
+        ? this.sqliteStorageMode.dateStorage
+        : this.sqliteStorageMode.timestampStorage;
+    if (storage === "iso-text") {
+      return value.toISOString();
+    }
     return value.getTime();
   }
 
@@ -25,7 +74,7 @@ export class SQLiteSerializer extends SQLSerializer {
     return value ? 1 : 0;
   }
 
-  protected serializeBigInt(value: bigint, col: AnyColumn): number | Buffer {
+  protected serializeBigInt(value: bigint, col: AnyColumn): bigint | number | Buffer {
     // SQLite special case: internal-id and reference columns use integer, not blob
     // These should be converted to numbers for SQLite
     if (col.role === "reference" || col.role === "internal-id") {
@@ -40,18 +89,52 @@ export class SQLiteSerializer extends SQLSerializer {
       }
       return Number(value);
     }
+    if (this.sqliteStorageMode.bigintStorage === "integer") {
+      return value;
+    }
     const buf = Buffer.alloc(8);
     buf.writeBigInt64BE(value);
     return buf;
   }
 
-  protected deserializeDate(value: unknown): Date {
+  protected deserializeDate(value: unknown, col: AnyColumn): Date {
     if (value instanceof Date) {
       return value;
     }
-    if (typeof value === "number" || typeof value === "string") {
+    if (typeof value === "string") {
+      if (/^\d+(?:\.\d+)?$/.test(value)) {
+        const numericDate = new Date(Number(value));
+        if (Number.isNaN(numericDate.getTime())) {
+          throw new Error(`Cannot deserialize date from value: ${value}`);
+        }
+        return numericDate;
+      }
+      const parsed = parseSQLiteUtcTimestamp(value);
+      const date = parsed ?? new Date(value);
+      if (Number.isNaN(date.getTime())) {
+        throw new Error(`Cannot deserialize date from value: ${value}`);
+      }
+      return date;
+    }
+    if (typeof value === "number") {
+      if (Number.isNaN(value)) {
+        throw new Error(`Cannot deserialize date from value: ${value}`);
+      }
       return new Date(value);
     }
+    if (typeof value === "bigint") {
+      const storage =
+        col.type === "date"
+          ? this.sqliteStorageMode.dateStorage
+          : this.sqliteStorageMode.timestampStorage;
+      if (storage === "epoch-ms") {
+        const date = new Date(Number(value));
+        if (Number.isNaN(date.getTime())) {
+          throw new Error(`Cannot deserialize date from value: ${value}`);
+        }
+        return date;
+      }
+    }
     throw new Error(`Cannot deserialize date from value: ${value}`);
   }
 
@@ -69,13 +152,20 @@ export class SQLiteSerializer extends SQLSerializer {
     if (typeof value === "bigint") {
       return value;
     }
-    if (value instanceof Buffer) {
-      return value.readBigInt64BE(0);
+    if (value instanceof Buffer || value instanceof ArrayBuffer || ArrayBuffer.isView(value)) {
+      return readBigInt64BEFromBytes(value);
     }
     if (typeof value === "string") {
       return BigInt(value);
     }
     if (typeof value === "number") {
+      if (this.sqliteStorageMode.bigintStorage === "integer") {
+        if (Math.abs(value) > Number.MAX_SAFE_INTEGER) {
+          throw new RangeError(
+            `Cannot deserialize bigint value ${value}: exceeds Number.MAX_SAFE_INTEGER`,
+          );
+        }
+      }
       return BigInt(value);
     }
     throw new Error(`Cannot deserialize bigint from value: ${value}`);
@@ -110,12 +200,15 @@ export class SQLiteSerializer extends SQLSerializer {
 
   protected deserializeInteger(value: unknown): number {
     if (typeof value === "number") {
+      if (Number.isNaN(value) || !Number.isFinite(value)) {
+        throw new Error(`Cannot deserialize integer from invalid number: ${value}`);
+      }
       return value;
     }
     // SQLite may return integers as strings for large values
     if (typeof value === "string") {
       const num = Number(value);
-      if (isNaN(num)) {
+      if (Number.isNaN(num) || !Number.isFinite(num)) {
         throw new Error(`Cannot deserialize integer from invalid string: ${value}`);
       }
       return num;
@@ -135,11 +228,14 @@ export class SQLiteSerializer extends SQLSerializer {
   protected deserializeDecimal(value: unknown): number {
     // SQLite stores decimals as REAL (floating point) or TEXT
     if (typeof value === "number") {
+      if (Number.isNaN(value) || !Number.isFinite(value)) {
+        throw new Error(`Cannot deserialize decimal from invalid number: ${value}`);
+      }
       return value;
     }
     if (typeof value === "string") {
       const num = parseFloat(value);
-      if (isNaN(num)) {
+      if (Number.isNaN(num) || !Number.isFinite(num)) {
         throw new Error(`Cannot deserialize decimal from invalid string: ${value}`);
       }
       return num;

package/src/query/serialize/sql-serializer.ts

@@ -40,7 +40,7 @@ export abstract class SQLSerializer {
 
     // Handle date/timestamp deserialization
     if (col.type === "timestamp" || col.type === "date") {
-      return this.deserializeDate(value);
+      return this.deserializeDate(value, col);
     }
 
     // Handle boolean deserialization
@@ -103,7 +103,7 @@ export abstract class SQLSerializer {
     if (!skipDriverConversions) {
       // Handle date/timestamp serialization
       if (value instanceof Date) {
-        return this.serializeDate(value);
+        return this.serializeDate(value, col);
       }
 
       // Handle boolean serialization
@@ -126,13 +126,13 @@ export abstract class SQLSerializer {
   }
 
   // Abstract methods for dialect-specific serialization
-  protected abstract serializeDate(value: Date): Date | number;
+  protected abstract serializeDate(value: Date, col: AnyColumn): Date | number | string;
   protected abstract serializeBoolean(value: boolean): boolean | number;
   protected abstract serializeBigInt(value: bigint, col: AnyColumn): bigint | number | Buffer;
   protected abstract serializeJson(value: unknown): unknown;
 
   // Abstract methods for dialect-specific deserialization
-  protected abstract deserializeDate(value: unknown): Date;
+  protected abstract deserializeDate(value: unknown, col: AnyColumn): Date;
   protected abstract deserializeBoolean(value: unknown): boolean;
   protected abstract deserializeBigInt(value: unknown): bigint;
   protected abstract deserializeJson(value: unknown): unknown;

package/src/query/simple-query-interface.ts

@@ -1,5 +1,7 @@
 import type { IdColumn, AnySchema, AnyTable, Relation, FragnoId } from "../schema/create";
+import type { Prettify } from "../util/types";
 import type { Condition, ConditionBuilder } from "./condition-builder";
+import type { CursorResult } from "./cursor";
 import type {
   TypedUnitOfWork,
   FindBuilder,
@@ -7,12 +9,11 @@ import type {
   DeleteBuilder,
   UpdateManyBuilder,
 } from "./unit-of-work/unit-of-work";
-import type { Prettify } from "../util/types";
-import type { CursorResult } from "./cursor";
+import type { IUnitOfWork } from "./unit-of-work/unit-of-work";
 
 export type AnySelectClause = SelectClause<AnyTable>;
 
-export type SelectClause<T extends AnyTable> = true | (keyof T["columns"])[];
+export type SelectClause<T extends AnyTable> = true | readonly (keyof T["columns"])[];
 
 export type RawColumnValues<T extends AnyTable> = {
   [K in keyof T["columns"] as string extends K ? never : K]: T["columns"][K]["$out"];
@@ -44,7 +45,7 @@ export type TableToUpdateValues<T extends AnyTable> = {
 
 type MainSelectResult<S extends SelectClause<T>, T extends AnyTable> = S extends true
   ? TableToColumnValues<T>
-  : S extends (keyof T["columns"])[]
+  : S extends readonly (keyof T["columns"])[]
     ? Prettify<{
         [K in S[number] as string extends K ? never : K]: K extends keyof T["columns"]
           ? T["columns"][K]["$out"]
@@ -133,6 +134,11 @@ export type FindManyOptions<
   : {});
 
 export interface SimpleQueryInterface<TSchema extends AnySchema, TUOWConfig = void> {
+  /**
+   * Fetch the current database timestamp.
+   * Optional for adapters that cannot provide DB time.
+   */
+  now?: () => Promise<Date>;
   /**
    * Find multiple records using a builder pattern
    */
@@ -259,4 +265,9 @@ export interface SimpleQueryInterface<TSchema extends AnySchema, TUOWConfig = vo
    * Create a Unit of Work bound to this query engine
    */
   createUnitOfWork: (name?: string, config?: TUOWConfig) => TypedUnitOfWork<TSchema, [], unknown>;
+
+  /**
+   * Create a base Unit of Work for cross-schema operations.
+   */
+  createBaseUnitOfWork: (name?: string, config?: TUOWConfig) => IUnitOfWork;
 }