@fragno-dev/db 0.2.2 → 0.4.1

package/src/query/cursor.ts

@@ -1,7 +1,8 @@
+import type { DriverConfig } from "../adapters/generic-sql/driver-config";
+import type { SQLiteStorageMode } from "../adapters/generic-sql/sqlite-storage";
 import type { AnyColumn } from "../schema/create";
 import { createSQLSerializer } from "./serialize/create-sql-serializer";
 import { resolveFragnoIdValue } from "./value-encoding";
-import type { DriverConfig } from "../adapters/generic-sql/driver-config";
 
 /**
  * Cursor object containing all information needed for pagination
@@ -56,6 +57,7 @@ export class Cursor {
    * Encode cursor to an opaque base64 string (safe to send to client)
    */
   encode(): string {
+    assertSerializableIndexValues(this.#indexValues);
     const data: CursorData = {
       v: 1,
       indexName: this.#indexName,
@@ -100,7 +102,12 @@ export interface CursorData {
  * Encode cursor data to a base64 string (internal)
  */
 function encodeCursorData(data: CursorData): string {
-  const json = JSON.stringify(data);
+  let json: string;
+  try {
+    json = JSON.stringify(data);
+  } catch (error) {
+    throw new Error(`Invalid cursor: ${error instanceof Error ? error.message : "malformed data"}`);
+  }
   // Use Buffer in Node.js or btoa in browsers
   if (typeof Buffer !== "undefined") {
     return Buffer.from(json, "utf-8").toString("base64");
@@ -129,32 +136,38 @@ export function decodeCursor(cursor: string): Cursor {
       json = atob(cursor);
     }
     const data = JSON.parse(json);
+    const record = data as Record<string, unknown>;
 
     // Validate structure
     if (
-      !data ||
-      typeof data !== "object" ||
-      !data.indexValues ||
-      typeof data.indexValues !== "object" ||
-      typeof data.pageSize !== "number" ||
-      !data.indexName ||
-      !data.orderDirection ||
-      (data.orderDirection !== "asc" && data.orderDirection !== "desc")
+      !isPlainObject(data) ||
+      !isPlainObject(record["indexValues"]) ||
+      typeof record["indexName"] !== "string" ||
+      record["indexName"].length === 0 ||
+      typeof record["orderDirection"] !== "string" ||
+      (record["orderDirection"] !== "asc" && record["orderDirection"] !== "desc") ||
+      typeof record["pageSize"] !== "number" ||
+      !Number.isFinite(record["pageSize"]) ||
+      !Number.isInteger(record["pageSize"]) ||
+      record["pageSize"] <= 0
     ) {
       throw new Error("Invalid cursor structure");
     }
 
     // Only support v1
-    const version = typeof data.v === "number" ? data.v : 0;
+    if (typeof record["v"] !== "number") {
+      throw new Error("Unsupported cursor version: missing. Only v1 is supported.");
+    }
+    const version = record["v"];
     if (version !== 1) {
       throw new Error(`Unsupported cursor version: ${version}. Only v1 is supported.`);
     }
 
     return new Cursor({
-      indexName: data.indexName,
-      orderDirection: data.orderDirection,
-      pageSize: data.pageSize,
-      indexValues: data.indexValues,
+      indexName: record["indexName"],
+      orderDirection: record["orderDirection"],
+      pageSize: record["pageSize"],
+      indexValues: record["indexValues"],
     });
   } catch (error) {
     throw new Error(`Invalid cursor: ${error instanceof Error ? error.message : "malformed data"}`);
@@ -194,7 +207,14 @@ export function createCursorFromRecord(
   const indexValues: Record<string, unknown> = {};
 
   for (const col of indexColumns) {
-    indexValues[col.ormName] = record[col.ormName];
+    const value = record[col.name];
+    if (value === undefined) {
+      throw new Error(`Record is missing value for index column "${col.name}".`);
+    }
+    // Resolve FragnoId/FragnoReference to primitive values for cursor serialization.
+    const resolved = resolveFragnoIdValue(value, col);
+    // BigInt values are not JSON-serializable, so store them as strings.
+    indexValues[col.name] = typeof resolved === "bigint" ? resolved.toString() : resolved;
   }
 
   return new Cursor({
@@ -218,6 +238,7 @@ export function createCursorFromRecord(
  * @param cursor - The cursor object
  * @param indexColumns - The columns that make up the index
  * @param driverConfig - The driver configuration
+ * @param sqliteStorageMode - Optional SQLite storage mode override
  * @returns Serialized values ready for database queries
  *
  * @example
@@ -233,23 +254,63 @@ export function serializeCursorValues(
   cursor: Cursor,
   indexColumns: AnyColumn[],
   driverConfig: DriverConfig,
+  sqliteStorageMode?: SQLiteStorageMode,
 ): Record<string, unknown> {
-  const serializer = createSQLSerializer(driverConfig);
+  const serializer = createSQLSerializer(driverConfig, sqliteStorageMode);
   const serialized: Record<string, unknown> = {};
+  const missingColumns: string[] = [];
 
   for (const col of indexColumns) {
-    const value = cursor.indexValues[col.ormName];
-    if (value !== undefined) {
-      // First deserialize from JSON format to application format
-      // (e.g., "2025-11-07T09:36:57.959Z" string → Date object)
-      const deserialized = serializer.deserialize(value, col);
-      // Resolve FragnoId/FragnoReference to primitive values (if present)
-      const resolved = resolveFragnoIdValue(deserialized, col);
-      // Then serialize to database format
-      // (e.g., Date → database driver format)
-      serialized[col.ormName] = serializer.serialize(resolved, col);
+    const value = cursor.indexValues[col.name];
+    if (value === undefined) {
+      missingColumns.push(col.name);
+      continue;
+    }
+
+    // If the cursor value is already a FragnoId/FragnoReference, resolve it directly
+    // to avoid deserializing non-JSON objects.
+    const resolvedDirect = resolveFragnoIdValue(value, col);
+    if (resolvedDirect !== value) {
+      serialized[col.name] = serializer.serialize(resolvedDirect, col);
+      continue;
     }
+
+    // First deserialize from JSON format to application format
+    // (e.g., "2025-11-07T09:36:57.959Z" string → Date object)
+    const deserialized = serializer.deserialize(value, col);
+    // Resolve FragnoId/FragnoReference to primitive values (if present)
+    const resolved = resolveFragnoIdValue(deserialized, col);
+    // Then serialize to database format
+    // (e.g., Date → database driver format)
+    serialized[col.name] = serializer.serialize(resolved, col);
+  }
+
+  if (missingColumns.length > 0) {
+    const suffix = cursor.indexName ? ` for index "${cursor.indexName}"` : "";
+    const columns = missingColumns.map((name) => `"${name}"`).join(", ");
+    const plural = missingColumns.length === 1 ? "" : "s";
+    throw new Error(`Cursor is missing values for index column${plural} ${columns}${suffix}.`);
   }
 
   return serialized;
 }
+
+const isPlainObject = (value: unknown): value is Record<string, unknown> =>
+  typeof value === "object" && value !== null && !Array.isArray(value);
+
+const assertSerializableIndexValues = (values: Record<string, unknown>): void => {
+  for (const [key, value] of Object.entries(values)) {
+    if (value === undefined) {
+      throw new Error(`Cursor index value "${key}" is undefined.`);
+    }
+    if (typeof value === "number" && !Number.isFinite(value)) {
+      throw new Error(`Cursor index value "${key}" must be a finite number.`);
+    }
+    if (typeof value === "bigint") {
+      throw new Error(`Cursor index value "${key}" must not be a BigInt.`);
+    }
+    if (typeof value === "function" || typeof value === "symbol") {
+      throw new Error(`Cursor index value "${key}" is not JSON-serializable.`);
+    }
+  }
+};

package/src/query/db-now.ts

@@ -0,0 +1,73 @@
+export type DbInterval = { tag: "db-interval"; ms: number };
+
+export type DbIntervalInput =
+  | number
+  | {
+      ms?: number;
+      seconds?: number;
+      minutes?: number;
+      hours?: number;
+      days?: number;
+    };
+
+export type DbNow = {
+  tag: "db-now";
+  offsetMs?: number;
+  plus: (interval: DbInterval | DbIntervalInput) => DbNow;
+};
+
+const toIntervalMs = (input: DbInterval | DbIntervalInput): number => {
+  if (typeof input === "number") {
+    if (!Number.isFinite(input)) {
+      throw new Error("DB_INTERVAL_INVALID");
+    }
+    return input;
+  }
+
+  if (typeof input === "object" && input !== null && "tag" in input) {
+    const tagged = input as DbInterval;
+    if (tagged.tag === "db-interval") {
+      if (!Number.isFinite(tagged.ms)) {
+        throw new Error("DB_INTERVAL_INVALID");
+      }
+      return tagged.ms;
+    }
+    throw new Error("DB_INTERVAL_INVALID");
+  }
+
+  const interval = input as Exclude<DbIntervalInput, number>;
+  const totalMs =
+    (interval.ms ?? 0) +
+    (interval.seconds ?? 0) * 1000 +
+    (interval.minutes ?? 0) * 60_000 +
+    (interval.hours ?? 0) * 3_600_000 +
+    (interval.days ?? 0) * 86_400_000;
+
+  if (!Number.isFinite(totalMs)) {
+    throw new Error("DB_INTERVAL_INVALID");
+  }
+
+  return totalMs;
+};
+
+const createDbNow = (offsetMs = 0): DbNow => ({
+  tag: "db-now",
+  offsetMs,
+  plus: (interval) => createDbNow(offsetMs + toIntervalMs(interval)),
+});
+
+export const dbNow = (): DbNow => createDbNow(0);
+
+export const isDbNow = (value: unknown): value is DbNow =>
+  typeof value === "object" && value !== null && (value as { tag?: string }).tag === "db-now";
+
+export const getDbNowOffsetMs = (value: DbNow): number =>
+  typeof value.offsetMs === "number" ? value.offsetMs : 0;
+
+export const dbInterval = (input: DbIntervalInput): DbInterval => ({
+  tag: "db-interval",
+  ms: toIntervalMs(input),
+});
+
+export const isDbInterval = (value: unknown): value is DbInterval =>
+  typeof value === "object" && value !== null && (value as { tag?: string }).tag === "db-interval";

package/src/query/orm/orm.ts

@@ -1,3 +1,5 @@
+import type { AnyColumn, AnyRelation, AnyTable } from "../../schema/create";
+import { buildCondition, type Condition } from "../condition-builder";
 import type {
   AnySelectClause,
   FindFirstOptions,
@@ -5,8 +7,6 @@ import type {
   JoinBuilder,
   OrderBy,
 } from "../simple-query-interface";
-import { buildCondition, type Condition } from "../condition-builder";
-import type { AnyColumn, AnyRelation, AnyTable } from "../../schema/create";
 
 export interface CompiledJoin {
   relation: AnyRelation;

package/src/query/query-type.test.ts

@@ -1,5 +1,7 @@
 import { describe, expectTypeOf, it } from "vitest";
+
 import { column, FragnoId, idColumn, referenceColumn, schema } from "../schema/create";
+import type { ConditionBuilder } from "./condition-builder";
 import type {
   SimpleQueryInterface,
   FindFirstOptions,
@@ -9,11 +11,10 @@ import type {
   SelectClause,
   TableToInsertValues,
 } from "./simple-query-interface";
-import type { ConditionBuilder } from "./condition-builder";
 
 describe("query type tests", () => {
   // Create test schema
-  const _testSchema = schema((s) => {
+  const _testSchema = schema("_test", (s) => {
     return s
       .addTable("users", (t) => {
         return t
@@ -337,7 +338,7 @@ describe("query type tests", () => {
   });
 
   describe("join", () => {
-    const userSchema = schema((s) => {
+    const userSchema = schema("user", (s) => {
       return s
         .addTable("users", (t) => {
           return t.addColumn("id", idColumn()).addColumn("name", column("string"));

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

@@ -1,8 +1,9 @@
 import type { DriverConfig } from "../../adapters/generic-sql/driver-config";
-import { SQLSerializer } from "./sql-serializer";
-import { SQLiteSerializer } from "./dialect/sqlite-serializer";
-import { PostgreSQLSerializer } from "./dialect/postgres-serializer";
+import type { SQLiteStorageMode } from "../../adapters/generic-sql/sqlite-storage";
 import { MySQLSerializer } from "./dialect/mysql-serializer";
+import { PostgreSQLSerializer } from "./dialect/postgres-serializer";
+import { SQLiteSerializer } from "./dialect/sqlite-serializer";
+import { SQLSerializer } from "./sql-serializer";
 
 // Re-export SQLSerializer for convenience
 export { SQLSerializer } from "./sql-serializer";
@@ -14,9 +15,13 @@ export { SQLSerializer } from "./sql-serializer";
  * (PostgreSQL, MySQL, or SQLite).
  *
  * @param driverConfig - The driver configuration
+ * @param sqliteStorageMode - Optional SQLite storage mode override
  * @returns Dialect-specific SQLSerializer instance
  */
-export function createSQLSerializer(driverConfig: DriverConfig): SQLSerializer {
+export function createSQLSerializer(
+  driverConfig: DriverConfig,
+  sqliteStorageMode?: SQLiteStorageMode,
+): SQLSerializer {
   // TODO: The serializers are pretty lenient in what they accept (lost of typeof checks), it may
   //       be beneficial to implement serializers per DriverConfig, and be less lenient.
   switch (driverConfig.databaseType) {
@@ -25,7 +30,7 @@ export function createSQLSerializer(driverConfig: DriverConfig): SQLSerializer {
     case "mysql":
       return new MySQLSerializer(driverConfig);
     case "sqlite":
-      return new SQLiteSerializer(driverConfig);
+      return new SQLiteSerializer(driverConfig, sqliteStorageMode);
     default: {
       const exhaustiveCheck: never = driverConfig.databaseType;
       throw new Error(`Unsupported database type: ${exhaustiveCheck}`);

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

@@ -1,6 +1,6 @@
+import type { DriverConfig } from "../../../adapters/generic-sql/driver-config";
 import type { AnyColumn } from "../../../schema/create";
 import { SQLSerializer } from "../sql-serializer";
-import type { DriverConfig } from "../../../adapters/generic-sql/driver-config";
 
 /**
  * MySQL-specific serializer.
@@ -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

@@ -1,6 +1,6 @@
+import type { DriverConfig } from "../../../adapters/generic-sql/driver-config";
 import type { AnyColumn } from "../../../schema/create";
 import { SQLSerializer } from "../sql-serializer";
-import type { DriverConfig } from "../../../adapters/generic-sql/driver-config";
 
 /**
  * PostgreSQL-specific serializer.
@@ -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

@@ -1,11 +1,20 @@
 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";
+import type { AnyColumn } from "../../../schema/create";
+import { SQLiteSerializer } from "./sqlite-serializer";
 
 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 +119,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 +154,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 +210,23 @@ 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");
+    });
+
+    it("should parse numeric timestamp strings with decimals", () => {
+      const date = serializer["deserializeDate"]("1772709276409.0", timestampColumn);
+      expect(date.getTime()).toBe(1772709276409);
+    });
+  });
+
   describe("deserializeInteger", () => {
     it("should deserialize number directly", () => {
       expect(serializer["deserializeInteger"](42)).toBe(42);
@@ -248,4 +294,45 @@ 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/,
+      );
+    });
+
+    it("should deserialize bigint from ArrayBuffer blob values", () => {
+      const expected = BigInt("9007199254740993");
+      const buffer = Buffer.alloc(8);
+      buffer.writeBigInt64BE(expected);
+      const arrayBuffer = buffer.buffer.slice(
+        buffer.byteOffset,
+        buffer.byteOffset + buffer.byteLength,
+      );
+
+      expect(serializer["deserializeBigInt"](arrayBuffer)).toBe(expected);
+    });
+
+    it("should deserialize bigint from Uint8Array blob values", () => {
+      const expected = BigInt("123456789012345678");
+      const buffer = Buffer.alloc(8);
+      buffer.writeBigInt64BE(expected);
+      const value = new Uint8Array(buffer);
+
+      expect(serializer["deserializeBigInt"](value)).toBe(expected);
+    });
+
+    it.each([
+      ["Buffer", Buffer.alloc(9)],
+      ["ArrayBuffer", new ArrayBuffer(9)],
+      ["Uint8Array", new Uint8Array(9)],
+    ])("should reject %s blob values when byte length is not exactly 8", (_, value) => {
+      expect(() => serializer["deserializeBigInt"](value)).toThrow(
+        /Cannot deserialize bigint from 9 bytes; expected 8\./,
+      );
+    });
+  });
 });