@fragno-dev/db 0.2.1 → 0.3.0

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

@@ -19,7 +19,8 @@ export class MySQLSerializer extends SQLSerializer {
     super(driverConfig);
   }
 
-  protected serializeDate(value: Date): Date {
+  protected serializeDate(value: Date, _col: AnyColumn): Date {
+    void _col;
     // MySQL handles Date objects natively
     return value;
   }
@@ -34,7 +35,8 @@ export class MySQLSerializer extends SQLSerializer {
     return value;
   }
 
-  protected deserializeDate(value: unknown): Date {
+  protected deserializeDate(value: unknown, _col: AnyColumn): Date {
+    void _col;
     if (value instanceof Date) {
       return value;
     }
@@ -96,12 +98,15 @@ export class MySQLSerializer 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;
     }
     // MySQL may return integers as strings
     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;
@@ -121,11 +126,14 @@ export class MySQLSerializer extends SQLSerializer {
   protected deserializeDecimal(value: unknown): number {
     // MySQL can return decimals as numbers or strings
     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/dialect/postgres-serializer.ts

@@ -18,7 +18,8 @@ export class PostgreSQLSerializer extends SQLSerializer {
     super(driverConfig);
   }
 
-  protected serializeDate(value: Date): Date {
+  protected serializeDate(value: Date, _col: AnyColumn): Date {
+    void _col;
     // PostgreSQL handles Date objects natively
     return value;
   }
@@ -33,13 +34,18 @@ export class PostgreSQLSerializer extends SQLSerializer {
     return value;
   }
 
-  protected deserializeDate(value: unknown): Date {
+  protected deserializeDate(value: unknown, _col: AnyColumn): Date {
+    void _col;
     if (value instanceof Date) {
+      if (this.driverConfig.driverType === "pglite") {
+        return new Date(value.getTime() - value.getTimezoneOffset() * 60_000);
+      }
       return value;
     }
     // PostgreSQL returns timestamps/dates as strings
     if (typeof value === "string") {
-      return new Date(value);
+      // Normalize timezone-less timestamps to UTC to avoid local offset drift.
+      return new Date(normalizeTimestampString(value));
     }
     throw new Error(`Cannot deserialize date from value: ${value}`);
   }
@@ -91,6 +97,9 @@ export class PostgreSQLSerializer 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;
     }
     // PostgreSQL may return bigint for large integers
@@ -108,11 +117,14 @@ export class PostgreSQLSerializer extends SQLSerializer {
   protected deserializeDecimal(value: unknown): number {
     // PostgreSQL can return decimals as numbers or strings depending on precision
     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;
@@ -127,3 +139,21 @@ export class PostgreSQLSerializer extends SQLSerializer {
     throw new Error(`Cannot deserialize string from value: ${typeof value}`);
   }
 }
+
+const normalizeTimestampString = (value: string) => {
+  if (!hasTimeComponent(value) || !isTimestampWithoutTimezone(value)) {
+    return value;
+  }
+  const withTimeSeparator = value.includes(" ") ? value.replace(" ", "T") : value;
+  return `${withTimeSeparator}Z`;
+};
+
+const hasTimeComponent = (value: string) => /\d{2}:\d{2}:\d{2}/.test(value);
+
+const isTimestampWithoutTimezone = (value: string) => {
+  // Detect RFC3339-like timezone indicators: Z or +/-HH(:MM)?
+  if (value.endsWith("Z")) {
+    return false;
+  }
+  return !/[+-]\d{2}(:?\d{2})?$/.test(value);
+};

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

@@ -2,10 +2,18 @@ import { describe, it, expect } from "vitest";
 import { SQLiteSerializer } from "./sqlite-serializer";
 import type { AnyColumn } from "../../../schema/create";
 import { BetterSQLite3DriverConfig } from "../../../adapters/generic-sql/driver-config";
+import { sqliteStoragePrisma } from "../../../adapters/generic-sql/sqlite-storage";
 
 describe("SQLiteSerializer", () => {
   const mockDriverConfig = new BetterSQLite3DriverConfig();
   const serializer = new SQLiteSerializer(mockDriverConfig);
+  const prismaSerializer = new SQLiteSerializer(mockDriverConfig, sqliteStoragePrisma);
+  const timestampColumn: AnyColumn = {
+    name: "createdAt",
+    type: "timestamp",
+    role: "regular",
+    isNullable: false,
+  } as AnyColumn;
 
   describe("serializeBigInt", () => {
     describe("for internal-id and reference columns", () => {
@@ -110,6 +118,19 @@ describe("SQLiteSerializer", () => {
         expect((result as Buffer).length).toBe(8);
       });
 
+      it("should keep bigint for regular column in prisma storage", () => {
+        const col: AnyColumn = {
+          name: "largeNumber",
+          type: "bigint",
+          role: "regular",
+          isNullable: false,
+        } as AnyColumn;
+
+        const result = prismaSerializer["serializeBigInt"](BigInt(789), col);
+        expect(result).toBe(BigInt(789));
+        expect(typeof result).toBe("bigint");
+      });
+
       it("should handle large values outside safe integer range as Buffer", () => {
         const col: AnyColumn = {
           name: "largeNumber",
@@ -132,11 +153,18 @@ describe("SQLiteSerializer", () => {
   describe("other serialization methods", () => {
     it("should serialize Date to timestamp number", () => {
       const date = new Date("2024-01-01T00:00:00Z");
-      const result = serializer["serializeDate"](date);
+      const result = serializer["serializeDate"](date, timestampColumn);
       expect(result).toBe(date.getTime());
       expect(typeof result).toBe("number");
     });
 
+    it("should serialize Date to ISO string for prisma storage", () => {
+      const date = new Date("2024-01-01T00:00:00Z");
+      const result = prismaSerializer["serializeDate"](date, timestampColumn);
+      expect(result).toBe(date.toISOString());
+      expect(typeof result).toBe("string");
+    });
+
     it("should serialize boolean to 0/1", () => {
       expect(serializer["serializeBoolean"](true)).toBe(1);
       expect(serializer["serializeBoolean"](false)).toBe(0);
@@ -181,6 +209,18 @@ describe("SQLiteSerializer", () => {
     });
   });
 
+  describe("deserializeDate", () => {
+    it("should parse CURRENT_TIMESTAMP format as UTC", () => {
+      const date = prismaSerializer["deserializeDate"]("2024-03-10 12:34:56", timestampColumn);
+      expect(date.toISOString()).toBe("2024-03-10T12:34:56.000Z");
+    });
+
+    it("should parse CURRENT_TIMESTAMP format with milliseconds as UTC", () => {
+      const date = prismaSerializer["deserializeDate"]("2024-03-10 12:34:56.789", timestampColumn);
+      expect(date.toISOString()).toBe("2024-03-10T12:34:56.789Z");
+    });
+  });
+
   describe("deserializeInteger", () => {
     it("should deserialize number directly", () => {
       expect(serializer["deserializeInteger"](42)).toBe(42);
@@ -248,4 +288,14 @@ describe("SQLiteSerializer", () => {
       );
     });
   });
+
+  describe("deserializeBigInt", () => {
+    it("should throw when prisma storage receives unsafe bigint number", () => {
+      const unsafeNumber = Number.MAX_SAFE_INTEGER + 10;
+      expect(() => prismaSerializer["deserializeBigInt"](unsafeNumber)).toThrow(RangeError);
+      expect(() => prismaSerializer["deserializeBigInt"](unsafeNumber)).toThrow(
+        /exceeds Number\.MAX_SAFE_INTEGER/,
+      );
+    });
+  });
 });

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

@@ -1,23 +1,59 @@
 import type { AnyColumn } from "../../../schema/create";
 import { SQLSerializer } from "../sql-serializer";
 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";
+
+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,
+    ),
+  );
+}
 
 /**
  * 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 +61,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 +76,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+$/.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}`);
   }
 
@@ -76,6 +146,13 @@ export class SQLiteSerializer extends SQLSerializer {
       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 +187,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 +215,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

@@ -133,6 +133,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
    */