@effect-app/infra 4.0.0-beta.99 → 4.0.1

package/test/sql-store.test.ts

@@ -1,10 +1,11 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import type Sqlite from "better-sqlite3"
 import BetterSqlite from "better-sqlite3"
+import * as S from "effect-app/Schema"
 import { describe, expect, it } from "vitest"
 import { parseRow } from "../src/Store/SQL.js"
 import { buildWhereSQLQuery, pgDialect, sqliteDialect } from "../src/Store/SQL/query.js"
-import { makeETag } from "../src/Store/utils.js"
+import { makeETag, makeJsonLower } from "../src/Store/utils.js"
 
 const query = (db: Sqlite.Database, sql: string, params: unknown[] = []) =>
   db.prepare(sql).all(...params as any[]) as any[]
@@ -24,11 +25,182 @@ describe("SQL query builder (SQLite dialect)", () => {
     expect(result.params).toContain("John")
   })
 
+  it("where eq Date binds ISO string", () => {
+    const result = buildWhereSQLQuery(
+      sqliteDialect,
+      "id",
+      [{ t: "where", path: "n", op: "eq", value: new Date("2024-01-01T00:00:00.000Z") }],
+      "users",
+      {}
+    )
+    expect(result.params).toContain("2024-01-01T00:00:00.000Z")
+  })
+
+  it("where eq app native Encoded binds via JsonLower", () => {
+    class Day {
+      readonly ymd: string
+      constructor(ymd: string) {
+        this.ymd = ymd
+      }
+    }
+    const day = new Day("2024-06-01")
+    const json = {
+      toJson: (v: unknown) => v instanceof Day ? v.ymd : v,
+      jsonifyFilter: (filter: readonly { t: string; path?: string; op?: string; value?: unknown }[]) =>
+        filter.map((r) => r.t === "where" ? { ...r, value: r.value instanceof Day ? r.value.ymd : r.value } : r)
+    }
+    const result = buildWhereSQLQuery(
+      sqliteDialect,
+      "id",
+      [{ t: "where", path: "day", op: "eq", value: day }],
+      "users",
+      {},
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      json as never
+    )
+    expect(result.params).toContain("2024-06-01")
+  })
+
+  it("does not re-encode store-lowered Date defaultValues", () => {
+    class Item extends S.Class<Item>("SqlDefaultValuesItem")({
+      id: S.String,
+      at: S.Date
+    }) {}
+    const json = makeJsonLower({ schema: Item })
+    const at = new Date("2024-06-01T00:00:00.000Z")
+    const lowered = json.toJson({ at }) as Record<string, unknown>
+    const result = buildWhereSQLQuery(
+      sqliteDialect,
+      "id",
+      [{ t: "where", path: "at", op: "eq", value: at }],
+      "items",
+      lowered,
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      json
+    )
+    expect(result.sql).toContain("COALESCE(")
+    expect(result.params).toContain("2024-06-01T00:00:00.000Z")
+  })
+
+  it("where in Set binds array values", () => {
+    const result = buildWhereSQLQuery(
+      sqliteDialect,
+      "id",
+      [{ t: "where", path: "tags", op: "in", value: new Set(["a", "b"]) }],
+      "users",
+      {}
+    )
+    expect(result.params).toEqual(expect.arrayContaining(["a", "b"]))
+  })
+
+  it("where includes Date binds ISO string", () => {
+    const result = buildWhereSQLQuery(
+      sqliteDialect,
+      "id",
+      [{ t: "where", path: "dates", op: "includes", value: new Date("2024-01-01T00:00:00.000Z") }],
+      "users",
+      {}
+    )
+    expect(result.params).toContain("2024-01-01T00:00:00.000Z")
+  })
+
+  it("where hasKey / hasValue / hasKeyValue on Map JSON tuples", () => {
+    const key = buildWhereSQLQuery(
+      sqliteDialect,
+      "id",
+      [{ t: "where", path: "meta", op: "hasKey", value: "n" }],
+      "users",
+      {}
+    )
+    expect(key.sql).toContain("json_extract(value, '$[0]')")
+    expect(key.params).toContain("n")
+
+    const value = buildWhereSQLQuery(
+      sqliteDialect,
+      "id",
+      [{ t: "where", path: "meta", op: "hasValue", value: 1 }],
+      "users",
+      {}
+    )
+    expect(value.sql).toContain("json_extract(value, '$[1]')")
+    expect(value.params).toContain(1)
+
+    const pair = buildWhereSQLQuery(
+      sqliteDialect,
+      "id",
+      [{ t: "where", path: "meta", op: "hasKeyValue", value: ["n", 1] }],
+      "users",
+      {}
+    )
+    expect(pair.sql).toContain("json_each")
+    expect(pair.params).toContain(JSON.stringify(["n", 1]))
+
+    const anyKeys = buildWhereSQLQuery(
+      sqliteDialect,
+      "id",
+      [{ t: "where", path: "meta", op: "hasKey-any", value: ["n", "x"] }],
+      "users",
+      {}
+    )
+    expect(anyKeys.sql).toContain(" OR ")
+    expect(anyKeys.params).toEqual(expect.arrayContaining(["n", "x"]))
+  })
+
+  it("pg where hasKey / hasKeyValue uses jsonb tuple elements", () => {
+    const key = buildWhereSQLQuery(
+      pgDialect,
+      "id",
+      [{ t: "where", path: "meta", op: "hasKey", value: "n" }],
+      "users",
+      {}
+    )
+    expect(key.sql).toContain("jsonb_array_elements")
+    expect(key.sql).toContain("e->0")
+    expect(key.params).toContain(JSON.stringify("n"))
+
+    const pair = buildWhereSQLQuery(
+      pgDialect,
+      "id",
+      [{ t: "where", path: "meta", op: "hasKeyValue", value: ["n", 1] }],
+      "users",
+      {}
+    )
+    expect(pair.sql).toContain("@>")
+    expect(pair.sql).toContain("jsonb_build_array")
+    expect(pair.params).toContain(JSON.stringify(["n", 1]))
+  })
+
+  it("where includes-any Date[] binds ISO strings", () => {
+    const result = buildWhereSQLQuery(
+      sqliteDialect,
+      "id",
+      [{
+        t: "where",
+        path: "dates",
+        op: "includes-any",
+        value: [new Date("2024-01-01T00:00:00.000Z"), new Date("2024-06-01T00:00:00.000Z")]
+      }],
+      "users",
+      {}
+    )
+    expect(result.params).toEqual(
+      expect.arrayContaining(["2024-01-01T00:00:00.000Z", "2024-06-01T00:00:00.000Z"])
+    )
+  })
+
   it("where eq number", () => {
     const result = buildWhereSQLQuery(
       sqliteDialect,
       "id",
-      [{ t: "where", path: "age", op: "eq", value: 25 as any }],
+      [{ t: "where", path: "age", op: "eq", value: 25 }],
       "users",
       {}
     )
@@ -40,7 +212,7 @@ describe("SQL query builder (SQLite dialect)", () => {
     const result = buildWhereSQLQuery(
       sqliteDialect,
       "id",
-      [{ t: "where", path: "age", op: "gt", value: 18 as any }],
+      [{ t: "where", path: "age", op: "gt", value: 18 }],
       "users",
       {}
     )
@@ -70,7 +242,7 @@ describe("SQL query builder (SQLite dialect)", () => {
       "id",
       [
         { t: "where", path: "name", op: "eq", value: "Alice" },
-        { t: "and", path: "age", op: "gt", value: 18 as any }
+        { t: "and", path: "age", op: "gt", value: 18 }
       ],
       "users",
       {}
@@ -83,7 +255,7 @@ describe("SQL query builder (SQLite dialect)", () => {
     const result = buildWhereSQLQuery(
       sqliteDialect,
       "id",
-      [{ t: "where", path: "id", op: "in", value: ["a", "b", "c"] as any }],
+      [{ t: "where", path: "id", op: "in", value: ["a", "b", "c"] }],
       "users",
       {}
     )
@@ -167,7 +339,7 @@ describe("SQL query builder (SQLite dialect)", () => {
     const result = buildWhereSQLQuery(
       sqliteDialect,
       "id",
-      [{ t: "where", path: "tags", op: "includes-any", value: ["admin", "user"] as any }],
+      [{ t: "where", path: "tags", op: "includes-any", value: ["admin", "user"] }],
       "users",
       {}
     )
@@ -228,6 +400,241 @@ describe("SQL query builder (SQLite dialect)", () => {
     expect(result.sql).toContain("LIMIT")
     expect(result.sql).toContain("OFFSET")
   })
+
+  it("computed relation count projection", () => {
+    const result = buildWhereSQLQuery(
+      sqliteDialect,
+      "id",
+      [],
+      "users",
+      {},
+      [{
+        key: "pickedCount",
+        computed: {
+          _tag: "relation-count",
+          path: "items",
+          filter: [{ t: "where", path: "items.-1.description", op: "contains", value: "picked" }]
+        }
+      }]
+    )
+    expect(result.sql).toContain(`SELECT COUNT(1) FROM json_each(data, '$.items') AS _items`)
+    expect(result.sql).toContain(`AS "pickedCount"`)
+    expect(result.params).toContain("%picked%")
+  })
+
+  it("computed relation any projection (sqlite bool encoding)", () => {
+    const result = buildWhereSQLQuery(
+      sqliteDialect,
+      "id",
+      [],
+      "users",
+      {},
+      [{
+        key: "hasPicked",
+        computed: {
+          _tag: "relation-any",
+          path: "items",
+          filter: [{ t: "where", path: "items.-1.description", op: "contains", value: "picked" }]
+        }
+      }]
+    )
+    expect(result.sql).toContain("CASE WHEN EXISTS(")
+    expect(result.sql).toContain(`AS "hasPicked"`)
+  })
+
+  it("computed relation every projection (sqlite emits NOT EXISTS NOT)", () => {
+    const result = buildWhereSQLQuery(
+      sqliteDialect,
+      "id",
+      [],
+      "users",
+      {},
+      [{
+        key: "allPicked",
+        computed: {
+          _tag: "relation-every",
+          path: "items",
+          filter: [{ t: "where", path: "items.-1.state._tag", op: "eq", value: "picked" }]
+        }
+      }]
+    )
+    expect(result.sql).toContain(`NOT EXISTS(SELECT 1 FROM json_each(data, '$.items') AS _items WHERE NOT (`)
+    expect(result.sql).toContain(`AS "allPicked"`)
+    expect(result.params).toContain("picked")
+  })
+
+  it("computed relation-every with no filter degenerates to true", () => {
+    const result = buildWhereSQLQuery(
+      sqliteDialect,
+      "id",
+      [],
+      "users",
+      {},
+      [{
+        key: "allPicked",
+        computed: { _tag: "relation-every", path: "items", filter: [] }
+      }]
+    )
+    expect(result.sql).toContain("CASE WHEN 1=1")
+    expect(result.sql).toContain(`AS "allPicked"`)
+  })
+
+  it("computed relation-distinct-count projection (sqlite)", () => {
+    const result = buildWhereSQLQuery(
+      sqliteDialect,
+      "id",
+      [],
+      "users",
+      {},
+      [{
+        key: "positionCount",
+        computed: {
+          _tag: "relation-distinct-count",
+          path: "items",
+          field: "rowId",
+          filter: [{ t: "where", path: "items.-1.state._tag", op: "neq", value: "cancelled" }]
+        }
+      }]
+    )
+    expect(result.sql).toContain(`SELECT COUNT(DISTINCT json_extract(_items.value, '$.rowId'))`)
+    expect(result.sql).toContain(`AS "positionCount"`)
+    expect(result.params).toContain("cancelled")
+  })
+
+  it("computed relation-sum projection (sqlite casts to REAL)", () => {
+    const result = buildWhereSQLQuery(
+      sqliteDialect,
+      "id",
+      [],
+      "users",
+      {},
+      [{
+        key: "totalWeight",
+        computed: { _tag: "relation-sum", path: "items", field: "weight", filter: [] }
+      }]
+    )
+    expect(result.sql).toContain(`SELECT COALESCE(SUM(CAST(json_extract(_items.value, '$.weight') AS REAL)), 0)`)
+    expect(result.sql).toContain(`AS "totalWeight"`)
+  })
+
+  it("computed relation-sum-expr projection (sqlite)", () => {
+    const result = buildWhereSQLQuery(
+      sqliteDialect,
+      "id",
+      [],
+      "users",
+      {},
+      [{
+        key: "totalWeighted",
+        computed: {
+          _tag: "relation-sum-expr",
+          path: "items",
+          expression: {
+            _tag: "mul",
+            left: { _tag: "field", field: "weight" },
+            right: { _tag: "field", field: "tradeUnit.amount" }
+          },
+          filter: []
+        }
+      }]
+    )
+    expect(result.sql).toContain(
+      `COALESCE(SUM((CAST(json_extract(_items.value, '$.weight') AS REAL) * CAST(json_extract(_items.value, '$.tradeUnit.amount') AS REAL))), 0)`
+    )
+    expect(result.sql).toContain(`AS "totalWeighted"`)
+  })
+
+  it("computed relation-sum-expr-by projection (sqlite)", () => {
+    const result = buildWhereSQLQuery(
+      sqliteDialect,
+      "id",
+      [],
+      "users",
+      {},
+      [{
+        key: "totalsByUnit",
+        computed: {
+          _tag: "relation-sum-expr-by",
+          path: "items",
+          expression: {
+            _tag: "mul",
+            left: { _tag: "field", field: "weight" },
+            right: { _tag: "field", field: "tradeUnit.amount" }
+          },
+          unit: "tradeUnit.unit",
+          filter: []
+        }
+      }]
+    )
+    expect(result.sql).toContain(`json_group_array(json_object('unit', __unit, 'total', __total))`)
+    expect(result.sql).toContain(`GROUP BY json_extract(_items.value, '$.tradeUnit.unit')`)
+    expect(result.sql).toContain(`AS "totalsByUnit"`)
+  })
+
+  it("computed relation-sum-expr-normalized projection (sqlite)", () => {
+    const result = buildWhereSQLQuery(
+      sqliteDialect,
+      "id",
+      [],
+      "users",
+      {},
+      [{
+        key: "totalKg",
+        computed: {
+          _tag: "relation-sum-expr-normalized",
+          path: "items",
+          expression: {
+            _tag: "mul",
+            left: { _tag: "field", field: "weight" },
+            right: { _tag: "field", field: "tradeUnit.amount" }
+          },
+          unit: "tradeUnit.unit",
+          toBase: "kg",
+          factors: { g: 0.001 },
+          filter: []
+        }
+      }]
+    )
+    expect(result.sql).toContain(
+      `CASE json_extract(_items.value, '$.tradeUnit.unit') WHEN 'kg' THEN 1 WHEN 'g' THEN 0.001 ELSE NULL END`
+    )
+    expect(result.sql).toContain(`AS "totalKg"`)
+  })
+
+  it("computed relation-collect (non-distinct) projection (sqlite)", () => {
+    const result = buildWhereSQLQuery(
+      sqliteDialect,
+      "id",
+      [],
+      "users",
+      {},
+      [{
+        key: "tags",
+        computed: { _tag: "relation-collect", path: "items", field: "articleId", distinct: false, filter: [] }
+      }]
+    )
+    expect(result.sql).toContain(
+      `SELECT COALESCE(json_group_array(json_extract(_items.value, '$.articleId')), json_array())`
+    )
+    expect(result.sql).toContain(`AS "tags"`)
+  })
+
+  it("computed relation-collect (distinct) emits inner DISTINCT subquery (sqlite)", () => {
+    const result = buildWhereSQLQuery(
+      sqliteDialect,
+      "id",
+      [],
+      "users",
+      {},
+      [{
+        key: "tags",
+        computed: { _tag: "relation-collect", path: "items", field: "articleId", distinct: true, filter: [] }
+      }]
+    )
+    expect(result.sql).toContain(`json_group_array(__v)`)
+    expect(result.sql).toContain(`SELECT DISTINCT json_extract(_items.value, '$.articleId') AS __v`)
+    expect(result.sql).toContain(`AS "tags"`)
+  })
 })
 
 describe("SQL query builder (PostgreSQL dialect)", () => {
@@ -260,7 +667,7 @@ describe("SQL query builder (PostgreSQL dialect)", () => {
     const result = buildWhereSQLQuery(
       pgDialect,
       "id",
-      [{ t: "where", path: "status", op: "in", value: ["active", "pending"] as any }],
+      [{ t: "where", path: "status", op: "in", value: ["active", "pending"] }],
       "users",
       {}
     )
@@ -291,33 +698,218 @@ describe("SQL query builder (PostgreSQL dialect)", () => {
     )
     expect(result.sql).toContain("data->'address'->>'city'")
   })
-})
 
-// --- Integration tests with in-memory SQLite (direct, no Effect SQL client) ---
+  it("computed relation any projection", () => {
+    const result = buildWhereSQLQuery(
+      pgDialect,
+      "id",
+      [],
+      "users",
+      {},
+      [{
+        key: "hasPicked",
+        computed: {
+          _tag: "relation-any",
+          path: "items",
+          filter: [{ t: "where", path: "items.-1.description", op: "contains", value: "picked" }]
+        }
+      }]
+    )
+    expect(result.sql).toContain("EXISTS(SELECT 1 FROM jsonb_array_elements(data->'items') AS _items")
+    expect(result.sql).toContain(`AS "hasPicked"`)
+  })
 
-describe("SQL Store (SQLite integration)", () => {
-  const withDb = (fn: (db: Sqlite.Database) => void) => {
-    const db = new BetterSqlite(":memory:")
-    db.pragma("journal_mode = WAL")
-    try {
-      fn(db)
-    } finally {
-      db.close()
-    }
-  }
+  it("computed relation-every (pg)", () => {
+    const result = buildWhereSQLQuery(
+      pgDialect,
+      "id",
+      [],
+      "users",
+      {},
+      [{
+        key: "allPicked",
+        computed: {
+          _tag: "relation-every",
+          path: "items",
+          filter: [{ t: "where", path: "items.-1.state._tag", op: "eq", value: "picked" }]
+        }
+      }]
+    )
+    expect(result.sql).toContain(`NOT EXISTS(SELECT 1 FROM jsonb_array_elements(data->'items') AS _items WHERE NOT (`)
+    expect(result.sql).toContain(`AS "allPicked"`)
+  })
 
-  it("creates table and seeds data", () =>
-    withDb((db) => {
-      db.exec(
-        `CREATE TABLE IF NOT EXISTS "test_items" (id TEXT PRIMARY KEY, _etag TEXT, data JSON NOT NULL)`
-      )
-      db
-        .prepare(`INSERT INTO "test_items" (id, _etag, data) VALUES (?, ?, ?)`)
-        .run("1", "etag1", JSON.stringify({ name: "Alice", age: 30 }))
+  it("computed relation-distinct-count (pg)", () => {
+    const result = buildWhereSQLQuery(
+      pgDialect,
+      "id",
+      [],
+      "users",
+      {},
+      [{
+        key: "positions",
+        computed: { _tag: "relation-distinct-count", path: "items", field: "rowId", filter: [] }
+      }]
+    )
+    expect(result.sql).toContain(`COUNT(DISTINCT _items->>'rowId')`)
+    expect(result.sql).toContain(`AS "positions"`)
+  })
 
-      const rows = db.prepare(`SELECT * FROM "test_items"`).all()
-      expect(rows.length).toBe(1)
-      expect((rows[0] as any).id).toBe("1")
+  it("computed relation-sum (pg casts via ::numeric)", () => {
+    const result = buildWhereSQLQuery(
+      pgDialect,
+      "id",
+      [],
+      "users",
+      {},
+      [{
+        key: "totalWeight",
+        computed: { _tag: "relation-sum", path: "items", field: "weight", filter: [] }
+      }]
+    )
+    expect(result.sql).toContain(`COALESCE(SUM((_items->>'weight')::numeric), 0)`)
+    expect(result.sql).toContain(`AS "totalWeight"`)
+  })
+
+  it("computed relation-sum-expr (pg)", () => {
+    const result = buildWhereSQLQuery(
+      pgDialect,
+      "id",
+      [],
+      "users",
+      {},
+      [{
+        key: "totalWeighted",
+        computed: {
+          _tag: "relation-sum-expr",
+          path: "items",
+          expression: {
+            _tag: "mul",
+            left: { _tag: "field", field: "weight" },
+            right: { _tag: "field", field: "tradeUnit.amount" }
+          },
+          filter: []
+        }
+      }]
+    )
+    expect(result.sql).toContain(
+      `COALESCE(SUM(((_items->>'weight')::numeric * (_items->'tradeUnit'->>'amount')::numeric)), 0)`
+    )
+    expect(result.sql).toContain(`AS "totalWeighted"`)
+  })
+
+  it("computed relation-sum-expr-by (pg)", () => {
+    const result = buildWhereSQLQuery(
+      pgDialect,
+      "id",
+      [],
+      "users",
+      {},
+      [{
+        key: "totalsByUnit",
+        computed: {
+          _tag: "relation-sum-expr-by",
+          path: "items",
+          expression: {
+            _tag: "mul",
+            left: { _tag: "field", field: "weight" },
+            right: { _tag: "field", field: "tradeUnit.amount" }
+          },
+          unit: "tradeUnit.unit",
+          filter: []
+        }
+      }]
+    )
+    expect(result.sql).toContain(`jsonb_agg(jsonb_build_object('unit', __unit, 'total', __total))`)
+    expect(result.sql).toContain(`GROUP BY _items->'tradeUnit'->>'unit'`)
+    expect(result.sql).toContain(`AS "totalsByUnit"`)
+  })
+
+  it("computed relation-sum-expr-normalized (pg)", () => {
+    const result = buildWhereSQLQuery(
+      pgDialect,
+      "id",
+      [],
+      "users",
+      {},
+      [{
+        key: "totalKg",
+        computed: {
+          _tag: "relation-sum-expr-normalized",
+          path: "items",
+          expression: {
+            _tag: "mul",
+            left: { _tag: "field", field: "weight" },
+            right: { _tag: "field", field: "tradeUnit.amount" }
+          },
+          unit: "tradeUnit.unit",
+          toBase: "kg",
+          factors: { g: 0.001 },
+          filter: []
+        }
+      }]
+    )
+    expect(result.sql).toContain(`CASE _items->'tradeUnit'->>'unit' WHEN 'kg' THEN 1 WHEN 'g' THEN 0.001 ELSE NULL END`)
+    expect(result.sql).toContain(`AS "totalKg"`)
+  })
+
+  it("computed relation-collect (pg jsonb_agg)", () => {
+    const result = buildWhereSQLQuery(
+      pgDialect,
+      "id",
+      [],
+      "users",
+      {},
+      [{
+        key: "ids",
+        computed: { _tag: "relation-collect", path: "items", field: "articleId", distinct: false, filter: [] }
+      }]
+    )
+    expect(result.sql).toContain(`COALESCE(jsonb_agg(_items->>'articleId'), '[]'::jsonb)`)
+    expect(result.sql).toContain(`AS "ids"`)
+  })
+
+  it("computed relation-collect distinct (pg jsonb_agg DISTINCT)", () => {
+    const result = buildWhereSQLQuery(
+      pgDialect,
+      "id",
+      [],
+      "users",
+      {},
+      [{
+        key: "ids",
+        computed: { _tag: "relation-collect", path: "items", field: "articleId", distinct: true, filter: [] }
+      }]
+    )
+    expect(result.sql).toContain(`COALESCE(jsonb_agg(DISTINCT _items->>'articleId'), '[]'::jsonb)`)
+  })
+})
+
+// --- Integration tests with in-memory SQLite (direct, no Effect SQL client) ---
+
+describe("SQL Store (SQLite integration)", () => {
+  const withDb = (fn: (db: Sqlite.Database) => void) => {
+    const db = new BetterSqlite(":memory:")
+    db.pragma("journal_mode = WAL")
+    try {
+      fn(db)
+    } finally {
+      db.close()
+    }
+  }
+
+  it("creates table and seeds data", () =>
+    withDb((db) => {
+      db.exec(
+        `CREATE TABLE IF NOT EXISTS "test_items" (id TEXT PRIMARY KEY, _etag TEXT, data JSON NOT NULL)`
+      )
+      db
+        .prepare(`INSERT INTO "test_items" (id, _etag, data) VALUES (?, ?, ?)`)
+        .run("1", "etag1", JSON.stringify({ name: "Alice", age: 30 }))
+
+      const rows = db.prepare(`SELECT * FROM "test_items"`).all()
+      expect(rows.length).toBe(1)
+      expect((rows[0] as any).id).toBe("1")
     }))
 
   it("data column should not contain _etag or id", () =>
@@ -367,7 +959,7 @@ describe("SQL Store (SQLite integration)", () => {
       )
       const r1 = query(db, q1.sql, q1.params)
       expect(r1.length).toBe(1)
-      expect((r1[0] as any).id).toBe("1")
+      expect(r1[0].id).toBe("1")
 
       const q2 = buildWhereSQLQuery(
         sqliteDialect,
@@ -378,13 +970,13 @@ describe("SQL Store (SQLite integration)", () => {
       )
       const r2 = query(db, q2.sql, q2.params)
       expect(r2.length).toBe(1)
-      expect((r2[0] as any).id).toBe("2")
+      expect(r2[0].id).toBe("2")
 
       // Both queryable by id column
       const q3 = buildWhereSQLQuery(
         sqliteDialect,
         "id",
-        [{ t: "where", path: "id", op: "in", value: ["1", "2"] as any }],
+        [{ t: "where", path: "id", op: "in", value: ["1", "2"] }],
         "test_compat",
         {}
       )
@@ -410,7 +1002,7 @@ describe("SQL Store (SQLite integration)", () => {
       const q1 = buildWhereSQLQuery(
         sqliteDialect,
         "id",
-        [{ t: "where", path: "age", op: "gt", value: 28 as any }],
+        [{ t: "where", path: "age", op: "gt", value: 28 }],
         "test_noid",
         {}
       )
@@ -426,8 +1018,8 @@ describe("SQL Store (SQLite integration)", () => {
       )
       const r2 = query(db, q2.sql, q2.params)
       expect(r2.length).toBe(1)
-      expect((r2[0] as any).id).toBe("2")
-      expect((JSON.parse((r2[0] as any).data) as any).name).toBe("Bob")
+      expect(r2[0].id).toBe("2")
+      expect((JSON.parse(r2[0].data) as any).name).toBe("Bob")
 
       // Order + limit still works
       const q3 = buildWhereSQLQuery(
@@ -443,7 +1035,7 @@ describe("SQL Store (SQLite integration)", () => {
       )
       const r3 = query(db, q3.sql, q3.params)
       expect(r3.length).toBe(2)
-      expect((JSON.parse((r3[0] as any).data) as any).name).toBe("Bob") // youngest first
+      expect((JSON.parse(r3[0].data) as any).name).toBe("Bob") // youngest first
     }))
 
   it("query builder generates valid SQL for SQLite", () =>
@@ -476,13 +1068,13 @@ describe("SQL Store (SQLite integration)", () => {
         {}
       )
       expect(query(db, q1.sql, q1.params).length).toBe(1)
-      expect((JSON.parse((query(db, q1.sql, q1.params)[0] as any).data) as any).name).toBe("Alice")
+      expect((JSON.parse(query(db, q1.sql, q1.params)[0].data) as any).name).toBe("Alice")
 
       // Test gt
       const q2 = buildWhereSQLQuery(
         sqliteDialect,
         "id",
-        [{ t: "where", path: "age", op: "gt", value: 28 as any }],
+        [{ t: "where", path: "age", op: "gt", value: 28 }],
         "test_people",
         {}
       )
@@ -507,20 +1099,20 @@ describe("SQL Store (SQLite integration)", () => {
         "id",
         [
           { t: "where", path: "name", op: "eq", value: "Alice" },
-          { t: "and", path: "age", op: "gt", value: 25 as any }
+          { t: "and", path: "age", op: "gt", value: 25 }
         ],
         "test_people",
         {}
       )
       const r4 = query(db, q4.sql, q4.params)
       expect(r4.length).toBe(1)
-      expect((JSON.parse((r4[0] as any).data) as any).name).toBe("Alice")
+      expect((JSON.parse(r4[0].data) as any).name).toBe("Alice")
 
       // Test IN
       const q5 = buildWhereSQLQuery(
         sqliteDialect,
         "id",
-        [{ t: "where", path: "id", op: "in", value: ["1", "3"] as any }],
+        [{ t: "where", path: "id", op: "in", value: ["1", "3"] }],
         "test_people",
         {}
       )
@@ -546,7 +1138,7 @@ describe("SQL Store (SQLite integration)", () => {
       )
       const r7 = query(db, q7.sql, q7.params)
       expect(r7.length).toBe(1)
-      expect((JSON.parse((r7[0] as any).data) as any).name).toBe("Alice")
+      expect((JSON.parse(r7[0].data) as any).name).toBe("Alice")
 
       // Test includes (array)
       const q8 = buildWhereSQLQuery(
@@ -567,7 +1159,7 @@ describe("SQL Store (SQLite integration)", () => {
           {
             t: "or-scope",
             result: [
-              { t: "where", path: "age", op: "gt", value: 30 as any },
+              { t: "where", path: "age", op: "gt", value: 30 },
               { t: "and", path: "name", op: "contains", value: "ar" }
             ],
             relation: "some"
@@ -592,7 +1184,115 @@ describe("SQL Store (SQLite integration)", () => {
       )
       const r10 = query(db, q10.sql, q10.params)
       expect(r10.length).toBe(2)
-      expect((JSON.parse((r10[0] as any).data) as any).name).toBe("Charlie") // oldest first
+      expect((JSON.parse(r10[0].data) as any).name).toBe("Charlie") // oldest first
+    }))
+
+  it("computed relation-every / distinct-count / sum / collect run on SQLite", () =>
+    withDb((db) => {
+      db.exec(`CREATE TABLE "test_orders" (id TEXT PRIMARY KEY, _etag TEXT, data JSON NOT NULL)`)
+      const orders = [
+        {
+          id: "o1",
+          items: [
+            { rowId: "r1", articleId: "A", weight: 1.5, state: { _tag: "picked" } },
+            { rowId: "r2", articleId: "A", weight: 2.5, state: { _tag: "picked" } },
+            { rowId: "r2", articleId: "B", weight: 0.25, state: { _tag: "picking" } }
+          ]
+        },
+        {
+          id: "o2",
+          items: [
+            { rowId: "r9", articleId: "Z", weight: 10, state: { _tag: "packed" } }
+          ]
+        }
+      ]
+      const insert = db.prepare(`INSERT INTO "test_orders" (id, _etag, data) VALUES (?, ?, ?)`)
+      for (const o of orders) {
+        const { id, ...data } = o
+        insert.run(id, `etag_${id}`, JSON.stringify(data))
+      }
+
+      const q = buildWhereSQLQuery(
+        sqliteDialect,
+        "id",
+        [],
+        "test_orders",
+        {},
+        [
+          {
+            key: "allPicked",
+            computed: {
+              _tag: "relation-every",
+              path: "items",
+              filter: [{ t: "where", path: "items.-1.state._tag", op: "eq", value: "picked" }]
+            }
+          },
+          {
+            key: "positionCount",
+            computed: { _tag: "relation-distinct-count", path: "items", field: "rowId", filter: [] }
+          },
+          {
+            key: "totalWeight",
+            computed: { _tag: "relation-sum", path: "items", field: "weight", filter: [] }
+          },
+          {
+            key: "articleIds",
+            computed: {
+              _tag: "relation-collect",
+              path: "items",
+              field: "articleId",
+              distinct: true,
+              filter: []
+            }
+          }
+        ] as any,
+        [{ key: "id", direction: "ASC" }] as any
+      )
+      const rows = query(db, q.sql, q.params) as Array<Record<string, unknown>>
+      expect(rows.length).toBe(2)
+      // o1: not all picked (one is "picking")
+      expect(JSON.parse(rows[0]!["allPicked"] as string)).toBe(false)
+      expect(rows[0]!["positionCount"]).toBe(2)
+      expect(rows[0]!["totalWeight"]).toBeCloseTo(4.25)
+      expect((JSON.parse(rows[0]!["articleIds"] as string) as string[]).sort()).toEqual(["A", "B"])
+      // o2: all packed (so not "picked"), allPicked = !exists(NOT picked) = false
+      expect(JSON.parse(rows[1]!["allPicked"] as string)).toBe(false)
+      expect(rows[1]!["positionCount"]).toBe(1)
+      expect(rows[1]!["totalWeight"]).toBeCloseTo(10)
+      expect(JSON.parse(rows[1]!["articleIds"] as string)).toEqual(["Z"])
+    }))
+
+  it("computed relation-every is true when all items match filter", () =>
+    withDb((db) => {
+      db.exec(`CREATE TABLE "test_every" (id TEXT PRIMARY KEY, _etag TEXT, data JSON NOT NULL)`)
+      db.prepare(`INSERT INTO "test_every" (id, _etag, data) VALUES (?, ?, ?)`).run(
+        "1",
+        "e",
+        JSON.stringify({
+          items: [
+            { state: { _tag: "picked" } },
+            { state: { _tag: "picked" } }
+          ]
+        })
+      )
+
+      const q = buildWhereSQLQuery(
+        sqliteDialect,
+        "id",
+        [],
+        "test_every",
+        {},
+        [{
+          key: "allPicked",
+          computed: {
+            _tag: "relation-every",
+            path: "items",
+            filter: [{ t: "where", path: "items.-1.state._tag", op: "eq", value: "picked" }]
+          }
+        }]
+      )
+      const rows = query(db, q.sql, q.params) as Array<Record<string, unknown>>
+      expect(JSON.parse(rows[0]!["allPicked"] as string)).toBe(true)
     }))
 
   it("namespace param is in correct position for SQLite positional placeholders", () =>
@@ -626,9 +1326,454 @@ describe("SQL Store (SQLite integration)", () => {
       const results = query(db, nsSql, params)
       // Should only get Alice and Bob (primary namespace), not Charlie (other namespace)
       expect(results.length).toBe(2)
-      const names = results.map((r) => (JSON.parse((r as any).data) as any).name).sort()
+      const names = results.map((r) => (JSON.parse(r.data) as any).name).sort()
       expect(names).toEqual(["Alice", "Bob"])
     }))
+
+  it("aggregate: agg-count-when with GROUP BY on aliased path field (SQLite)", () =>
+    withDb((db) => {
+      db.exec(`CREATE TABLE "test_agg" (id TEXT PRIMARY KEY, _etag TEXT, data JSON NOT NULL)`)
+      const rows = [
+        { city: "NYC", state: "active" },
+        { city: "NYC", state: "inactive" },
+        { city: "NYC", state: "active" },
+        { city: "LA", state: "active" }
+      ]
+      const insert = db.prepare(`INSERT INTO "test_agg" (id, _etag, data) VALUES (?, ?, ?)`)
+      rows.forEach((r, i) => insert.run(String(i + 1), `e${i + 1}`, JSON.stringify(r)))
+
+      const q = buildWhereSQLQuery(
+        sqliteDialect,
+        "id",
+        [],
+        "test_agg",
+        {},
+        [
+          { key: "city", path: "city" },
+          {
+            key: "activeCount",
+            aggregate: {
+              _tag: "agg-count-when",
+              filter: [{ t: "where", path: "state", op: "eq", value: "active" }]
+            }
+          },
+          { key: "total", aggregate: { _tag: "agg-count" } }
+        ] as any,
+        [{ key: "city", direction: "ASC" }] as any
+      )
+
+      expect(q.sql).toContain("GROUP BY")
+      expect(q.sql).toContain("COUNT(CASE WHEN")
+
+      const result = query(db, q.sql, q.params) as Array<Record<string, unknown>>
+      expect(result.length).toBe(2)
+
+      const la = result.find((r) => r["city"] === "LA")!
+      expect(la["activeCount"]).toBe(1)
+      expect(la["total"]).toBe(1)
+
+      const nyc = result.find((r) => r["city"] === "NYC")!
+      expect(nyc["activeCount"]).toBe(2)
+      expect(nyc["total"]).toBe(3)
+    }))
+
+  it("aggregate: agg-sum and agg-min / agg-max (SQLite)", () =>
+    withDb((db) => {
+      db.exec(`CREATE TABLE "test_agg2" (id TEXT PRIMARY KEY, _etag TEXT, data JSON NOT NULL)`)
+      const rows = [
+        { dept: "eng", salary: 100 },
+        { dept: "eng", salary: 200 },
+        { dept: "hr", salary: 50 }
+      ]
+      const insert = db.prepare(`INSERT INTO "test_agg2" (id, _etag, data) VALUES (?, ?, ?)`)
+      rows.forEach((r, i) => insert.run(String(i + 1), `e${i + 1}`, JSON.stringify(r)))
+
+      const q = buildWhereSQLQuery(
+        sqliteDialect,
+        "id",
+        [],
+        "test_agg2",
+        {},
+        [
+          { key: "dept", path: "dept" },
+          { key: "totalSalary", aggregate: { _tag: "agg-sum", field: "salary" } },
+          { key: "minSalary", aggregate: { _tag: "agg-min", field: "salary" } },
+          { key: "maxSalary", aggregate: { _tag: "agg-max", field: "salary" } }
+        ] as any,
+        [{ key: "dept", direction: "ASC" }] as any
+      )
+
+      const result = query(db, q.sql, q.params) as Array<Record<string, unknown>>
+      expect(result.length).toBe(2)
+
+      const eng = result.find((r) => r["dept"] === "eng")!
+      expect(eng["totalSalary"]).toBeCloseTo(300)
+      expect(eng["minSalary"]).toBeCloseTo(100)
+      expect(eng["maxSalary"]).toBeCloseTo(200)
+
+      const hr = result.find((r) => r["dept"] === "hr")!
+      expect(hr["totalSalary"]).toBeCloseTo(50)
+    }))
+
+  it("aggregate: nested path field grouping (SQLite)", () =>
+    withDb((db) => {
+      db.exec(`CREATE TABLE "test_agg3" (id TEXT PRIMARY KEY, _etag TEXT, data JSON NOT NULL)`)
+      const rows = [
+        { address: { city: "NYC" }, status: "open" },
+        { address: { city: "NYC" }, status: "closed" },
+        { address: { city: "LA" }, status: "open" }
+      ]
+      const insert = db.prepare(`INSERT INTO "test_agg3" (id, _etag, data) VALUES (?, ?, ?)`)
+      rows.forEach((r, i) => insert.run(String(i + 1), `e${i + 1}`, JSON.stringify(r)))
+
+      const q = buildWhereSQLQuery(
+        sqliteDialect,
+        "id",
+        [],
+        "test_agg3",
+        {},
+        [
+          { key: "city", path: "address.city" },
+          { key: "total", aggregate: { _tag: "agg-count" } }
+        ] as any,
+        [{ key: "city", direction: "ASC" }] as any
+      )
+
+      expect(q.sql).toContain("GROUP BY")
+
+      const result = query(db, q.sql, q.params) as Array<Record<string, unknown>>
+      expect(result.length).toBe(2)
+      const la = result.find((r) => r["city"] === "LA")!
+      expect(la["total"]).toBe(1)
+      const nyc = result.find((r) => r["city"] === "NYC")!
+      expect(nyc["total"]).toBe(2)
+    }))
+})
+
+// --- boolean WHERE clause tests (regression: where("x", true) must work per dialect) ---
+
+describe("boolean WHERE clauses — query builder", () => {
+  it("sqlite: eq true serializes bool → 1 integer", () => {
+    const result = buildWhereSQLQuery(
+      sqliteDialect,
+      "id",
+      [{ t: "where", path: "flag", op: "eq", value: true }],
+      "t",
+      {}
+    )
+    expect(result.sql).toContain("json_extract(data, '$.flag') = ?")
+    expect(result.params).toEqual([1])
+  })
+
+  it("sqlite: eq false serializes bool → 0 integer", () => {
+    const result = buildWhereSQLQuery(
+      sqliteDialect,
+      "id",
+      [{ t: "where", path: "flag", op: "eq", value: false }],
+      "t",
+      {}
+    )
+    expect(result.params).toEqual([0])
+  })
+
+  it("sqlite: neq/in also serialize booleans", () => {
+    const r1 = buildWhereSQLQuery(
+      sqliteDialect,
+      "id",
+      [{ t: "where", path: "flag", op: "neq", value: true }],
+      "t",
+      {}
+    )
+    expect(r1.params).toEqual([1])
+
+    const r2 = buildWhereSQLQuery(
+      sqliteDialect,
+      "id",
+      [{ t: "where", path: "flag", op: "in", value: [true, false] }],
+      "t",
+      {}
+    )
+    expect(r2.params).toEqual([1, 0])
+  })
+
+  it("pg: eq true serializes bool → 'true' text (matches ->> output)", () => {
+    const result = buildWhereSQLQuery(
+      pgDialect,
+      "id",
+      [{ t: "where", path: "flag", op: "eq", value: true }],
+      "t",
+      {}
+    )
+    expect(result.sql).toContain("data->>'flag' = $1")
+    expect(result.params).toEqual(["true"])
+  })
+
+  it("pg: eq false serializes bool → 'false' text", () => {
+    const result = buildWhereSQLQuery(
+      pgDialect,
+      "id",
+      [{ t: "where", path: "flag", op: "eq", value: false }],
+      "t",
+      {}
+    )
+    expect(result.params).toEqual(["false"])
+  })
+
+  it("pg: in with booleans serializes as text list", () => {
+    const result = buildWhereSQLQuery(
+      pgDialect,
+      "id",
+      [{ t: "where", path: "flag", op: "in", value: [true, false] }],
+      "t",
+      {}
+    )
+    expect(result.params).toEqual(["true", "false"])
+  })
+
+  it("non-boolean scalars pass through unchanged (sqlite)", () => {
+    const result = buildWhereSQLQuery(
+      sqliteDialect,
+      "id",
+      [{ t: "where", path: "name", op: "eq", value: "Alice" }],
+      "t",
+      {}
+    )
+    expect(result.params).toEqual(["Alice"])
+  })
+
+  it("non-boolean scalars pass through unchanged (pg)", () => {
+    const result = buildWhereSQLQuery(
+      pgDialect,
+      "id",
+      [{ t: "where", path: "age", op: "gt", value: 18 }],
+      "t",
+      {}
+    )
+    expect(result.params).toEqual([18])
+  })
+})
+
+describe("boolean WHERE clauses — SQLite integration (end-to-end)", () => {
+  const withDb = (fn: (db: Sqlite.Database) => void) => {
+    const db = new BetterSqlite(":memory:")
+    try {
+      fn(db)
+    } finally {
+      db.close()
+    }
+  }
+
+  it("where flag = true matches only true rows", () =>
+    withDb((db) => {
+      db.exec(`CREATE TABLE "t" (id TEXT PRIMARY KEY, _etag TEXT, data JSON NOT NULL)`)
+      db
+        .prepare(`INSERT INTO "t" (id, _etag, data) VALUES (?, ?, ?)`)
+        .run("1", "e", JSON.stringify({ flag: true, name: "Alice" }))
+      db
+        .prepare(`INSERT INTO "t" (id, _etag, data) VALUES (?, ?, ?)`)
+        .run("2", "e", JSON.stringify({ flag: false, name: "Bob" }))
+
+      const q = buildWhereSQLQuery(
+        sqliteDialect,
+        "id",
+        [{ t: "where", path: "flag", op: "eq", value: true }],
+        "t",
+        {}
+      )
+      const rows = query(db, q.sql, q.params)
+      expect(rows.length).toBe(1)
+      expect((JSON.parse(rows[0].data) as any).name).toBe("Alice")
+    }))
+
+  it("where flag = false matches only false rows", () =>
+    withDb((db) => {
+      db.exec(`CREATE TABLE "t" (id TEXT PRIMARY KEY, _etag TEXT, data JSON NOT NULL)`)
+      db
+        .prepare(`INSERT INTO "t" (id, _etag, data) VALUES (?, ?, ?)`)
+        .run("1", "e", JSON.stringify({ flag: true, name: "Alice" }))
+      db
+        .prepare(`INSERT INTO "t" (id, _etag, data) VALUES (?, ?, ?)`)
+        .run("2", "e", JSON.stringify({ flag: false, name: "Bob" }))
+
+      const q = buildWhereSQLQuery(
+        sqliteDialect,
+        "id",
+        [{ t: "where", path: "flag", op: "eq", value: false }],
+        "t",
+        {}
+      )
+      const rows = query(db, q.sql, q.params)
+      expect(rows.length).toBe(1)
+      expect((JSON.parse(rows[0].data) as any).name).toBe("Bob")
+    }))
+
+  it("where nested boolean path works", () =>
+    withDb((db) => {
+      db.exec(`CREATE TABLE "t" (id TEXT PRIMARY KEY, _etag TEXT, data JSON NOT NULL)`)
+      db
+        .prepare(`INSERT INTO "t" (id, _etag, data) VALUES (?, ?, ?)`)
+        .run("1", "e", JSON.stringify({ meta: { active: true }, name: "Alice" }))
+      db
+        .prepare(`INSERT INTO "t" (id, _etag, data) VALUES (?, ?, ?)`)
+        .run("2", "e", JSON.stringify({ meta: { active: false }, name: "Bob" }))
+
+      const q = buildWhereSQLQuery(
+        sqliteDialect,
+        "id",
+        [{ t: "where", path: "meta.active", op: "eq", value: true }],
+        "t",
+        {}
+      )
+      const rows = query(db, q.sql, q.params)
+      expect(rows.length).toBe(1)
+      expect((JSON.parse(rows[0].data) as any).name).toBe("Alice")
+    }))
+
+  it("where hasKey / hasValue / hasKeyValue match Map tuple JSON", () =>
+    withDb((db) => {
+      db.exec(`CREATE TABLE "t" (id TEXT PRIMARY KEY, _etag TEXT, data JSON NOT NULL)`)
+      db
+        .prepare(`INSERT INTO "t" (id, _etag, data) VALUES (?, ?, ?)`)
+        .run("1", "e", JSON.stringify({ meta: [["n", 1], ["x", 2]] }))
+      db
+        .prepare(`INSERT INTO "t" (id, _etag, data) VALUES (?, ?, ?)`)
+        .run("2", "e", JSON.stringify({ meta: [["n", 9]] }))
+
+      const byKey = buildWhereSQLQuery(
+        sqliteDialect,
+        "id",
+        [{ t: "where", path: "meta", op: "hasKey", value: "x" }],
+        "t",
+        {}
+      )
+      expect(query(db, byKey.sql, byKey.params).map((r) => r.id)).toEqual(["1"])
+
+      const byValue = buildWhereSQLQuery(
+        sqliteDialect,
+        "id",
+        [{ t: "where", path: "meta", op: "hasValue", value: 9 }],
+        "t",
+        {}
+      )
+      expect(query(db, byValue.sql, byValue.params).map((r) => r.id)).toEqual(["2"])
+
+      const byPair = buildWhereSQLQuery(
+        sqliteDialect,
+        "id",
+        [{ t: "where", path: "meta", op: "hasKeyValue", value: ["n", 1] }],
+        "t",
+        {}
+      )
+      expect(query(db, byPair.sql, byPair.params).map((r) => r.id)).toEqual(["1"])
+    }))
+
+  it("where neq boolean works", () =>
+    withDb((db) => {
+      db.exec(`CREATE TABLE "t" (id TEXT PRIMARY KEY, _etag TEXT, data JSON NOT NULL)`)
+      db
+        .prepare(`INSERT INTO "t" (id, _etag, data) VALUES (?, ?, ?)`)
+        .run("1", "e", JSON.stringify({ flag: true, name: "Alice" }))
+      db
+        .prepare(`INSERT INTO "t" (id, _etag, data) VALUES (?, ?, ?)`)
+        .run("2", "e", JSON.stringify({ flag: false, name: "Bob" }))
+
+      const q = buildWhereSQLQuery(
+        sqliteDialect,
+        "id",
+        [{ t: "where", path: "flag", op: "neq", value: true }],
+        "t",
+        {}
+      )
+      const rows = query(db, q.sql, q.params)
+      expect(rows.length).toBe(1)
+      expect((JSON.parse(rows[0].data) as any).name).toBe("Bob")
+    }))
+})
+
+// --- jsonExtractJson dialect tests (regression: booleans must survive round-trip) ---
+
+describe("sqliteDialect.jsonExtractJson boolean round-trip", () => {
+  const withDb = (fn: (db: Sqlite.Database) => void) => {
+    const db = new BetterSqlite(":memory:")
+    try {
+      fn(db)
+    } finally {
+      db.close()
+    }
+  }
+
+  it("SQL uses json_type CASE to preserve booleans", () => {
+    const sql = sqliteDialect.jsonExtractJson("flag")
+    expect(sql).toContain("json_type(data, '$.flag')")
+    expect(sql).toContain("'true'")
+    expect(sql).toContain("'false'")
+    expect(sql).toContain("json_quote(json_extract(data, '$.flag'))")
+  })
+
+  it("boolean false round-trips as false (not 0)", () =>
+    withDb((db) => {
+      db.exec(`CREATE TABLE "t" (data JSON NOT NULL)`)
+      db.prepare(`INSERT INTO "t" (data) VALUES (?)`).run(JSON.stringify({ flag: false }))
+
+      const row = db.prepare(`SELECT ${sqliteDialect.jsonExtractJson("flag")} AS v FROM "t"`).get() as any
+      const parsed = JSON.parse(row.v)
+      expect(parsed).toBe(false)
+      expect(typeof parsed).toBe("boolean")
+    }))
+
+  it("boolean true round-trips as true (not 1)", () =>
+    withDb((db) => {
+      db.exec(`CREATE TABLE "t" (data JSON NOT NULL)`)
+      db.prepare(`INSERT INTO "t" (data) VALUES (?)`).run(JSON.stringify({ flag: true }))
+
+      const row = db.prepare(`SELECT ${sqliteDialect.jsonExtractJson("flag")} AS v FROM "t"`).get() as any
+      const parsed = JSON.parse(row.v)
+      expect(parsed).toBe(true)
+      expect(typeof parsed).toBe("boolean")
+    }))
+
+  it("nested boolean round-trips correctly", () =>
+    withDb((db) => {
+      db.exec(`CREATE TABLE "t" (data JSON NOT NULL)`)
+      db.prepare(`INSERT INTO "t" (data) VALUES (?)`).run(
+        JSON.stringify({ nested: { flag: false } })
+      )
+
+      const row = db
+        .prepare(`SELECT ${sqliteDialect.jsonExtractJson("nested.flag")} AS v FROM "t"`)
+        .get() as any
+      const parsed = JSON.parse(row.v)
+      expect(parsed).toBe(false)
+      expect(typeof parsed).toBe("boolean")
+    }))
+
+  it("numbers 0 and 1 still parse as numbers (not booleans)", () =>
+    withDb((db) => {
+      db.exec(`CREATE TABLE "t" (data JSON NOT NULL)`)
+      db.prepare(`INSERT INTO "t" (data) VALUES (?)`).run(JSON.stringify({ zero: 0, one: 1 }))
+
+      const zRow = db.prepare(`SELECT ${sqliteDialect.jsonExtractJson("zero")} AS v FROM "t"`).get() as any
+      const oRow = db.prepare(`SELECT ${sqliteDialect.jsonExtractJson("one")} AS v FROM "t"`).get() as any
+      expect(JSON.parse(zRow.v)).toBe(0)
+      expect(typeof JSON.parse(zRow.v)).toBe("number")
+      expect(JSON.parse(oRow.v)).toBe(1)
+      expect(typeof JSON.parse(oRow.v)).toBe("number")
+    }))
+
+  it("strings, arrays, and null still round-trip correctly", () =>
+    withDb((db) => {
+      db.exec(`CREATE TABLE "t" (data JSON NOT NULL)`)
+      db.prepare(`INSERT INTO "t" (data) VALUES (?)`).run(
+        JSON.stringify({ s: "hello", arr: [1, 2, 3], nil: null })
+      )
+
+      const sRow = db.prepare(`SELECT ${sqliteDialect.jsonExtractJson("s")} AS v FROM "t"`).get() as any
+      const aRow = db.prepare(`SELECT ${sqliteDialect.jsonExtractJson("arr")} AS v FROM "t"`).get() as any
+      const nRow = db.prepare(`SELECT ${sqliteDialect.jsonExtractJson("nil")} AS v FROM "t"`).get() as any
+      expect(JSON.parse(sRow.v)).toBe("hello")
+      expect(JSON.parse(aRow.v)).toEqual([1, 2, 3])
+      expect(JSON.parse(nRow.v)).toBe(null)
+    }))
 })
 
 // --- toRow stripping and parseRow reconstruction tests ---
@@ -638,7 +1783,7 @@ describe("toRow strips _etag and id from data", () => {
   const toRow = <IdKey extends PropertyKey>(e: any, idKey: IdKey) => {
     const newE = makeETag(e)
     const id = newE[idKey] as string
-    const { _etag, [idKey]: _id, ...rest } = newE as any
+    const { _etag, [idKey]: _id, ...rest } = newE
     const data = JSON.stringify(rest)
     return { id, _etag: newE._etag!, data, item: newE }
   }
@@ -773,4 +1918,14 @@ describe("parseRow reconstructs full object from row", () => {
     expect(reconstructed.tags).toEqual(["admin"])
     expect(reconstructed._etag).toBe(newE._etag)
   })
+
+  it("lowers Date defaultValues to ISO before merge", () => {
+    const result: any = parseRow(
+      { id: "1", _etag: "e1", data: JSON.stringify({ name: "Alice" }) },
+      "id",
+      { at: new Date("2024-06-01T00:00:00.000Z") }
+    )
+    expect(result.at).toBe("2024-06-01T00:00:00.000Z")
+    expect(result.name).toBe("Alice")
+  })
 })