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

package/test/cosmos-query.test.ts

@@ -13,6 +13,101 @@ type OrderEnc = S.Codec.Encoded<typeof Order>
 
 // Length projection via `relation(...).length()` should emit a scalar
 // ARRAY_LENGTH expression rather than pulling (or reshaping) the array.
+describe("cosmos query filter: native Encoded values", () => {
+  it("binds Date as ISO string parameters", () => {
+    const result = buildWhereCosmosQuery3(
+      "id",
+      [{ t: "where", path: "n", op: "eq", value: new Date("2024-01-01T00:00:00.000Z") }],
+      "Orders",
+      {}
+    )
+    expect(result.parameters).toEqual(
+      expect.arrayContaining([{ name: "@v0", value: "2024-01-01T00:00:00.000Z" }])
+    )
+  })
+
+  it("binds Map as array of tuples", () => {
+    const result = buildWhereCosmosQuery3(
+      "id",
+      [{ t: "where", path: "meta", op: "eq", value: new Map([["k", "v"]]) }],
+      "Orders",
+      {}
+    )
+    expect(result.parameters).toEqual(
+      expect.arrayContaining([{ name: "@v0", value: [["k", "v"]] }])
+    )
+  })
+
+  it("emits EXISTS over Map JSON tuples for hasKey / hasValue / hasKeyValue", () => {
+    const byKey = buildWhereCosmosQuery3(
+      "id",
+      [{ t: "where", path: "meta", op: "hasKey", value: "n" }],
+      "Orders",
+      {}
+    )
+    expect(byKey.query).toContain("EXISTS(SELECT VALUE p FROM p IN f[\"meta\"] WHERE p[0] = @v0)")
+    expect(byKey.parameters).toEqual(expect.arrayContaining([{ name: "@v0", value: "n" }]))
+
+    const byValue = buildWhereCosmosQuery3(
+      "id",
+      [{ t: "where", path: "meta", op: "hasValue", value: 1 }],
+      "Orders",
+      {}
+    )
+    expect(byValue.query).toContain("p[1] = @v0")
+
+    const byPair = buildWhereCosmosQuery3(
+      "id",
+      [{ t: "where", path: "meta", op: "hasKeyValue", value: ["n", 1] }],
+      "Orders",
+      {}
+    )
+    expect(byPair.query).toContain("ARRAY_CONTAINS")
+    expect(byPair.parameters).toEqual(expect.arrayContaining([{ name: "@v0", value: ["n", 1] }]))
+
+    const anyKey = buildWhereCosmosQuery3(
+      "id",
+      [{ t: "where", path: "meta", op: "hasKey-any", value: ["n", "x"] }],
+      "Orders",
+      {}
+    )
+    expect(anyKey.query).toContain("ARRAY_CONTAINS(@v0, p[0])")
+  })
+
+  it("binds includes Date as ISO string", () => {
+    const result = buildWhereCosmosQuery3(
+      "id",
+      [{ t: "where", path: "dates", op: "includes", value: new Date("2024-01-01T00:00:00.000Z") }],
+      "Orders",
+      {}
+    )
+    expect(result.query).toContain("ARRAY_CONTAINS")
+    expect(result.parameters).toEqual(
+      expect.arrayContaining([{ name: "@v0", value: "2024-01-01T00:00:00.000Z" }])
+    )
+  })
+
+  it("binds includes-any Date Set as ISO parameters", () => {
+    const result = buildWhereCosmosQuery3(
+      "id",
+      [{
+        t: "where",
+        path: "dates",
+        op: "includes-any",
+        value: new Set([new Date("2024-01-01T00:00:00.000Z")])
+      }],
+      "Orders",
+      {}
+    )
+    expect(result.parameters).toEqual(
+      expect.arrayContaining([
+        { name: "@v0", value: ["2024-01-01T00:00:00.000Z"] },
+        { name: "@v0__0", value: "2024-01-01T00:00:00.000Z" }
+      ])
+    )
+  })
+})
+
 describe("cosmos query projection: array length", () => {
   it("projects packages length via ARRAY_LENGTH", () => {
     const q = make<OrderEnc>().pipe(
@@ -29,13 +124,13 @@ describe("cosmos query projection: array length", () => {
       ir.filter ?? [],
       "Orders",
       {},
-      ir.select as any
+      ir.select
     )
 
     expect(result.query).toMatch(/ARRAY_LENGTH\(f(?:\.packages|\["packages"\])\)/)
     expect(result.query).toContain("AS packageCount")
     // Must not pull the full array nor reshape via subquery
-    expect(result.query).not.toMatch(/ARRAY\s*\(\s*SELECT[^)]*FROM\s+t\s+in\s+f[\.\["]/i)
+    expect(result.query).not.toMatch(/ARRAY\s*\(\s*SELECT[^)]*FROM\s+t\s+in\s+f[.["]/i)
     expect(result.query).not.toMatch(/SELECT VALUE COUNT/)
   })
 })
@@ -83,7 +178,7 @@ describe("cosmos query projection: union array fields", () => {
     const packageSelects = select.filter((item) =>
       typeof item === "object" && item !== null && "key" in item && item.key === "packages"
     )
-    const result = buildWhereCosmosQuery3("id", ir.filter ?? [], "Orders", {}, ir.select as any)
+    const result = buildWhereCosmosQuery3("id", ir.filter ?? [], "Orders", {}, ir.select)
 
     expect(packageSelects).toHaveLength(1)
     expect(result.query.match(/\bAS\s+packages\b/g) ?? []).toHaveLength(1)
@@ -102,7 +197,7 @@ describe("cosmos query projection: union array fields", () => {
     const packageSelects = select.filter((item) =>
       typeof item === "object" && item !== null && "key" in item && item.key === "packages"
     )
-    const result = buildWhereCosmosQuery3("id", ir.filter ?? [], "Orders", {}, ir.select as any)
+    const result = buildWhereCosmosQuery3("id", ir.filter ?? [], "Orders", {}, ir.select)
 
     expect(packageSelects).toHaveLength(1)
     expect(result.query.match(/\bAS\s+packages\b/g) ?? []).toHaveLength(1)
@@ -146,7 +241,7 @@ describe("cosmos query projection: relation-every parameter binding", () => {
     )
 
     const ir = toFilter(q as any, DN as any)
-    const result = buildWhereCosmosQuery3("id", ir.filter ?? [], "DN", {}, ir.select as any)
+    const result = buildWhereCosmosQuery3("id", ir.filter ?? [], "DN", {}, ir.select)
 
     // Each filter element binds exactly one parameter: 2 every filters + 2 main filter = 4.
     expect(result.parameters).toHaveLength(4)

package/test/dist/json-lower.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-lower.test.d.ts","sourceRoot":"","sources":["../json-lower.test.ts"],"names":[],"mappings":""}

package/test/dist/query.test.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"query.test.d.ts","sourceRoot":"","sources":["../query.test.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,CAAC,MAAM,mBAAmB,CAAA;;;;;;;;;;;;;;;;;AAgBtC,qBAAa,SAAU,SAAQ,cAM7B;CAAG;AACL,MAAM,CAAC,OAAO,WAAW,SAAS,CAAC;IAEjC,UAAiB,OAAQ,SAAQ,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,SAAS,CAAC;KAAG;CACtE"}
+{"version":3,"file":"query.test.d.ts","sourceRoot":"","sources":["../query.test.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,CAAC,MAAM,mBAAmB,CAAA;;;;;;;;;;;;;;;;;AAsBtC,qBAAa,SAAU,SAAQ,cAM7B;CAAG;AACL,MAAM,CAAC,OAAO,WAAW,SAAS,CAAC;IAEjC,UAAiB,OAAQ,SAAQ,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,SAAS,CAAC;KAAG;CACtE"}

package/test/json-lower.test.ts

@@ -0,0 +1,115 @@
+import type { Ops } from "effect-app/Model/filter/filterApi"
+import * as S from "effect-app/Schema"
+import * as Getter from "effect/SchemaGetter"
+import { describe, expect, it } from "vitest"
+import { jsonifyFilter } from "../src/Store/utils.js"
+
+class Day {
+  readonly ymd: string
+  constructor(ymd: string) {
+    this.ymd = ymd
+  }
+}
+
+const DayFromSelf = S.declare((u): u is Day => u instanceof Day, {
+  expected: "Day",
+  toCodecJson: () =>
+    S.link<Day>()(
+      S.String,
+      {
+        decode: Getter.transform((s: string) => new Day(s)),
+        encode: Getter.transform((d: Day) => d.ymd)
+      }
+    )
+})
+
+const where = (path: string, op: Ops, value: unknown) => ({
+  t: "where" as const,
+  path,
+  op,
+  value
+})
+
+describe("jsonifyFilter Encoded key paths", () => {
+  it("lowers encodeKeys-renamed native Encoded values via the Encoded field name", () => {
+    const schema = S
+      .Struct({
+        id: S.String,
+        day: DayFromSelf
+      })
+      .pipe(S.encodeKeys({ day: "the_day" }))
+    const day = new Day("2024-06-01")
+    expect(jsonifyFilter([where("the_day", "eq", day)], schema)).toEqual([
+      where("the_day", "eq", "2024-06-01")
+    ])
+  })
+
+  it("lowers Class.pipe(encodeKeys) using Encoded names, not Type .fields", () => {
+    class Doc extends S.Class<Doc>("JsonLowerEncodeKeysDoc")({
+      id: S.String,
+      day: DayFromSelf,
+      tags: S.NonEmptyArray(S.String)
+    }) {}
+    const schema = Doc.pipe(S.encodeKeys({ day: "the_day" }))
+    const day = new Day("2024-06-01")
+    expect(jsonifyFilter([where("the_day", "eq", day)], schema)).toEqual([
+      where("the_day", "eq", "2024-06-01")
+    ])
+    expect(jsonifyFilter([where("id", "in", ["d1"])], schema)).toEqual([
+      where("id", "in", ["d1"])
+    ])
+    expect(jsonifyFilter([where("tags", "includes-any", ["a"])], schema)).toEqual([
+      where("tags", "includes-any", ["a"])
+    ])
+  })
+
+  it("does not encode scalar `in` values through an array field renamed onto Encoded `id`", () => {
+    class Doc extends S.Class<Doc>("JsonLowerSwappedKeysDoc")({
+      id: S.String,
+      items: S.NonEmptyArray(S.String)
+    }) {}
+    const schema = Doc.pipe(S.encodeKeys({ items: "id", id: "item_id" }))
+    expect(jsonifyFilter([where("item_id", "in", ["d1"])], schema)).toEqual([
+      where("item_id", "in", ["d1"])
+    ])
+    expect(jsonifyFilter([where("id", "includes-any", ["a"])], schema)).toEqual([
+      where("id", "includes-any", ["a"])
+    ])
+  })
+
+  it("lowers TaggedUnion Opaque `id in`", () => {
+    const identity = S.Struct({ id: S.String, layout: S.String })
+    class Available extends S.Opaque<Available>()(S.TaggedStruct("available", { ...identity.fields })) {}
+    class Reserved extends S.Opaque<Reserved>()(
+      S.TaggedStruct("reserved", { ...identity.fields, reservation: S.String })
+    ) {}
+    const Cart = S.TaggedUnion([Available, Reserved])
+    expect(jsonifyFilter([where("id", "in", ["cart-1"])], Cart)).toEqual([
+      where("id", "in", ["cart-1"])
+    ])
+  })
+
+  it("lowers TaggedClass union array includes-any through the element schema", () => {
+    class Picking extends S.TaggedClass<Picking>()("picking", {
+      id: S.String,
+      cartIds: S.NonEmptyArray(S.String),
+      createdAt: S.Date
+    }) {}
+    class Assembling extends S.TaggedClass<Assembling>()("assembling", {
+      id: S.String,
+      cartIds: S.NonEmptyArray(S.String),
+      createdAt: S.Date
+    }) {}
+    const Batch = S.TaggedUnion([Picking, Assembling])
+    const at = new Date("2024-06-01T00:00:00.000Z")
+    expect(jsonifyFilter([where("id", "in", ["batch-1"])], Batch)).toEqual([
+      where("id", "in", ["batch-1"])
+    ])
+    expect(jsonifyFilter([where("cartIds", "includes-any", ["cart-1"])], Batch)).toEqual([
+      where("cartIds", "includes-any", ["cart-1"])
+    ])
+    expect(jsonifyFilter([where("createdAt", "eq", at)], Batch)).toEqual([
+      where("createdAt", "eq", at.toISOString())
+    ])
+  })
+})

package/test/query.test.ts

@@ -11,10 +11,16 @@ import * as Option from "effect-app/Option"
 import * as S from "effect-app/Schema"
 import { setupRequestContextFromCurrent } from "effect-app/setupRequest"
 import { flow, pipe } from "effect/Function"
+import * as Redacted from "effect/Redacted"
+import * as Getter from "effect/SchemaGetter"
 import * as SchemaTransformation from "effect/SchemaTransformation"
 import * as Struct from "effect/Struct"
+import * as fs from "fs"
+import * as os from "os"
+import * as path from "path"
 import { inspect } from "util"
 import { expect, expectTypeOf, it } from "vitest"
+import { DiskStoreLayer } from "../src/Store/Disk.js"
 import { memFilter, MemoryStoreLive } from "../src/Store/Memory.js"
 import { SomeService } from "./fixtures.js"
 
@@ -41,7 +47,7 @@ const q = make<Something.Encoded>()
     where("displayName", "Verona"),
     or(
       where("displayName", "Riley"),
-      and("n", "gt", "2021-01-01T00:00:00Z") // TODO: work with To type translation, so Date?
+      and("n", "gt", new Date("2021-01-01T00:00:00Z"))
     ),
     order("displayName"),
     page({ take: 10 }),
@@ -141,7 +147,7 @@ it("works with repo", () =>
           where("displayName", "Verona"),
           or(
             where("displayName", "Riley"),
-            and("n", "gt", "2021-01-01T00:00:00Z") // TODO: work with To type translation, so Date?
+            and("n", "gt", new Date("2021-01-01T00:00:00Z"))
           ),
           order("displayName"),
           page({ take: 10 }),
@@ -168,6 +174,11 @@ it("works with repo", () =>
 
       expect(q1).toEqual(items.slice(0, 2).toReversed().map(Struct.pick(["id", "displayName"])))
       expect(q2).toEqual(items.slice(0, 2).toReversed().map(Struct.pick(["displayName"])))
+
+      const byDate = yield* somethingRepo.query(
+        where("n", new Date("2020-01-01T00:00:00.000Z"))
+      )
+      expect(byDate.map((_) => _.displayName)).toEqual(["Verona", "Riley"])
     })
     .pipe(
       Effect.provide(Layer.mergeAll(SomethingRepo.Test, SomeService.Default)),
@@ -176,6 +187,150 @@ it("works with repo", () =>
       Effect.runPromise
     ))
 
+it("memory store round-trips Date/Set/Map via JSON codecs", () =>
+  Effect
+    .gen(function*() {
+      class Doc extends S.Class<Doc>("JsonCodecDoc")({
+        id: S.String,
+        at: S.Date,
+        tags: S.ReadonlySet(S.String),
+        meta: S.ReadonlyMap({ key: S.String, value: S.Finite })
+      }) {}
+      const at = new Date("2024-06-01T00:00:00.000Z")
+      const saved = new Doc({
+        id: "d1",
+        at,
+        tags: new Set(["a", "b"]),
+        meta: new Map([["n", 1]])
+      })
+      const repo = yield* makeRepo("JsonCodecDoc", Doc, { makeInitial: Effect.succeed([saved]) })
+      const found = yield* repo.find("d1")
+      expect(Option.isSome(found)).toBe(true)
+      if (Option.isSome(found)) {
+        expect(found.value.at.toISOString()).toBe(at.toISOString())
+        expect(found.value.tags).toEqual(new Set(["a", "b"]))
+        expect(found.value.meta).toEqual(new Map([["n", 1]]))
+      }
+      const byDate = yield* repo.query(where("at", at))
+      expect(byDate.map((_) => _.id)).toEqual(["d1"])
+      const byTag = yield* repo.query(where("tags", "includes", "b"))
+      expect(byTag.map((_) => _.id)).toEqual(["d1"])
+      const byKey = yield* repo.query(where("meta", "hasKey", "n"))
+      expect(byKey.map((_) => _.id)).toEqual(["d1"])
+      const byPair = yield* repo.query(where("meta", "hasKeyValue", ["n", 1]))
+      expect(byPair.map((_) => _.id)).toEqual(["d1"])
+    })
+    .pipe(Effect.provide(TestStoreLive), setupRequestContextFromCurrent(), Effect.scoped, Effect.runPromise))
+
+class Day {
+  readonly ymd: string
+  constructor(ymd: string) {
+    this.ymd = ymd
+  }
+}
+
+const DayFromSelf = S.declare((u): u is Day => u instanceof Day, {
+  expected: "Day",
+  toCodecJson: () =>
+    S.link<Day>()(
+      S.String,
+      {
+        decode: Getter.transform((s: string) => new Day(s)),
+        encode: Getter.transform((d: Day) => d.ymd)
+      }
+    )
+})
+
+it("memory store round-trips app native Encoded values via the document schema", () =>
+  Effect
+    .gen(function*() {
+      class Doc extends S.Class<Doc>("JsonCodecDayDoc")({
+        id: S.String,
+        day: DayFromSelf
+      }) {}
+      const day = new Day("2024-06-01")
+      const saved = new Doc({ id: "d1", day })
+      const repo = yield* makeRepo("JsonCodecDayDoc", Doc, { makeInitial: Effect.succeed([saved]) })
+      const found = yield* repo.find("d1")
+      expect(Option.isSome(found)).toBe(true)
+      if (Option.isSome(found)) {
+        expect(found.value.day).toBeInstanceOf(Day)
+        expect(found.value.day.ymd).toBe("2024-06-01")
+      }
+      expect(S.encodeSync(DayFromSelf)(day)).toBe(day)
+      expect(S.encodeSync(S.toCodecJson(DayFromSelf))(day)).toBe("2024-06-01")
+      const byDay = yield* repo.query(where("day", day))
+      expect(byDay.map((_) => _.id)).toEqual(["d1"])
+    })
+    .pipe(Effect.provide(TestStoreLive), setupRequestContextFromCurrent(), Effect.scoped, Effect.runPromise))
+
+it("memory store queries encodeKeys-renamed native Encoded fields", () =>
+  Effect
+    .gen(function*() {
+      class Doc extends S.Class<Doc>("JsonCodecEncodeKeysDayDoc")({
+        id: S.String,
+        day: DayFromSelf
+      }) {}
+      const schema = Doc.pipe(S.encodeKeys({ day: "the_day" }))
+      const day = new Day("2024-06-01")
+      const saved = new Doc({ id: "d1", day })
+      const repo = yield* makeRepo("JsonCodecEncodeKeysDayDoc", schema, { makeInitial: Effect.succeed([saved]) })
+      const byDay = yield* repo.query(where("the_day", day))
+      expect(byDay.map((_) => _.id)).toEqual(["d1"])
+      const byId = yield* repo.query(where("id", "in", ["d1"]))
+      expect(byId.map((_) => _.id)).toEqual(["d1"])
+    })
+    .pipe(Effect.provide(TestStoreLive), setupRequestContextFromCurrent(), Effect.scoped, Effect.runPromise))
+
+it("disk store round-trips Date/Set/Map via JSON codecs", () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "effect-app-disk-json-"))
+  const diskLive = Layer.merge(
+    DiskStoreLayer({ url: Redacted.make(`disk://${dir}`), prefix: "", dbName: "test" }, dir),
+    RepositoryRegistryLive
+  )
+  return Effect
+    .gen(function*() {
+      class Doc extends S.Class<Doc>("JsonCodecDiskDoc")({
+        id: S.String,
+        at: S.Date,
+        tags: S.ReadonlySet(S.String),
+        meta: S.ReadonlyMap({ key: S.String, value: S.Finite })
+      }) {}
+      const at = new Date("2024-06-01T00:00:00.000Z")
+      const saved = new Doc({
+        id: "d1",
+        at,
+        tags: new Set(["a", "b"]),
+        meta: new Map([["n", 1]])
+      })
+      const repo = yield* makeRepo("JsonCodecDiskDoc", Doc, { makeInitial: Effect.succeed([saved]) })
+      const found = yield* repo.find("d1")
+      expect(Option.isSome(found)).toBe(true)
+      if (Option.isSome(found)) {
+        expect(found.value.at.toISOString()).toBe(at.toISOString())
+        expect(found.value.tags).toEqual(new Set(["a", "b"]))
+        expect(found.value.meta).toEqual(new Map([["n", 1]]))
+      }
+      const jsonFile = fs.readdirSync(dir).find((f) => f.endsWith(".json"))
+      expect(jsonFile).toBeDefined()
+      const raw = JSON.parse(fs.readFileSync(path.join(dir, jsonFile!), "utf8")) as Array<{
+        at: unknown
+        tags: unknown
+        meta: unknown
+      }>
+      expect(raw[0]?.at).toBe(at.toISOString())
+      expect(raw[0]?.tags).toEqual(["a", "b"])
+      expect(raw[0]?.meta).toEqual([["n", 1]])
+    })
+    .pipe(
+      Effect.provide(diskLive),
+      setupRequestContextFromCurrent(),
+      Effect.scoped,
+      Effect.runPromise
+    )
+    .finally(() => fs.rmSync(dir, { recursive: true, force: true }))
+})
+
 it("collect", () =>
   Effect
     .gen(function*() {
@@ -196,8 +351,8 @@ it("collect", () =>
                 })),
                 S.toType(S.Option(S.String)),
                 (_) =>
-                  _.displayName === "Riley" && _.n === "2020-01-01T00:00:00.000Z"
-                    ? Option.some(`${_.displayName}-${_.n}`)
+                  _.displayName === "Riley" && _.n.toISOString() === "2020-01-01T00:00:00.000Z"
+                    ? Option.some(`${_.displayName}-${_.n.toISOString()}`)
                     : Option.none()
               ),
               "collect"
@@ -215,7 +370,7 @@ it("collect", () =>
         QueryEnd<{
           readonly id: string
           readonly displayName: string
-          readonly n: string
+          readonly n: Date
           readonly union: {
             readonly _tag: "string"
             readonly value: string
@@ -530,7 +685,7 @@ it(
         const schema = S.Struct({
           id: S.String,
           createdAt: S.Date.pipe(
-            S.withDecodingDefault(Effect.sync(() => new Date().toISOString())),
+            S.withDecodingDefault(Effect.sync(() => new Date())),
             S.withConstructorDefault(Effect.sync(() => new Date()))
           )
         })
@@ -543,7 +698,7 @@ it(
         const outputSchema = S.Struct({
           id: S.Literal("123"),
           createdAt: S.Date.pipe(
-            S.withDecodingDefault(Effect.sync(() => new Date().toISOString())),
+            S.withDecodingDefault(Effect.sync(() => new Date())),
             S.withConstructorDefault(Effect.sync(() => new Date()))
           )
         })
@@ -824,7 +979,7 @@ it("ProjectableFromDomain distributes over tagged union Encoded", () => {
   type GoodCheck = ProjectableFromDomain<Good, DomainEnc, "n">
   type BadCheck = ProjectableFromDomain<Bad, DomainEnc>
 
-  const _good: GoodCheck = undefined as unknown
+  const _good: GoodCheck = undefined
   // @ts-expect-error cancelled branch requires activeRequest not present on domain cancelled
   const _bad: BadCheck = undefined as unknown
   void _good
@@ -852,7 +1007,7 @@ it("ProjectableFromDomain allows dual same-tag domain variants", () => {
   type GoodCheck = ProjectableFromDomain<Good, DomainEnc>
   type BadFlatCheck = ProjectableFromDomain<BadFlat, DomainEnc>
 
-  const _good: GoodCheck = undefined as unknown
+  const _good: GoodCheck = undefined
   // @ts-expect-error packages is not on domain initial; multi-tag flat intersection rejects it
   const _badFlat: BadFlatCheck = undefined as unknown
   void _good
@@ -1345,6 +1500,49 @@ it("does not allow string queries on arrays", () =>
       expectTypeOf(good2).toEqualTypeOf<QueryWhere<Some, Some>>()
       expectTypeOf(good3).toEqualTypeOf<QueryWhere<Some, Some>>()
       expectTypeOf(good4).toEqualTypeOf<QueryWhere<Some, Some>>()
+
+      type Native = {
+        readonly id: string
+        readonly dates: Date[]
+        readonly dateSet: ReadonlySet<Date>
+        readonly tags: ReadonlySet<string>
+      }
+      const native = make<Native>()
+      const d = new Date("2020-01-01T00:00:00.000Z")
+      const n1 = native.pipe(where("dates", "includes", d))
+      const n2 = native.pipe(where("dateSet", "includes", d))
+      const n3 = native.pipe(where("tags", "includes", "a"))
+      const n4 = native.pipe(where("dates", "includes-any", [d]))
+      const n5 = native.pipe(where("dateSet", "includes-any", new Set([d])))
+      const n6 = native.pipe(where("id", "in", new Set(["x"])))
+      expectTypeOf(n1).toEqualTypeOf<QueryWhere<Native, Native>>()
+      expectTypeOf(n2).toEqualTypeOf<QueryWhere<Native, Native>>()
+      expectTypeOf(n3).toEqualTypeOf<QueryWhere<Native, Native>>()
+      expectTypeOf(n4).toEqualTypeOf<QueryWhere<Native, Native>>()
+      expectTypeOf(n5).toEqualTypeOf<QueryWhere<Native, Native>>()
+      expectTypeOf(n6).toEqualTypeOf<QueryWhere<Native, Native>>()
+
+      type WithMap = {
+        readonly id: string
+        readonly meta: ReadonlyMap<string, number>
+      }
+      const mapped = make<WithMap>()
+      const m1 = mapped.pipe(where("meta", "hasKey", "n"))
+      const m2 = mapped.pipe(where("meta", "hasValue", 1))
+      const m3 = mapped.pipe(where("meta", "hasKeyValue", ["n", 1] as const))
+      const m4 = mapped.pipe(where("meta", "hasKey-any", ["n", "x"]))
+      const m5 = mapped.pipe(where("meta", "hasValue-all", new Set([1, 2])))
+      const m6 = mapped.pipe(where("meta", "hasKeyValue-any", [["n", 1] as const, ["x", 2] as const]))
+      expectTypeOf(m1).toEqualTypeOf<QueryWhere<WithMap, WithMap>>()
+      expectTypeOf(m2).toEqualTypeOf<QueryWhere<WithMap, WithMap>>()
+      expectTypeOf(m3).toEqualTypeOf<QueryWhere<WithMap, WithMap>>()
+      expectTypeOf(m4).toEqualTypeOf<QueryWhere<WithMap, WithMap>>()
+      expectTypeOf(m5).toEqualTypeOf<QueryWhere<WithMap, WithMap>>()
+      expectTypeOf(m6).toEqualTypeOf<QueryWhere<WithMap, WithMap>>()
+      // @ts-expect-error cannot hasKey on a string field
+      mapped.pipe(where("id", "hasKey", "n"))
+      // @ts-expect-error hasKey value must be the map key type
+      mapped.pipe(where("meta", "hasKey", 1))
     })
     .pipe(Effect.provide(TestStoreLive), setupRequestContextFromCurrent(), Effect.scoped, Effect.runPromise))
 
@@ -2064,6 +2262,57 @@ it("codeFilter: array includes / includes-any / includes-all", () => {
   expect(runCF(make<CFRow>().pipe(where("tags", "includes-all", ["red", "blue"])))).toEqual(["3"])
 })
 
+it("codeFilter: Date array / Set includes and in", () => {
+  const d0 = new Date("2020-01-01T00:00:00.000Z")
+  const d1 = new Date("2021-01-01T00:00:00.000Z")
+  type DateRow = {
+    readonly id: string
+    readonly dates: Date[]
+    readonly dateSet: ReadonlySet<Date>
+    readonly tag: string
+  }
+  const rows: DateRow[] = [
+    { id: "1", dates: [d0], dateSet: new Set([d0]), tag: "a" },
+    { id: "2", dates: [d1, d0], dateSet: new Set([d1]), tag: "b" }
+  ]
+  const run = (q: any) => (memFilter(toFilter(q))(rows) as DateRow[]).map((_) => _.id)
+  expect(run(make<DateRow>().pipe(where("dates", "includes", d0))).sort()).toEqual(["1", "2"])
+  expect(run(make<DateRow>().pipe(where("dates", "includes", d1)))).toEqual(["2"])
+  expect(run(make<DateRow>().pipe(where("dateSet", "includes", d0)))).toEqual(["1"])
+  expect(run(make<DateRow>().pipe(where("dates", "includes-any", [d1])))).toEqual(["2"])
+  expect(run(make<DateRow>().pipe(where("dateSet", "includes-any", new Set([d0, d1])))).sort()).toEqual([
+    "1",
+    "2"
+  ])
+  expect(run(make<DateRow>().pipe(where("tag", "in", new Set(["a"]))))).toEqual(["1"])
+})
+
+it("codeFilter: Map hasKey / hasValue / hasKeyValue", () => {
+  type MapRow = {
+    readonly id: string
+    readonly meta: ReadonlyMap<string, number>
+  }
+  const rows: MapRow[] = [
+    { id: "1", meta: new Map([["n", 1], ["x", 2]]) },
+    { id: "2", meta: new Map([["n", 9]]) },
+    { id: "3", meta: new Map([["z", 2]]) }
+  ]
+  const run = (q: any) => (memFilter(toFilter(q))(rows) as MapRow[]).map((_) => _.id)
+  expect(run(make<MapRow>().pipe(where("meta", "hasKey", "n"))).sort()).toEqual(["1", "2"])
+  expect(run(make<MapRow>().pipe(where("meta", "notHasKey", "n")))).toEqual(["3"])
+  expect(run(make<MapRow>().pipe(where("meta", "hasValue", 2))).sort()).toEqual(["1", "3"])
+  expect(run(make<MapRow>().pipe(where("meta", "notHasValue", 2)))).toEqual(["2"])
+  expect(run(make<MapRow>().pipe(where("meta", "hasKeyValue", ["n", 1])))).toEqual(["1"])
+  expect(run(make<MapRow>().pipe(where("meta", "notHasKeyValue", ["n", 1]))).sort()).toEqual(["2", "3"])
+  expect(run(make<MapRow>().pipe(where("meta", "hasKey-any", ["z", "missing"])))).toEqual(["3"])
+  expect(run(make<MapRow>().pipe(where("meta", "hasKey-all", ["n", "x"])))).toEqual(["1"])
+  expect(run(make<MapRow>().pipe(where("meta", "notHasKey-all", ["n", "x"]))).sort()).toEqual(["2", "3"])
+  expect(run(make<MapRow>().pipe(where("meta", "hasValue-any", [9, 99])))).toEqual(["2"])
+  expect(run(make<MapRow>().pipe(where("meta", "hasValue-all", [1, 2])))).toEqual(["1"])
+  expect(run(make<MapRow>().pipe(where("meta", "hasKeyValue-any", [["n", 9], ["missing", 0]])))).toEqual(["2"])
+  expect(run(make<MapRow>().pipe(where("meta", "hasKeyValue-all", [["n", 1], ["x", 2]])))).toEqual(["1"])
+})
+
 it("codeFilter: in / notIn", () => {
   expect(runCF(make<CFRow>().pipe(where("tag", "in", ["x", "z"]))).sort()).toEqual(["1", "3"])
   expect(runCF(make<CFRow>().pipe(where("tag", "notIn", ["x", "z"]))).sort()).toEqual(["2", "4"])
@@ -2129,7 +2378,7 @@ it("memFilter: agg-count-when groups rows and counts conditionally", () => {
       },
       { key: "total", aggregate: { _tag: "agg-count" } }
     ] as any
-  })(rows as any) as any[]
+  })(rows) as any[]
 
   expect(result.length).toBe(2)
   const nyc = result.find((r: any) => r.city === "NYC")!
@@ -2155,7 +2404,7 @@ it("memFilter: agg-sum / agg-min / agg-max aggregate numerics", () => {
       { key: "min", aggregate: { _tag: "agg-min", field: "salary" } },
       { key: "max", aggregate: { _tag: "agg-max", field: "salary" } }
     ] as any
-  })(rows as any) as any[]
+  })(rows) as any[]
 
   expect(result.length).toBe(2)
   const eng = result.find((r: any) => r.dept === "eng")!
@@ -2179,7 +2428,7 @@ it("memFilter: aggregate with nested path grouping", () => {
       { key: "city", path: "address.city" },
       { key: "count", aggregate: { _tag: "agg-count" } }
     ] as any
-  })(rows as any) as any[]
+  })(rows) as any[]
 
   expect(result.length).toBe(2)
   expect(result.find((r: any) => r.city === "NYC")!.count).toBe(2)