@fragno-dev/db 0.2.2 → 0.3.0

package/src/adapters/{drizzle/drizzle-adapter-pglite.test.ts → generic-sql/sql-adapter-pglite-queries.test.ts}

@@ -1,18 +1,18 @@
 import { PGlite } from "@electric-sql/pglite";
 import { KyselyPGlite } from "kysely-pglite";
-import { DrizzleAdapter } from "./drizzle-adapter";
+import { SqlAdapter } from "./generic-sql-adapter";
 import { beforeAll, describe, expect, expectTypeOf, it } from "vitest";
 import { column, idColumn, referenceColumn, schema } from "../../schema/create";
 import { Cursor } from "../../query/cursor";
-import { PGLiteDriverConfig } from "../generic-sql/driver-config";
+import { PGLiteDriverConfig } from "./driver-config";
 import type { CompiledQuery } from "../../sql-driver/sql-driver";
 import { internalSchema } from "../../fragments/internal-fragment";
 
-describe("DrizzleAdapter PGLite", () => {
+describe("SqlAdapter PGLite", () => {
   let pgliteDatabase: PGlite;
-  let adapter: DrizzleAdapter;
+  let adapter: SqlAdapter;
 
-  const testSchema = schema((s) => {
+  const testSchema = schema("test", (s) => {
     return s
       .addTable("users", (t) => {
         return t
@@ -73,7 +73,7 @@ describe("DrizzleAdapter PGLite", () => {
       });
   });
 
-  const schema2 = schema((s) => {
+  const schema2 = schema("schema2", (s) => {
     return s
       .addTable("products", (t) => {
         return t
@@ -98,7 +98,7 @@ describe("DrizzleAdapter PGLite", () => {
 
     const { dialect } = new KyselyPGlite(pgliteDatabase);
 
-    adapter = new DrizzleAdapter({
+    adapter = new SqlAdapter({
       dialect,
       driverConfig: new PGLiteDriverConfig(),
     });
@@ -321,7 +321,7 @@ describe("DrizzleAdapter PGLite", () => {
 
     const [query] = queries;
     expect(query.sql).toMatchInlineSnapshot(
-      `"select "user"."name" as "user:name", "user"."id" as "user:id", "user"."age" as "user:age", "user"."_internalId" as "user:_internalId", "user"."_version" as "user:_version", "emails_namespace"."id" as "id", "emails_namespace"."user_id" as "user_id", "emails_namespace"."email" as "email", "emails_namespace"."is_primary" as "is_primary", "emails_namespace"."_internalId" as "_internalId", "emails_namespace"."_version" as "_version" from "emails_namespace" left join "users_namespace" as "user" on "emails_namespace"."user_id" = "user"."_internalId""`,
+      `"select "user"."name" as "user:name", "user"."id" as "user:id", "user"."age" as "user:age", "user"."_internalId" as "user:_internalId", "user"."_version" as "user:_version", "namespace"."emails"."id" as "id", "namespace"."emails"."user_id" as "user_id", "namespace"."emails"."email" as "email", "namespace"."emails"."is_primary" as "is_primary", "namespace"."emails"."_internalId" as "_internalId", "namespace"."emails"."_version" as "_version" from "namespace"."emails" left join "namespace"."users" as "user" on "namespace"."emails"."user_id" = "user"."_internalId""`,
     );
 
     expect(email).toMatchObject({
@@ -502,7 +502,7 @@ describe("DrizzleAdapter PGLite", () => {
 
     const [query] = queries;
     expect(query.sql).toMatchInlineSnapshot(
-      `"select "post"."id" as "post:id", "post"."title" as "post:title", "post"."content" as "post:content", "post"."_internalId" as "post:_internalId", "post"."_version" as "post:_version", "post_author"."id" as "post:author:id", "post_author"."name" as "post:author:name", "post_author"."age" as "post:author:age", "post_author"."_internalId" as "post:author:_internalId", "post_author"."_version" as "post:author:_version", "commenter"."id" as "commenter:id", "commenter"."name" as "commenter:name", "commenter"."_internalId" as "commenter:_internalId", "commenter"."_version" as "commenter:_version", "comments_namespace"."id" as "id", "comments_namespace"."post_id" as "post_id", "comments_namespace"."user_id" as "user_id", "comments_namespace"."text" as "text", "comments_namespace"."_internalId" as "_internalId", "comments_namespace"."_version" as "_version" from "comments_namespace" left join "posts_namespace" as "post" on "comments_namespace"."post_id" = "post"."_internalId" left join "users_namespace" as "post_author" on "post"."user_id" = "post_author"."_internalId" left join "users_namespace" as "commenter" on "comments_namespace"."user_id" = "commenter"."_internalId""`,
+      `"select "post"."id" as "post:id", "post"."title" as "post:title", "post"."content" as "post:content", "post"."_internalId" as "post:_internalId", "post"."_version" as "post:_version", "post_author"."id" as "post:author:id", "post_author"."name" as "post:author:name", "post_author"."age" as "post:author:age", "post_author"."_internalId" as "post:author:_internalId", "post_author"."_version" as "post:author:_version", "commenter"."id" as "commenter:id", "commenter"."name" as "commenter:name", "commenter"."_internalId" as "commenter:_internalId", "commenter"."_version" as "commenter:_version", "namespace"."comments"."id" as "id", "namespace"."comments"."post_id" as "post_id", "namespace"."comments"."user_id" as "user_id", "namespace"."comments"."text" as "text", "namespace"."comments"."_internalId" as "_internalId", "namespace"."comments"."_version" as "_version" from "namespace"."comments" left join "namespace"."posts" as "post" on "namespace"."comments"."post_id" = "post"."_internalId" left join "namespace"."users" as "post_author" on "post"."user_id" = "post_author"."_internalId" left join "namespace"."users" as "commenter" on "namespace"."comments"."user_id" = "commenter"."_internalId""`,
     );
   });
 
@@ -614,11 +614,11 @@ describe("DrizzleAdapter PGLite", () => {
 
     const [insertUserQuery, insertPostQuery] = queries;
     expect(insertUserQuery.sql).toMatchInlineSnapshot(
-      `"insert into "users_namespace" ("id", "name", "age") values ($1, $2, $3) returning "users_namespace"."id" as "id", "users_namespace"."name" as "name", "users_namespace"."age" as "age", "users_namespace"."_internalId" as "_internalId", "users_namespace"."_version" as "_version""`,
+      `"insert into "namespace"."users" ("id", "name", "age") values ($1, $2, $3) returning "namespace"."users"."id" as "id", "namespace"."users"."name" as "name", "namespace"."users"."age" as "age", "namespace"."users"."_internalId" as "_internalId", "namespace"."users"."_version" as "_version""`,
     );
     expect(insertUserQuery.parameters).toEqual([userId.externalId, "UOW Test User", 35]);
     expect(insertPostQuery.sql).toMatchInlineSnapshot(
-      `"insert into "posts_namespace" ("id", "user_id", "title", "content") values ($1, (select "_internalId" from "users_namespace" where "id" = $2 limit $3), $4, $5) returning "posts_namespace"."id" as "id", "posts_namespace"."user_id" as "user_id", "posts_namespace"."title" as "title", "posts_namespace"."content" as "content", "posts_namespace"."created_at" as "created_at", "posts_namespace"."_internalId" as "_internalId", "posts_namespace"."_version" as "_version""`,
+      `"insert into "namespace"."posts" ("id", "user_id", "title", "content") values ($1, (select "_internalId" from "namespace"."users" where "id" = $2 limit $3), $4, $5) returning "namespace"."posts"."id" as "id", "namespace"."posts"."user_id" as "user_id", "namespace"."posts"."title" as "title", "namespace"."posts"."content" as "content", "namespace"."posts"."created_at" as "created_at", "namespace"."posts"."_internalId" as "_internalId", "namespace"."posts"."_version" as "_version""`,
     );
     expect(insertPostQuery.parameters).toEqual([
       postId.externalId,

package/src/adapters/generic-sql/{test/generic-drizzle-adapter-sqlite3.test.ts → sql-adapter-sqlite3-driver.test.ts}

@@ -1,21 +1,21 @@
 import SQLite from "better-sqlite3";
 import { beforeAll, describe, expect, expectTypeOf, it } from "vitest";
-import { column, idColumn, referenceColumn, schema, type FragnoId } from "../../../schema/create";
+import { column, idColumn, referenceColumn, schema, type FragnoId } from "../../schema/create";
 import {
   Cursor,
   createServiceTxBuilder,
   createHandlerTxBuilder,
   ExponentialBackoffRetryPolicy,
   type DatabaseAdapter,
-} from "../../../mod";
+} from "../../mod";
 import { SqliteDialect } from "kysely";
-import { SqlDriverAdapter } from "../../../sql-driver/sql-driver-adapter";
-import { BetterSQLite3DriverConfig } from "../driver-config";
-import { GenericSQLAdapter } from "../generic-sql-adapter";
-import { internalSchema } from "../../../fragments/internal-fragment";
+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("GenericSQLAdapter with DrizzleAdapter better-sqlite3", () => {
-  const testSchema = schema((s) => {
+describe("SqlAdapter with better-sqlite3", () => {
+  const testSchema = schema("test", (s) => {
     return s
       .addTable("users", (t) => {
         return t
@@ -73,7 +73,7 @@ describe("GenericSQLAdapter with DrizzleAdapter better-sqlite3", () => {
   });
 
   // Second schema for multi-schema testing
-  const schema2 = schema((s) => {
+  const schema2 = schema("schema2", (s) => {
     return s
       .addTable("products", (t) => {
         return t
@@ -105,7 +105,7 @@ describe("GenericSQLAdapter with DrizzleAdapter better-sqlite3", () => {
     });
     const sqlAdapter = new SqlDriverAdapter(dialect);
     const driverConfig = new BetterSQLite3DriverConfig();
-    const genericAdapter = new GenericSQLAdapter({ dialect, driverConfig });
+    const genericAdapter = new SqlAdapter({ dialect, driverConfig });
 
     {
       const migrations = genericAdapter.prepareMigrations(internalSchema, "");

package/src/adapters/{drizzle/drizzle-adapter-sqlite3.test.ts → generic-sql/sql-adapter-sqlite3-uow.test.ts}

@@ -1,6 +1,6 @@
 import SQLite from "better-sqlite3";
 import { SqliteDialect } from "kysely";
-import { DrizzleAdapter } from "./drizzle-adapter";
+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 { Cursor } from "../../query/cursor";
@@ -9,11 +9,11 @@ import {
   createHandlerTxBuilder,
 } from "../../query/unit-of-work/execute-unit-of-work";
 import { ExponentialBackoffRetryPolicy } from "../../query/unit-of-work/retry-policy";
-import { BetterSQLite3DriverConfig } from "../generic-sql/driver-config";
+import { BetterSQLite3DriverConfig } from "./driver-config";
 import { internalSchema } from "../../fragments/internal-fragment";
 
-describe("DrizzleAdapter SQLite", () => {
-  const testSchema = schema((s) => {
+describe("SqlAdapter SQLite", () => {
+  const testSchema = schema("test", (s) => {
     return s
       .addTable("users", (t) => {
         return t
@@ -71,7 +71,7 @@ describe("DrizzleAdapter SQLite", () => {
   });
 
   // Second schema for multi-schema testing
-  const schema2 = schema((s) => {
+  const schema2 = schema("schema2", (s) => {
     return s
       .addTable("products", (t) => {
         return t
@@ -94,7 +94,7 @@ describe("DrizzleAdapter SQLite", () => {
       });
   });
 
-  let adapter: DrizzleAdapter;
+  let adapter: SqlAdapter;
   let sqliteDatabase: InstanceType<typeof SQLite>;
 
   beforeAll(async () => {
@@ -104,7 +104,7 @@ describe("DrizzleAdapter SQLite", () => {
       database: sqliteDatabase,
     });
 
-    adapter = new DrizzleAdapter({
+    adapter = new SqlAdapter({
       dialect,
       driverConfig: new BetterSQLite3DriverConfig(),
     });

package/src/adapters/{kysely/kysely-adapter-sqlocal.test.ts → generic-sql/sql-adapter-sqlocal.test.ts}

@@ -1,11 +1,11 @@
 import { SQLocalKysely } from "sqlocal/kysely";
 import { beforeAll, describe, expect, it } from "vitest";
-import { KyselyAdapter } from "./kysely-adapter";
+import { SqlAdapter } from "./generic-sql-adapter";
 import { column, idColumn, referenceColumn, schema } from "../../schema/create";
-import { SQLocalDriverConfig } from "../generic-sql/driver-config";
+import { SQLocalDriverConfig } from "./driver-config";
 
-describe("KyselyAdapter SQLite", () => {
-  const testSchema = schema((s) => {
+describe("SqlAdapter SQLite", () => {
+  const testSchema = schema("test", (s) => {
     return s
       .addTable("accounts", (t) => {
         return t
@@ -33,11 +33,11 @@ describe("KyselyAdapter SQLite", () => {
       });
   });
 
-  let adapter: KyselyAdapter;
+  let adapter: SqlAdapter;
 
   beforeAll(async () => {
     const { dialect } = new SQLocalKysely(":memory:");
-    adapter = new KyselyAdapter({
+    adapter = new SqlAdapter({
       dialect,
       driverConfig: new SQLocalDriverConfig(),
     });

package/src/adapters/generic-sql/sqlite-storage.ts

@@ -0,0 +1,20 @@
+export type SQLiteDateStorage = "epoch-ms" | "iso-text";
+export type SQLiteBigintStorage = "blob" | "integer";
+
+export interface SQLiteStorageMode {
+  timestampStorage: SQLiteDateStorage;
+  dateStorage: SQLiteDateStorage;
+  bigintStorage: SQLiteBigintStorage;
+}
+
+export const sqliteStorageDefault: SQLiteStorageMode = {
+  timestampStorage: "epoch-ms",
+  dateStorage: "epoch-ms",
+  bigintStorage: "blob",
+};
+
+export const sqliteStoragePrisma: SQLiteStorageMode = {
+  timestampStorage: "iso-text",
+  dateStorage: "iso-text",
+  bigintStorage: "integer",
+};

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

@@ -8,7 +8,7 @@ import type { AnySchema } from "../../schema/create";
 describe("UnitOfWorkDecoder", () => {
   const driverConfig = new SQLocalDriverConfig();
 
-  const testSchema = schema((s) => {
+  const testSchema = schema("test", (s) => {
     return s
       .addTable("users", (t) => {
         return t

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

@@ -4,6 +4,8 @@ import type { AnySchema, AnyTable } from "../../schema/create";
 import { decodeResult } from "../../query/value-decoding";
 import { createCursorFromRecord, type Cursor, type CursorResult } from "../../query/cursor";
 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.
@@ -13,9 +15,17 @@ import type { DriverConfig } from "./driver-config";
  */
 export class UnitOfWorkDecoder implements UOWDecoder<unknown> {
   readonly #driverConfig: DriverConfig;
-
-  constructor(driverConfig: DriverConfig) {
+  readonly #sqliteStorageMode?: SQLiteStorageMode;
+  readonly #resolver?: NamingResolver;
+
+  constructor(
+    driverConfig: DriverConfig,
+    sqliteStorageMode?: SQLiteStorageMode,
+    resolver?: NamingResolver,
+  ) {
     this.#driverConfig = driverConfig;
+    this.#sqliteStorageMode = sqliteStorageMode;
+    this.#resolver = resolver;
   }
 
   /**
@@ -60,7 +70,15 @@ export class UnitOfWorkDecoder implements UOWDecoder<unknown> {
       return this.decodeCountResult(rows);
     }
 
-    const decodedRows = rows.map((row) => decodeResult(row, operation.table, this.#driverConfig));
+    const decodedRows = rows.map((row) =>
+      decodeResult(
+        row,
+        operation.table,
+        this.#driverConfig,
+        this.#sqliteStorageMode,
+        this.#resolver,
+      ),
+    );
 
     if (operation.withCursor) {
       return this.decodeCursorResult(decodedRows, operation.table, operation);

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

@@ -1,6 +1,8 @@
 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 {
   BetterSQLite3DriverConfig,
   MySQL2DriverConfig,
@@ -8,7 +10,7 @@ import {
 } from "./driver-config";
 
 describe("UnitOfWorkEncoder", () => {
-  const testSchema = schema((s) => {
+  const testSchema = schema("test", (s) => {
     return s
       .addTable("users", (t) => {
         return t
@@ -16,7 +18,8 @@ describe("UnitOfWorkEncoder", () => {
           .addColumn("name", column("string"))
           .addColumn("age", column("integer").nullable())
           .addColumn("isActive", column("bool"))
-          .addColumn("createdAt", column("timestamp"));
+          .addColumn("createdAt", column("timestamp"))
+          .addColumn("birthDate", column("date").nullable());
       })
       .addTable("posts", (t) => {
         return t
@@ -111,6 +114,34 @@ describe("UnitOfWorkEncoder", () => {
       expect(typeof result["id"]).toBe("string");
       expect(result["title"]).toBe("Test");
     });
+
+    it("should use sqlite dateStorage for dbNow date columns", () => {
+      type TestDB = { users: { id: string; birthDate: unknown } };
+      const dialectConfig = {} as unknown as ConstructorParameters<typeof PostgresDialect>[0];
+      const sqliteDb = new Kysely<TestDB>({
+        dialect: new PostgresDialect(dialectConfig),
+      });
+      const encoderWithStorage = new UnitOfWorkEncoder(sqliteConfig, sqliteDb, {
+        timestampStorage: "epoch-ms",
+        dateStorage: "iso-text",
+        bigintStorage: "blob",
+      });
+
+      const result = encoderWithStorage.encodeForDatabase({
+        values: { birthDate: dbNow() },
+        table: usersTable,
+        generateDefaults: false,
+      });
+
+      const query = sqliteDb
+        .updateTable("users")
+        .set({ birthDate: result["birthDate"] as unknown })
+        .where("id", "=", "test");
+
+      const sqlText = query.compile().sql;
+      expect(sqlText).toContain("CURRENT_TIMESTAMP");
+      expect(sqlText).not.toContain("julianday");
+    });
   });
 
   describe("PostgreSQL encoding", () => {

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

@@ -6,8 +6,10 @@ import {
 } from "../../query/serialize/create-sql-serializer";
 import { encodeValues } from "../../query/value-encoding";
 import { processReferenceSubqueries } from "./query/where-builder";
-import type { TableNameMapper } from "../shared/table-name-mapper";
-import type { Kysely } from "kysely";
+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";
 
 /**
  * Encoder class for Unit of Work mutation operations.
@@ -21,18 +23,23 @@ import type { Kysely } from "kysely";
  * This class mirrors the UnitOfWorkDecoder pattern for symmetry.
  */
 export class UnitOfWorkEncoder {
+  readonly #driverConfig: DriverConfig;
   readonly #serializer: SQLSerializer;
   readonly #db: Kysely<any>; // eslint-disable-line @typescript-eslint/no-explicit-any
-  readonly #mapper?: TableNameMapper;
+  readonly #sqliteStorageMode?: SQLiteStorageMode;
+  readonly #resolver?: NamingResolver;
 
   constructor(
     driverConfig: DriverConfig,
     db: Kysely<any>, // eslint-disable-line @typescript-eslint/no-explicit-any
-    mapper?: TableNameMapper,
+    sqliteStorageMode?: SQLiteStorageMode,
+    resolver?: NamingResolver,
   ) {
-    this.#serializer = createSQLSerializer(driverConfig);
+    this.#driverConfig = driverConfig;
+    this.#serializer = createSQLSerializer(driverConfig, sqliteStorageMode);
     this.#db = db;
-    this.#mapper = mapper;
+    this.#sqliteStorageMode = sqliteStorageMode;
+    this.#resolver = resolver;
   }
 
   /**
@@ -66,10 +73,16 @@ export class UnitOfWorkEncoder {
     generateDefaults: boolean;
   }): Record<string, unknown> {
     // Step 1: Resolution - Resolve FragnoId/FragnoReference and generate defaults
-    const resolved = encodeValues(options.values, options.table, options.generateDefaults);
+    const resolved = encodeValues(
+      options.values,
+      options.table,
+      options.generateDefaults,
+      {},
+      this.#resolver,
+    );
 
     // Step 2: Reference Processing - Convert external IDs to subqueries
-    const processed = processReferenceSubqueries(resolved, this.#db, this.#mapper);
+    const processed = processReferenceSubqueries(resolved, this.#db, this.#resolver);
 
     // Step 3: Serialization - Apply database-specific type conversions
     const serialized = this.serializeValues(processed, options.table);
@@ -94,10 +107,11 @@ export class UnitOfWorkEncoder {
     table: AnyTable,
   ): Record<string, unknown> {
     const result: Record<string, unknown> = {};
+    const columnMap = this.#resolver ? this.#resolver.getColumnNameMap(table) : undefined;
 
     for (const [dbColumnName, value] of Object.entries(values)) {
       // Find the column definition by database column name
-      const col = this.findColumnByDbName(table, dbColumnName);
+      const col = this.findColumnByDbName(table, dbColumnName, columnMap);
 
       if (!col) {
         // Not a regular column (might be a special value like sql.raw())
@@ -106,6 +120,22 @@ export class UnitOfWorkEncoder {
         continue;
       }
 
+      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`;
+        }
+        continue;
+      }
+
       // Serialize the value using the column definition and database type
       result[dbColumnName] = this.#serializer.serialize(value, col);
     }
@@ -120,9 +150,18 @@ export class UnitOfWorkEncoder {
    * @param dbColumnName - The database column name (e.g., "user_id")
    * @returns The column definition or undefined if not found
    */
-  private findColumnByDbName(table: AnyTable, dbColumnName: string): AnyColumn | undefined {
+  private findColumnByDbName(
+    table: AnyTable,
+    dbColumnName: string,
+    columnMap?: Record<string, string>,
+  ): AnyColumn | undefined {
+    const logicalName = columnMap?.[dbColumnName] ?? dbColumnName;
+    const direct = table.columns[logicalName];
+    if (direct) {
+      return direct;
+    }
     for (const col of Object.values(table.columns)) {
-      if (col.name === dbColumnName) {
+      if (col.name === logicalName) {
         return col;
       }
     }

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

@@ -0,0 +1,193 @@
+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 { evaluateCondition } from "./condition-evaluator";
+import { createNamespaceStore } from "./store";
+
+describe("in-memory condition evaluator", () => {
+  it("evaluates SQLite-normalized comparisons and LIKE semantics", () => {
+    const testSchema = schema("test", (s) =>
+      s.addTable("events", (t) =>
+        t
+          .addColumn("id", idColumn())
+          .addColumn("name", column("string"))
+          .addColumn("createdAt", column("timestamp"))
+          .addColumn("isActive", column("bool"))
+          .addColumn("payload", column("json"))
+          .addColumn("size", column("bigint")),
+      ),
+    );
+
+    const table = testSchema.tables.events;
+    const createdAt = new Date("2024-01-01T00:00:00.000Z");
+    const payload = { ok: true, count: 2 };
+    const row = {
+      id: "evt_1",
+      name: "Test User",
+      createdAt,
+      isActive: true,
+      payload,
+      size: 9n,
+    };
+
+    expect(
+      evaluateCondition(
+        buildCondition(table.columns, (eb) => eb("createdAt", "=", createdAt)),
+        table,
+        row,
+      ),
+    ).toBe(true);
+    const numericBooleanCondition: Condition = {
+      type: "compare",
+      a: table.columns.isActive,
+      operator: "=",
+      b: 1,
+    };
+    expect(evaluateCondition(numericBooleanCondition, table, row)).toBe(true);
+    expect(
+      evaluateCondition(
+        buildCondition(table.columns, (eb) => eb("payload", "=", payload)),
+        table,
+        row,
+      ),
+    ).toBe(true);
+    expect(
+      evaluateCondition(
+        buildCondition(table.columns, (eb) => eb("size", ">", 8n)),
+        table,
+        row,
+      ),
+    ).toBe(true);
+    expect(
+      evaluateCondition(
+        buildCondition(table.columns, (eb) => eb("name", "contains", "test")),
+        table,
+        row,
+      ),
+    ).toBe(true);
+    expect(
+      evaluateCondition(
+        buildCondition(table.columns, (eb) => eb("name", "starts with", "TEST")),
+        table,
+        row,
+      ),
+    ).toBe(true);
+    expect(
+      evaluateCondition(
+        buildCondition(table.columns, (eb) => eb("name", "ends with", "user")),
+        table,
+        row,
+      ),
+    ).toBe(true);
+  });
+
+  it("handles null and IN semantics", () => {
+    const testSchema = schema("test", (s) =>
+      s.addTable("events", (t) =>
+        t
+          .addColumn("id", idColumn())
+          .addColumn("age", column("integer").nullable())
+          .addColumn("size", column("bigint")),
+      ),
+    );
+
+    const table = testSchema.tables.events;
+    const row = {
+      id: "evt_2",
+      age: null,
+      size: 9n,
+    };
+
+    expect(
+      evaluateCondition(
+        buildCondition(table.columns, (eb) => eb("age", "is", null)),
+        table,
+        row,
+      ),
+    ).toBe(true);
+    expect(
+      evaluateCondition(
+        buildCondition(table.columns, (eb) => eb("age", "=", null)),
+        table,
+        row,
+      ),
+    ).toBe(false);
+    expect(
+      evaluateCondition(
+        buildCondition(table.columns, (eb) => eb("age", "is not", null)),
+        table,
+        row,
+      ),
+    ).toBe(false);
+
+    const inCondition: Condition = {
+      type: "compare",
+      a: table.columns.size,
+      operator: "in",
+      b: [1n, null],
+    };
+    const notInCondition: Condition = {
+      type: "compare",
+      a: table.columns.size,
+      operator: "not in",
+      b: [1n, null],
+    };
+
+    expect(evaluateCondition(inCondition, table, row)).toBe(false);
+    expect(evaluateCondition(notInCondition, table, row)).toBe(false);
+    expect(
+      evaluateCondition(
+        buildCondition(table.columns, (eb) => eb("size", "not in", [1n, 2n])),
+        table,
+        row,
+      ),
+    ).toBe(true);
+  });
+
+  it("resolves reference values against the namespace store", () => {
+    const refSchema = schema("ref", (s) =>
+      s
+        .addTable("users", (t) =>
+          t.addColumn("id", idColumn()).addColumn("email", column("string")),
+        )
+        .addTable("posts", (t) =>
+          t
+            .addColumn("id", idColumn())
+            .addColumn("title", column("string"))
+            .addColumn("userId", referenceColumn()),
+        )
+        .addReference("author", {
+          type: "one",
+          from: { table: "posts", column: "userId" },
+          to: { table: "users", column: "id" },
+        }),
+    );
+
+    const namespaceStore = createNamespaceStore(refSchema);
+    const usersStore = namespaceStore.tables.get("users");
+    const postsTable = refSchema.tables.posts;
+
+    if (!usersStore) {
+      throw new Error("users table missing from namespace store");
+    }
+
+    usersStore.rows.set(1n, {
+      id: "user_1",
+      email: "user@example.com",
+      _internalId: 1n,
+      _version: 0,
+    });
+
+    const postRow = {
+      id: "post_1",
+      title: "Hello",
+      userId: 1n,
+      _internalId: 10n,
+      _version: 0,
+    };
+
+    const condition = buildCondition(postsTable.columns, (eb) => eb("userId", "=", "user_1"));
+    expect(evaluateCondition(condition, postsTable, postRow, namespaceStore)).toBe(true);
+  });
+});