@effect-app/infra 4.0.0-beta.315 → 4.0.0-beta.317

package/test/sql-store.test.ts

@@ -24,11 +24,157 @@ 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("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 +186,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 +216,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 +229,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 +313,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",
       {}
     )
@@ -495,7 +641,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",
       {}
     )
@@ -787,7 +933,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,
@@ -798,13 +944,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",
         {}
       )
@@ -830,7 +976,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",
         {}
       )
@@ -846,8 +992,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(
@@ -863,7 +1009,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", () =>
@@ -896,13 +1042,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",
         {}
       )
@@ -927,20 +1073,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",
         {}
       )
@@ -966,7 +1112,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(
@@ -987,7 +1133,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"
@@ -1012,7 +1158,7 @@ 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", () =>
@@ -1154,7 +1300,7 @@ 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"])
     }))
 
@@ -1285,7 +1431,7 @@ describe("boolean WHERE clauses — query builder", () => {
     const result = buildWhereSQLQuery(
       sqliteDialect,
       "id",
-      [{ t: "where", path: "flag", op: "eq", value: true as any }],
+      [{ t: "where", path: "flag", op: "eq", value: true }],
       "t",
       {}
     )
@@ -1297,7 +1443,7 @@ describe("boolean WHERE clauses — query builder", () => {
     const result = buildWhereSQLQuery(
       sqliteDialect,
       "id",
-      [{ t: "where", path: "flag", op: "eq", value: false as any }],
+      [{ t: "where", path: "flag", op: "eq", value: false }],
       "t",
       {}
     )
@@ -1308,7 +1454,7 @@ describe("boolean WHERE clauses — query builder", () => {
     const r1 = buildWhereSQLQuery(
       sqliteDialect,
       "id",
-      [{ t: "where", path: "flag", op: "neq", value: true as any }],
+      [{ t: "where", path: "flag", op: "neq", value: true }],
       "t",
       {}
     )
@@ -1317,7 +1463,7 @@ describe("boolean WHERE clauses — query builder", () => {
     const r2 = buildWhereSQLQuery(
       sqliteDialect,
       "id",
-      [{ t: "where", path: "flag", op: "in", value: [true, false] as any }],
+      [{ t: "where", path: "flag", op: "in", value: [true, false] }],
       "t",
       {}
     )
@@ -1328,7 +1474,7 @@ describe("boolean WHERE clauses — query builder", () => {
     const result = buildWhereSQLQuery(
       pgDialect,
       "id",
-      [{ t: "where", path: "flag", op: "eq", value: true as any }],
+      [{ t: "where", path: "flag", op: "eq", value: true }],
       "t",
       {}
     )
@@ -1340,7 +1486,7 @@ describe("boolean WHERE clauses — query builder", () => {
     const result = buildWhereSQLQuery(
       pgDialect,
       "id",
-      [{ t: "where", path: "flag", op: "eq", value: false as any }],
+      [{ t: "where", path: "flag", op: "eq", value: false }],
       "t",
       {}
     )
@@ -1351,7 +1497,7 @@ describe("boolean WHERE clauses — query builder", () => {
     const result = buildWhereSQLQuery(
       pgDialect,
       "id",
-      [{ t: "where", path: "flag", op: "in", value: [true, false] as any }],
+      [{ t: "where", path: "flag", op: "in", value: [true, false] }],
       "t",
       {}
     )
@@ -1373,7 +1519,7 @@ describe("boolean WHERE clauses — query builder", () => {
     const result = buildWhereSQLQuery(
       pgDialect,
       "id",
-      [{ t: "where", path: "age", op: "gt", value: 18 as any }],
+      [{ t: "where", path: "age", op: "gt", value: 18 }],
       "t",
       {}
     )
@@ -1404,13 +1550,13 @@ describe("boolean WHERE clauses — SQLite integration (end-to-end)", () => {
       const q = buildWhereSQLQuery(
         sqliteDialect,
         "id",
-        [{ t: "where", path: "flag", op: "eq", value: true as any }],
+        [{ 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] as any).data) as any).name).toBe("Alice")
+      expect((JSON.parse(rows[0].data) as any).name).toBe("Alice")
     }))
 
   it("where flag = false matches only false rows", () =>
@@ -1426,13 +1572,13 @@ describe("boolean WHERE clauses — SQLite integration (end-to-end)", () => {
       const q = buildWhereSQLQuery(
         sqliteDialect,
         "id",
-        [{ t: "where", path: "flag", op: "eq", value: false as any }],
+        [{ 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] as any).data) as any).name).toBe("Bob")
+      expect((JSON.parse(rows[0].data) as any).name).toBe("Bob")
     }))
 
   it("where nested boolean path works", () =>
@@ -1448,13 +1594,51 @@ describe("boolean WHERE clauses — SQLite integration (end-to-end)", () => {
       const q = buildWhereSQLQuery(
         sqliteDialect,
         "id",
-        [{ t: "where", path: "meta.active", op: "eq", value: true as any }],
+        [{ 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] as any).data) as any).name).toBe("Alice")
+      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", () =>
@@ -1470,13 +1654,13 @@ describe("boolean WHERE clauses — SQLite integration (end-to-end)", () => {
       const q = buildWhereSQLQuery(
         sqliteDialect,
         "id",
-        [{ t: "where", path: "flag", op: "neq", value: true as any }],
+        [{ 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] as any).data) as any).name).toBe("Bob")
+      expect((JSON.parse(rows[0].data) as any).name).toBe("Bob")
     }))
 })
 
@@ -1573,7 +1757,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 }
   }
@@ -1708,4 +1892,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")
+  })
 })