@fragno-dev/db 0.3.0 → 0.4.1

package/src/adapters/generic-sql/sql-adapter-sqlite3-driver.test.ts

@@ -1,6 +1,9 @@
-import SQLite from "better-sqlite3";
 import { beforeAll, describe, expect, expectTypeOf, it } from "vitest";
-import { column, idColumn, referenceColumn, schema, type FragnoId } from "../../schema/create";
+
+import SQLite from "better-sqlite3";
+import { SqliteDialect } from "kysely";
+
+import { internalSchema } from "../../fragments/internal-fragment";
 import {
   Cursor,
   createServiceTxBuilder,
@@ -8,11 +11,11 @@ import {
   ExponentialBackoffRetryPolicy,
   type DatabaseAdapter,
 } from "../../mod";
-import { SqliteDialect } from "kysely";
+import { createNamingResolver, suffixNamingStrategy } from "../../naming/sql-naming";
+import { column, idColumn, referenceColumn, schema, type FragnoId } from "../../schema/create";
 import { SqlDriverAdapter } from "../../sql-driver/sql-driver-adapter";
 import { BetterSQLite3DriverConfig } from "./driver-config";
 import { SqlAdapter } from "./generic-sql-adapter";
-import { internalSchema } from "../../fragments/internal-fragment";
 
 describe("SqlAdapter with better-sqlite3", () => {
   const testSchema = schema("test", (s) => {
@@ -22,7 +25,8 @@ describe("SqlAdapter with better-sqlite3", () => {
           .addColumn("id", idColumn())
           .addColumn("name", column("string"))
           .addColumn("age", column("integer").nullable())
-          .createIndex("name_idx", ["name"]);
+          .createIndex("name_idx", ["name"])
+          .createIndex("name_id_idx", ["name", "id"]);
       })
       .addTable("emails", (t) => {
         return t
@@ -317,6 +321,47 @@ describe("SqlAdapter with better-sqlite3", () => {
     }
   });
 
+  it("should support composite cursor pagination", async () => {
+    const queryEngine = adapter.createQueryEngine(testSchema, "namespace");
+    const nameValue = "SqlAdapter SQLite Composite Cursor";
+
+    const createUow = queryEngine.createUnitOfWork("create-composite-cursor-users");
+    for (let i = 0; i < 5; i += 1) {
+      createUow.create("users", { name: nameValue, age: 70 + i });
+    }
+    await createUow.executeMutations();
+
+    const all = await queryEngine.find("users", (b) =>
+      b
+        .whereIndex("name_id_idx", (eb) => eb("name", "=", nameValue))
+        .orderByIndex("name_id_idx", "asc"),
+    );
+
+    const firstPage = await queryEngine.findWithCursor("users", (b) =>
+      b
+        .whereIndex("name_id_idx", (eb) => eb("name", "=", nameValue))
+        .orderByIndex("name_id_idx", "asc")
+        .pageSize(2),
+    );
+
+    const secondPage = await queryEngine.findWithCursor("users", (b) =>
+      b
+        .whereIndex("name_id_idx", (eb) => eb("name", "=", nameValue))
+        .after(firstPage.cursor!)
+        .orderByIndex("name_id_idx", "asc")
+        .pageSize(2),
+    );
+
+    const ids = (rows: { id: FragnoId }[]) => rows.map((row) => row.id.externalId);
+
+    expect(all.length).toBeGreaterThanOrEqual(5);
+    expect(firstPage.items).toHaveLength(2);
+    expect(firstPage.cursor).toBeInstanceOf(Cursor);
+    expect(firstPage.hasNextPage).toBe(true);
+    expect(ids(firstPage.items)).toEqual(ids(all).slice(0, 2));
+    expect(ids([...firstPage.items, ...secondPage.items])).toEqual(ids(all).slice(0, 4));
+  });
+
   it("should support joins", async () => {
     const queryEngine = adapter.createQueryEngine(testSchema, "namespace");
 
@@ -911,3 +956,226 @@ describe("SqlAdapter with better-sqlite3", () => {
     expect(conflictPosts).toHaveLength(0);
   });
 });
+
+describe("SQLite recreate-table foreign keys", () => {
+  it("keeps foreign keys pointing at the original table after recreation", async () => {
+    const database = new SQLite(":memory:");
+    const dialect = new SqliteDialect({ database });
+    const driver = new SqlDriverAdapter(dialect);
+    const adapter = new SqlAdapter({
+      dialect,
+      driverConfig: new BetterSQLite3DriverConfig(),
+    });
+
+    const fkSchema = schema("fk_test", (s) => {
+      return s
+        .addTable("users", (t) => {
+          return t.addColumn("id", idColumn()).addColumn("name", column("string"));
+        })
+        .addTable("sessions", (t) => {
+          return t.addColumn("id", idColumn()).addColumn("userId", referenceColumn());
+        })
+        .addReference("sessionUser", {
+          type: "one",
+          from: { table: "sessions", column: "userId" },
+          to: { table: "users", column: "id" },
+        })
+        .alterTable("users", (t) => {
+          return t.alterColumn("name").nullable();
+        });
+    });
+
+    const namespace = "fk_test";
+    const resolver = createNamingResolver(fkSchema, namespace, suffixNamingStrategy);
+    const usersTable = resolver.getTableName("users");
+    const sessionsTable = resolver.getTableName("sessions");
+
+    const migrations = adapter.prepareMigrations(fkSchema, namespace);
+    const beforeRecreateVersion = fkSchema.version - 1;
+
+    try {
+      await migrations.executeWithDriver(driver, 0, beforeRecreateVersion, {
+        updateVersionInMigration: false,
+      });
+      await migrations.executeWithDriver(driver, beforeRecreateVersion, fkSchema.version, {
+        updateVersionInMigration: false,
+      });
+
+      const fkRows = database
+        .prepare(`PRAGMA foreign_key_list("${sessionsTable}")`)
+        .all() as Array<{ table: string }>;
+
+      expect(fkRows.length).toBeGreaterThan(0);
+      for (const row of fkRows) {
+        expect(row.table).toBe(usersTable);
+        expect(row.table).not.toContain("__fragno_tmp_");
+      }
+    } finally {
+      await driver.destroy();
+    }
+  });
+});
+
+describe("SQLite migration failure scenarios", () => {
+  const createAdapter = () => {
+    const database = new SQLite(":memory:");
+    const dialect = new SqliteDialect({ database });
+    const driver = new SqlDriverAdapter(dialect);
+    const adapter = new SqlAdapter({
+      dialect,
+      driverConfig: new BetterSQLite3DriverConfig(),
+    });
+
+    return { adapter, driver, database };
+  };
+
+  it("fails when adding a foreign key after tables already exist", async () => {
+    const { adapter, driver } = createAdapter();
+    const fkLaterSchema = schema("fk_later_runtime", (s) => {
+      return s
+        .addTable("users", (t) => {
+          return t.addColumn("id", idColumn()).addColumn("name", column("string"));
+        })
+        .addTable("posts", (t) => {
+          return t
+            .addColumn("id", idColumn())
+            .addColumn("title", column("string"))
+            .addColumn("authorId", referenceColumn());
+        })
+        .addReference("author", {
+          type: "one",
+          from: { table: "posts", column: "authorId" },
+          to: { table: "users", column: "id" },
+        });
+    });
+
+    const namespace = "fk_later_runtime";
+    const migrations = adapter.prepareMigrations(fkLaterSchema, namespace);
+    const beforeFkVersion = fkLaterSchema.version - 1;
+
+    try {
+      await migrations.executeWithDriver(driver, 0, beforeFkVersion, {
+        updateVersionInMigration: false,
+      });
+
+      await expect(
+        migrations.executeWithDriver(driver, beforeFkVersion, fkLaterSchema.version, {
+          updateVersionInMigration: false,
+        }),
+      ).rejects.toThrow(/foreign keys/i);
+    } finally {
+      await driver.destroy();
+    }
+  });
+
+  it("fails when adding a NOT NULL column without default to a table with data", async () => {
+    const { adapter, driver, database } = createAdapter();
+    const addNotNullSchema = schema("add_not_null", (s) => {
+      return s
+        .addTable("items", (t) => {
+          return t.addColumn("id", idColumn()).addColumn("name", column("string"));
+        })
+        .alterTable("items", (t) => {
+          return t.addColumn("status", column("string"));
+        });
+    });
+
+    const namespace = "add_not_null";
+    const resolver = createNamingResolver(addNotNullSchema, namespace, suffixNamingStrategy);
+    const itemsTable = resolver.getTableName("items");
+    const migrations = adapter.prepareMigrations(addNotNullSchema, namespace);
+    const beforeAddVersion = addNotNullSchema.version - 1;
+
+    try {
+      await migrations.executeWithDriver(driver, 0, beforeAddVersion, {
+        updateVersionInMigration: false,
+      });
+
+      database
+        .prepare(`insert into "${itemsTable}" ("id", "name") values (?, ?)`)
+        .run("item-1", "First");
+
+      await expect(
+        migrations.executeWithDriver(driver, beforeAddVersion, addNotNullSchema.version, {
+          updateVersionInMigration: false,
+        }),
+      ).rejects.toThrow(/not null/i);
+    } finally {
+      await driver.destroy();
+    }
+  });
+
+  it("fails when tightening a nullable column with existing NULL values", async () => {
+    const { adapter, driver, database } = createAdapter();
+    const tightenSchema = schema("tighten_nullable", (s) => {
+      return s
+        .addTable("items", (t) => {
+          return t.addColumn("id", idColumn()).addColumn("note", column("string").nullable());
+        })
+        .alterTable("items", (t) => {
+          return t.alterColumn("note").nullable(false);
+        });
+    });
+
+    const namespace = "tighten_nullable";
+    const resolver = createNamingResolver(tightenSchema, namespace, suffixNamingStrategy);
+    const itemsTable = resolver.getTableName("items");
+    const migrations = adapter.prepareMigrations(tightenSchema, namespace);
+    const beforeTightenVersion = tightenSchema.version - 1;
+
+    try {
+      await migrations.executeWithDriver(driver, 0, beforeTightenVersion, {
+        updateVersionInMigration: false,
+      });
+
+      database
+        .prepare(`insert into "${itemsTable}" ("id", "note") values (?, ?)`)
+        .run("item-1", null);
+
+      await expect(
+        migrations.executeWithDriver(driver, beforeTightenVersion, tightenSchema.version, {
+          updateVersionInMigration: false,
+        }),
+      ).rejects.toThrow(/not null/i);
+    } finally {
+      await driver.destroy();
+    }
+  });
+
+  it("fails when adding a unique index with duplicate data", async () => {
+    const { adapter, driver, database } = createAdapter();
+    const uniqueIndexSchema = schema("unique_index", (s) => {
+      return s
+        .addTable("items", (t) => {
+          return t.addColumn("id", idColumn()).addColumn("name", column("string"));
+        })
+        .alterTable("items", (t) => {
+          return t.createIndex("unique_name", ["name"], { unique: true });
+        });
+    });
+
+    const namespace = "unique_index";
+    const resolver = createNamingResolver(uniqueIndexSchema, namespace, suffixNamingStrategy);
+    const itemsTable = resolver.getTableName("items");
+    const migrations = adapter.prepareMigrations(uniqueIndexSchema, namespace);
+    const beforeIndexVersion = uniqueIndexSchema.version - 1;
+
+    try {
+      await migrations.executeWithDriver(driver, 0, beforeIndexVersion, {
+        updateVersionInMigration: false,
+      });
+
+      const insert = database.prepare(`insert into "${itemsTable}" ("id", "name") values (?, ?)`);
+      insert.run("item-1", "dup");
+      insert.run("item-2", "dup");
+
+      await expect(
+        migrations.executeWithDriver(driver, beforeIndexVersion, uniqueIndexSchema.version, {
+          updateVersionInMigration: false,
+        }),
+      ).rejects.toThrow(/unique/i);
+    } finally {
+      await driver.destroy();
+    }
+  });
+});

package/src/adapters/generic-sql/sql-adapter-sqlite3-uow.test.ts

@@ -1,16 +1,20 @@
+import { beforeAll, describe, expect, expectTypeOf, it } from "vitest";
+
 import SQLite from "better-sqlite3";
 import { SqliteDialect } from "kysely";
-import { SqlAdapter } from "./generic-sql-adapter";
-import { beforeAll, describe, expect, expectTypeOf, it } from "vitest";
-import { column, idColumn, referenceColumn, schema, type FragnoId } from "../../schema/create";
+
+import { internalSchema } from "../../fragments/internal-fragment";
+import type { InternalFragmentInstance } from "../../fragments/internal-fragment";
+import { prepareHookMutations, type HooksMap } from "../../hooks/hooks";
 import { Cursor } from "../../query/cursor";
 import {
   createServiceTxBuilder,
   createHandlerTxBuilder,
 } from "../../query/unit-of-work/execute-unit-of-work";
 import { ExponentialBackoffRetryPolicy } from "../../query/unit-of-work/retry-policy";
+import { column, idColumn, referenceColumn, schema, type FragnoId } from "../../schema/create";
 import { BetterSQLite3DriverConfig } from "./driver-config";
-import { internalSchema } from "../../fragments/internal-fragment";
+import { SqlAdapter } from "./generic-sql-adapter";
 
 describe("SqlAdapter SQLite", () => {
   const testSchema = schema("test", (s) => {
@@ -20,7 +24,8 @@ describe("SqlAdapter SQLite", () => {
           .addColumn("id", idColumn())
           .addColumn("name", column("string"))
           .addColumn("age", column("integer").nullable())
-          .createIndex("name_idx", ["name"]);
+          .createIndex("name_idx", ["name"])
+          .createIndex("name_id_idx", ["name", "id"]);
       })
       .addTable("emails", (t) => {
         return t
@@ -39,6 +44,13 @@ describe("SqlAdapter SQLite", () => {
           .addColumn("content", column("string"))
           .createIndex("posts_user_idx", ["user_id"]);
       })
+      .addTable("optional_emails", (t) => {
+        return t
+          .addColumn("id", idColumn())
+          .addColumn("user_id", referenceColumn().nullable())
+          .addColumn("email", column("string"))
+          .createIndex("optional_emails_user_idx", ["user_id"]);
+      })
       .addTable("comments", (t) => {
         return t
           .addColumn("id", idColumn())
@@ -58,6 +70,11 @@ describe("SqlAdapter SQLite", () => {
         from: { table: "posts", column: "user_id" },
         to: { table: "users", column: "id" },
       })
+      .addReference("user", {
+        type: "one",
+        from: { table: "optional_emails", column: "user_id" },
+        to: { table: "users", column: "id" },
+      })
       .addReference("post", {
         type: "one",
         from: { table: "comments", column: "post_id" },
@@ -149,7 +166,7 @@ describe("SqlAdapter SQLite", () => {
       Parameters<typeof createUow.find>[0]
     >();
     expectTypeOf<keyof typeof testSchema.tables>().toEqualTypeOf<
-      "users" | "emails" | "posts" | "comments"
+      "users" | "emails" | "posts" | "comments" | "optional_emails"
     >();
 
     const { success: createSuccess } = await createUow.executeMutations();
@@ -249,6 +266,45 @@ describe("SqlAdapter SQLite", () => {
     });
   });
 
+  it("should fail inserting duplicate triggered hook ids", async () => {
+    const queryEngine = adapter.createQueryEngine(testSchema, "namespace");
+    const hookId = "hook-duplicate-id";
+    const hooks: HooksMap = {
+      onTest: () => {},
+    };
+
+    const internalFragmentStub = {
+      $internal: { deps: { schema: internalSchema } },
+    } as InternalFragmentInstance;
+
+    const buildHookUow = (name: string) => {
+      const uow = queryEngine.createUnitOfWork(name).forSchema(testSchema, hooks);
+      uow.triggerHook("onTest", { data: name }, { id: hookId });
+      prepareHookMutations(
+        uow,
+        internalFragmentStub,
+        new ExponentialBackoffRetryPolicy({ maxRetries: 5 }),
+      );
+      return uow;
+    };
+
+    const firstUow = buildHookUow("hook-duplicate-first");
+    const { success } = await firstUow.executeMutations();
+    expect(success).toBe(true);
+
+    const secondUow = buildHookUow("hook-duplicate-second");
+    await expect(secondUow.executeMutations()).rejects.toThrow();
+
+    const verifyUow = queryEngine.createUnitOfWork("verify-duplicate-hook-id");
+    const internalUow = verifyUow.forSchema(internalSchema);
+    const findUow = internalUow.find("fragno_hooks", (b) =>
+      b.whereIndex("primary", (eb) => eb("id", "=", hookId)),
+    );
+    const [events] = await findUow.executeRetrieve();
+
+    expect(events).toHaveLength(1);
+  });
+
   it("should support count operations", async () => {
     const queryEngine = adapter.createQueryEngine(testSchema, "namespace");
 
@@ -380,6 +436,26 @@ describe("SqlAdapter SQLite", () => {
     });
   });
 
+  it("should return null for left-joined relation when foreign key is null", async () => {
+    const queryEngine = adapter.createQueryEngine(testSchema, "namespace");
+
+    const createUow = queryEngine.createUnitOfWork("create-optional-email");
+    createUow.create("optional_emails", {
+      user_id: null,
+      email: "optional@example.com",
+    });
+    await createUow.executeMutations();
+
+    const uow = queryEngine
+      .createUnitOfWork("join-optional-email")
+      .find("optional_emails", (b) => b.whereIndex("primary").join((jb) => jb.user()));
+
+    const [[email]] = await uow.executeRetrieve();
+
+    expect(email.email).toBe("optional@example.com");
+    expect(email.user).toBeNull();
+  });
+
   it("should support complex nested joins (comments -> post -> author)", async () => {
     const queryEngine = adapter.createQueryEngine(testSchema, "namespace");
 
@@ -796,6 +872,47 @@ describe("SqlAdapter SQLite", () => {
     expect(emptyPage.cursor).toBeUndefined();
   });
 
+  it("should support composite cursor pagination", async () => {
+    const queryEngine = adapter.createQueryEngine(testSchema, "namespace");
+    const nameValue = "SqlAdapter SQLite UOW Composite Cursor";
+
+    const createUow = queryEngine.createUnitOfWork("create-composite-cursor-users");
+    for (let i = 0; i < 5; i += 1) {
+      createUow.create("users", { name: nameValue, age: 60 + i });
+    }
+    await createUow.executeMutations();
+
+    const all = await queryEngine.find("users", (b) =>
+      b
+        .whereIndex("name_id_idx", (eb) => eb("name", "=", nameValue))
+        .orderByIndex("name_id_idx", "asc"),
+    );
+
+    const firstPage = await queryEngine.findWithCursor("users", (b) =>
+      b
+        .whereIndex("name_id_idx", (eb) => eb("name", "=", nameValue))
+        .orderByIndex("name_id_idx", "asc")
+        .pageSize(2),
+    );
+
+    const secondPage = await queryEngine.findWithCursor("users", (b) =>
+      b
+        .whereIndex("name_id_idx", (eb) => eb("name", "=", nameValue))
+        .after(firstPage.cursor!)
+        .orderByIndex("name_id_idx", "asc")
+        .pageSize(2),
+    );
+
+    const ids = (rows: { id: FragnoId }[]) => rows.map((row) => row.id.externalId);
+
+    expect(all.length).toBeGreaterThanOrEqual(5);
+    expect(firstPage.items).toHaveLength(2);
+    expect(firstPage.cursor).toBeInstanceOf(Cursor);
+    expect(firstPage.hasNextPage).toBe(true);
+    expect(ids(firstPage.items)).toEqual(ids(all).slice(0, 2));
+    expect(ids([...firstPage.items, ...secondPage.items])).toEqual(ids(all).slice(0, 4));
+  });
+
   it("should support handlerTx with retry logic", async () => {
     const queryEngine = adapter.createQueryEngine(testSchema, "namespace");
 

package/src/adapters/generic-sql/sql-adapter-sqlocal.test.ts

@@ -1,8 +1,10 @@
-import { SQLocalKysely } from "sqlocal/kysely";
 import { beforeAll, describe, expect, it } from "vitest";
-import { SqlAdapter } from "./generic-sql-adapter";
+
+import { SQLocalKysely } from "sqlocal/kysely";
+
 import { column, idColumn, referenceColumn, schema } from "../../schema/create";
 import { SQLocalDriverConfig } from "./driver-config";
+import { SqlAdapter } from "./generic-sql-adapter";
 
 describe("SqlAdapter SQLite", () => {
   const testSchema = schema("test", (s) => {

package/src/adapters/generic-sql/uow-decoder.test.ts

@@ -1,9 +1,10 @@
 import { describe, it, expect } from "vitest";
-import { schema, idColumn, column, FragnoId } from "../../schema/create";
-import { UnitOfWorkDecoder } from "./uow-decoder";
-import { SQLocalDriverConfig } from "./driver-config";
+
 import type { RetrievalOperation } from "../../query/unit-of-work/unit-of-work";
+import { schema, idColumn, column, FragnoId } from "../../schema/create";
 import type { AnySchema } from "../../schema/create";
+import { SQLocalDriverConfig } from "./driver-config";
+import { UnitOfWorkDecoder } from "./uow-decoder";
 
 describe("UnitOfWorkDecoder", () => {
   const driverConfig = new SQLocalDriverConfig();

package/src/adapters/generic-sql/uow-decoder.ts

@@ -1,11 +1,11 @@
+import type { NamingResolver } from "../../naming/sql-naming";
+import { createCursorFromRecord, type Cursor, type CursorResult } from "../../query/cursor";
 import type { UOWDecoder } from "../../query/unit-of-work/unit-of-work";
 import type { RetrievalOperation } from "../../query/unit-of-work/unit-of-work";
-import type { AnySchema, AnyTable } from "../../schema/create";
 import { decodeResult } from "../../query/value-decoding";
-import { createCursorFromRecord, type Cursor, type CursorResult } from "../../query/cursor";
+import type { AnySchema, AnyTable } from "../../schema/create";
 import type { DriverConfig } from "./driver-config";
 import type { SQLiteStorageMode } from "./sqlite-storage";
-import type { NamingResolver } from "../../naming/sql-naming";
 
 /**
  * Decoder class for Unit of Work retrieval results.

package/src/adapters/generic-sql/uow-encoder.test.ts

@@ -1,13 +1,15 @@
 import { describe, it, expect } from "vitest";
+
 import { Kysely, PostgresDialect } from "kysely";
-import { UnitOfWorkEncoder } from "./uow-encoder";
-import { schema, column, idColumn, referenceColumn } from "../../schema/create";
+
 import { dbNow } from "../../query/db-now";
+import { schema, column, idColumn, referenceColumn } from "../../schema/create";
 import {
   BetterSQLite3DriverConfig,
   MySQL2DriverConfig,
   NodePostgresDriverConfig,
 } from "./driver-config";
+import { UnitOfWorkEncoder } from "./uow-encoder";
 
 describe("UnitOfWorkEncoder", () => {
   const testSchema = schema("test", (s) => {

package/src/adapters/generic-sql/uow-encoder.ts

@@ -1,15 +1,17 @@
-import type { AnyTable, AnyColumn } from "../../schema/create";
-import type { DriverConfig } from "./driver-config";
+import type { Kysely } from "kysely";
+
+import type { NamingResolver } from "../../naming/sql-naming";
+import { getDbNowOffsetMs, isDbNow } from "../../query/db-now";
 import {
   createSQLSerializer,
   type SQLSerializer,
 } from "../../query/serialize/create-sql-serializer";
 import { encodeValues } from "../../query/value-encoding";
+import type { AnyTable, AnyColumn } from "../../schema/create";
+import type { DriverConfig } from "./driver-config";
+import { buildDbNowSql } from "./query/db-now-sql";
 import { processReferenceSubqueries } from "./query/where-builder";
-import type { NamingResolver } from "../../naming/sql-naming";
-import { sql, type Kysely } from "kysely";
-import { isDbNow } from "../../query/db-now";
-import { sqliteStorageDefault, type SQLiteStorageMode } from "./sqlite-storage";
+import type { SQLiteStorageMode } from "./sqlite-storage";
 
 /**
  * Encoder class for Unit of Work mutation operations.
@@ -121,18 +123,12 @@ export class UnitOfWorkEncoder {
       }
 
       if (isDbNow(value)) {
-        if (this.#driverConfig.databaseType === "sqlite") {
-          const storageMode = this.#sqliteStorageMode ?? sqliteStorageDefault;
-          const storage =
-            col.type === "date" ? storageMode.dateStorage : storageMode.timestampStorage;
-          if ((col.type === "timestamp" || col.type === "date") && storage === "epoch-ms") {
-            result[dbColumnName] = sql`(cast((julianday('now') - 2440587.5)*86400000 as integer))`;
-          } else {
-            result[dbColumnName] = sql`CURRENT_TIMESTAMP`;
-          }
-        } else {
-          result[dbColumnName] = sql`CURRENT_TIMESTAMP`;
-        }
+        result[dbColumnName] = buildDbNowSql({
+          driverConfig: this.#driverConfig,
+          columnType: col.type,
+          offsetMs: getDbNowOffsetMs(value),
+          sqliteStorageMode: this.#sqliteStorageMode,
+        });
         continue;
       }
 

package/src/adapters/in-memory/condition-evaluator.test.ts

@@ -1,7 +1,8 @@
 import { describe, expect, it } from "vitest";
-import { column, idColumn, referenceColumn, schema } from "../../schema/create";
+
 import type { Condition } from "../../query/condition-builder";
 import { buildCondition } from "../../query/condition-builder";
+import { column, idColumn, referenceColumn, schema } from "../../schema/create";
 import { evaluateCondition } from "./condition-evaluator";
 import { createNamespaceStore } from "./store";
 

package/src/adapters/in-memory/condition-evaluator.ts

@@ -1,13 +1,13 @@
+import type { NamingResolver } from "../../naming/sql-naming";
 import type { Condition } from "../../query/condition-builder";
+import { getDbNowOffsetMs, isDbNow } from "../../query/db-now";
 import { ReferenceSubquery, resolveFragnoIdValue } from "../../query/value-encoding";
-import { isDbNow } from "../../query/db-now";
 import type { AnyColumn, AnyTable } from "../../schema/create";
 import { Column, FragnoId, FragnoReference } from "../../schema/create";
+import { resolveReferenceSubquery } from "./reference-resolution";
 import type { InMemoryNamespaceStore, InMemoryRow } from "./store";
 import { normalizeIndexValue } from "./store";
-import { resolveReferenceSubquery } from "./reference-resolution";
 import { compareNormalizedValues } from "./value-comparison";
-import type { NamingResolver } from "../../naming/sql-naming";
 
 const isNullish = (value: unknown): value is null | undefined =>
   value === null || value === undefined;
@@ -74,7 +74,12 @@ const resolveComparisonValue = (
   }
 
   if (isDbNow(value)) {
-    return { value: now(), column };
+    const base = now();
+    const offsetMs = getDbNowOffsetMs(value);
+    return {
+      value: offsetMs === 0 ? base : new Date(base.getTime() + offsetMs),
+      column,
+    };
   }
 
   if (column.role === "reference") {