@effect-app/infra 4.0.0-beta.3 → 4.0.0-beta.300

package/test/query.test.ts

@@ -1,25 +1,35 @@
 /* eslint-disable unused-imports/no-unused-vars */
 /* eslint-disable @typescript-eslint/no-empty-object-type */
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { Effect, flow, Layer, Option, pipe, S, ServiceMap, Struct } from "effect-app"
+import * as Context from "effect-app/Context"
+import * as Effect from "effect-app/Effect"
+import * as Layer from "effect-app/Layer"
+import { and, computed, count, expr, make, one, or, order, page, project, projectComputed, type QueryEnd, type QueryProjection, type QueryWhere, relation, toFilter, where } from "effect-app/Model/query"
+import { makeRepo } from "effect-app/Model/Repository"
+import { RepositoryRegistryLive } from "effect-app/Model/Repository/Registry"
+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 SchemaTransformation from "effect/SchemaTransformation"
+import * as Struct from "effect/Struct"
 import { inspect } from "util"
 import { expect, expectTypeOf, it } from "vitest"
-import { setupRequestContextFromCurrent } from "../src/api/setupRequest.js"
-import { and, count, make, one, or, order, page, project, type QueryEnd, type QueryProjection, type QueryWhere, toFilter, where } from "../src/Model/query.js"
-import { makeRepo } from "../src/Model/Repository.js"
 import { memFilter, MemoryStoreLive } from "../src/Store/Memory.js"
 import { SomeService } from "./fixtures.js"
 
+const TestStoreLive = Layer.merge(MemoryStoreLive, RepositoryRegistryLive)
+
 const str = S.Struct({ _tag: S.Literal("string"), value: S.String })
-const num = S.Struct({ _tag: S.Literal("number"), value: S.Number })
+const num = S.Struct({ _tag: S.Literal("number"), value: S.Finite })
 const someUnion = S.Union([str, num])
 
 export class Something extends S.Class<Something>("Something")({
-  id: S.StringId.withDefault,
+  id: S.StringId.withConstructorDefault,
   displayName: S.NonEmptyString255,
-  name: S.NullOr(S.NonEmptyString255).withDefault,
-  n: S.Date.withDefault,
-  union: someUnion.pipe(S.withDefaultConstructor(() => ({ _tag: "string" as const, value: "hi" })))
+  name: S.NullOr(S.NonEmptyString255).withConstructorDefault,
+  n: S.Date.withConstructorDefault,
+  union: someUnion.pipe(S.withConstructorDefault(Effect.succeed({ _tag: "string" as const, value: "hi" })))
 }) {}
 export declare namespace Something {
   // eslint-disable-next-line @typescript-eslint/no-empty-object-type
@@ -90,8 +100,8 @@ it("works", () => {
 
   const processed = memFilter(interpreted)(items.map((_) =>
     S.encodeUnknownSync(S.Struct({
-      ...Something.omit("displayName"),
-      displayName: S.Literal("Verona", "Riley")
+      ...Struct.omit(Something.fields, ["displayName"]),
+      displayName: S.Literals(["Verona", "Riley"])
     }))(_)
   ))
 
@@ -99,7 +109,7 @@ it("works", () => {
 })
 
 // @effect-diagnostics-next-line missingEffectServiceDependency:off
-class SomethingRepo extends ServiceMap.Service<SomethingRepo>()("SomethingRepo", {
+class SomethingRepo extends Context.Service<SomethingRepo>()("SomethingRepo", {
   make: Effect.gen(function*() {
     return yield* makeRepo("Something", Something, {})
   })
@@ -112,7 +122,7 @@ class SomethingRepo extends ServiceMap.Service<SomethingRepo>()("SomethingRepo",
       })
     )
     .pipe(
-      Layer.provide(MemoryStoreLive)
+      Layer.provide(TestStoreLive)
     )
 }
 
@@ -156,14 +166,13 @@ it("works with repo", () =>
 
       expectTypeOf(smtArr).toEqualTypeOf<readonly Something[]>()
 
-      console.log(" $$$$$$")
-      console.log(Struct.pick(["id", "displayName"]))
       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"])))
     })
     .pipe(
       Effect.provide(Layer.mergeAll(SomethingRepo.Test, SomeService.Default)),
       setupRequestContextFromCurrent(),
+      Effect.scoped,
       Effect.runPromise
     ))
 
@@ -235,18 +244,19 @@ it("collect", () =>
     .pipe(
       Effect.provide(Layer.mergeAll(SomethingRepo.Test, SomeService.Default)),
       setupRequestContextFromCurrent(),
+      Effect.scoped,
       Effect.runPromise
     ))
 
-class Person extends S.ExtendedTaggedClass<Person, Person.Encoded>()("person", {
+class Person extends S.TaggedClass<Person, Person.Encoded>()("person", {
   id: S.String,
   surname: S.String
 }) {}
-class Animal extends S.ExtendedTaggedClass<Animal, Animal.Encoded>()("animal", {
+class Animal extends S.TaggedClass<Animal, Animal.Encoded>()("animal", {
   id: S.String,
   surname: S.String
 }) {}
-class Test extends S.ExtendedTaggedClass<Test, Test.Encoded>()("test", {
+class Test extends S.TaggedClass<Test, Test.Encoded>()("test", {
   id: S.String
 }) {}
 
@@ -281,7 +291,7 @@ it(
         expect(result).toEqual([])
         expect(result2).toEqual([])
       })
-      .pipe(Effect.provide(MemoryStoreLive), setupRequestContextFromCurrent(), Effect.runPromise)
+      .pipe(Effect.provide(TestStoreLive), setupRequestContextFromCurrent(), Effect.scoped, Effect.runPromise)
 )
 
 it(
@@ -379,7 +389,6 @@ it(
         // eslint-disable-next-line unused-imports/no-unused-vars
         const query5 = make<Union>().pipe(
           where("id", "bla"),
-          // @ts-expect-error cannot project over fields that are not in common between the union members (you must refine the union first)
           project(S.Struct({ id: S.String, a: S.Unknown }))
         )
         console.log(query5)
@@ -467,7 +476,7 @@ it(
 
         expect([]).toEqual([])
       })
-      .pipe(Effect.provide(MemoryStoreLive), setupRequestContextFromCurrent(), Effect.runPromise)
+      .pipe(Effect.provide(TestStoreLive), setupRequestContextFromCurrent(), Effect.scoped, Effect.runPromise)
 )
 
 it(
@@ -510,7 +519,7 @@ it(
 
         expect([]).toEqual([])
       })
-      .pipe(Effect.provide(MemoryStoreLive), setupRequestContextFromCurrent(), Effect.runPromise)
+      .pipe(Effect.provide(TestStoreLive), setupRequestContextFromCurrent(), Effect.scoped, Effect.runPromise)
 )
 
 it(
@@ -521,8 +530,8 @@ it(
         const schema = S.Struct({
           id: S.String,
           createdAt: S.Date.pipe(
-            S.withDecodingDefault(() => new Date().toISOString()),
-            S.withConstructorDefault(() => Option.some(new Date()))
+            S.withDecodingDefault(Effect.sync(() => new Date().toISOString())),
+            S.withConstructorDefault(Effect.sync(() => new Date()))
           )
         })
         const repo = yield* makeRepo(
@@ -534,8 +543,8 @@ it(
         const outputSchema = S.Struct({
           id: S.Literal("123"),
           createdAt: S.Date.pipe(
-            S.withDecodingDefault(() => new Date().toISOString()),
-            S.withConstructorDefault(() => Option.some(new Date()))
+            S.withDecodingDefault(Effect.sync(() => new Date().toISOString())),
+            S.withConstructorDefault(Effect.sync(() => new Date()))
           )
         })
 
@@ -543,9 +552,347 @@ it(
 
         expect(result).toEqual([])
       })
-      .pipe(Effect.provide(MemoryStoreLive), setupRequestContextFromCurrent(), Effect.runPromise)
+      .pipe(Effect.provide(TestStoreLive), setupRequestContextFromCurrent(), Effect.scoped, Effect.runPromise)
 )
 
+it(
+  "project with encodeKeys in projection maps encoded keys",
+  () =>
+    Effect
+      .gen(function*() {
+        const schema = S.Struct({
+          id: S.String,
+          a: S.Number
+        })
+
+        const repo = yield* makeRepo(
+          "test",
+          schema,
+          {
+            makeInitial: Effect.sync(() => [{ id: "1", a: 1 }])
+          }
+        )
+
+        const outputSchema = S.Struct({ b: S.Number }).pipe(S.encodeKeys({ b: "a" }))
+
+        const result = yield* repo.query(project(outputSchema))
+
+        expect(result).toStrictEqual([{ b: 1 }])
+      })
+      .pipe(Effect.provide(TestStoreLive), setupRequestContextFromCurrent(), Effect.scoped, Effect.runPromise)
+)
+
+it("projectComputed sets computed IR and forces project mode", () => {
+  const baseSchema = S.Struct({
+    id: S.String,
+    items: S.Array(S.Struct({
+      state: S.Struct({
+        _tag: S.String
+      })
+    }))
+  })
+  const query = make<S.Codec.Encoded<typeof baseSchema>>().pipe(
+    projectComputed(
+      S.Struct({
+        pickedCount: S.NonNegativeInt
+      }),
+      computed({
+        pickedCount: relation<S.Codec.Encoded<typeof baseSchema>>("items").count(where("state._tag", "Picked"))
+      })
+    )
+  )
+  const interpreted = toFilter(query, baseSchema)
+  expect(interpreted.mode).toBe("project")
+  expect(interpreted.select).toEqual([
+    {
+      key: "pickedCount",
+      computed: {
+        _tag: "relation-count",
+        path: "items",
+        filter: [{ t: "where", path: "items.-1.state._tag", op: "eq", value: "Picked" }]
+      }
+    }
+  ])
+  expect(interpreted.computed?.["pickedCount"]?._tag).toBe("relation-count")
+  expect(interpreted.computed?.["pickedCount"]?.path).toBe("items")
+  expect((interpreted.computed?.["pickedCount"] as { filter: unknown } | undefined)?.filter).toEqual([
+    { t: "where", path: "items.-1.state._tag", op: "eq", value: "Picked" }
+  ])
+})
+
+it("projectComputed validates extra computed keys", () => {
+  const baseSchema = S.Struct({
+    id: S.String,
+    items: S.Array(S.Struct({ value: S.Number }))
+  })
+  const query = make<S.Codec.Encoded<typeof baseSchema>>().pipe(
+    projectComputed(
+      S.Struct({ id: S.String }),
+      // @ts-expect-error extra computed keys are rejected statically; keep runtime guard covered
+      computed({
+        pickedCount: relation<S.Codec.Encoded<typeof baseSchema>>("items").count()
+      })
+    )
+  )
+  expect(() => toFilter(query, baseSchema)).toThrowError("Computed projection keys must exist in projection schema")
+})
+
+it("projectComputed constrains projection schema to encoded repo fields and computed outputs", () => {
+  const baseSchema = S.Struct({
+    id: S.String,
+    name: S.String,
+    items: S.Array(S.Struct({ articleId: S.String, weight: S.Number }))
+  })
+  type Encoded = S.Codec.Encoded<typeof baseSchema>
+
+  make<Encoded>().pipe(
+    projectComputed(
+      S.Struct({
+        id: S.String,
+        itemCount: S.Number,
+        hasItems: S.Boolean,
+        articleIds: S.Array(S.String)
+      }),
+      ({ relation }) => ({
+        itemCount: relation("items").count(),
+        hasItems: relation("items").any(),
+        articleIds: relation("items").collect("articleId")
+      })
+    )
+  )
+
+  make<Encoded>().pipe(
+    projectComputed(S.Struct({ missingField: S.String }), computed({}))
+  )
+
+  make<Encoded>().pipe(
+    projectComputed(
+      S.Struct({ name: S.Number }),
+      computed({})
+    )
+  )
+
+  make<Encoded>().pipe(
+    projectComputed(
+      S.Struct({ itemCount: S.String }),
+      computed({ itemCount: relation<Encoded>("items").count() })
+    )
+  )
+
+  make<Encoded>().pipe(
+    projectComputed(
+      S.Struct({ itemCount: S.Number }),
+      // @ts-expect-error extra computed keys must exist in the projection schema
+      computed({
+        itemCount: relation<Encoded>("items").count(),
+        extraCount: relation<Encoded>("items").count()
+      })
+    )
+  )
+})
+
+it("projectComputed supports union projection schemas", () => {
+  const baseSchema = S.Union([
+    S.Struct({
+      _tag: S.Literal("open"),
+      id: S.String,
+      items: S.Array(S.Struct({ articleId: S.String, weight: S.Number }))
+    }),
+    S.Struct({
+      _tag: S.Literal("closed"),
+      id: S.String,
+      closedAt: S.String
+    })
+  ])
+  type Encoded = S.Codec.Encoded<typeof baseSchema>
+  const query = make<Encoded>().pipe(
+    projectComputed(
+      S.Union([
+        S.Struct({
+          _tag: S.Literal("open"),
+          id: S.String,
+          articleCount: S.Number,
+          weight: S.Number,
+          articleIds: S.Array(S.String)
+        }),
+        S.Struct({
+          _tag: S.Literal("closed"),
+          id: S.String,
+          closedAt: S.String
+        })
+      ]),
+      computed({
+        articleCount: relation<Encoded>("items").count(),
+        weight: relation<Encoded>("items").sum("weight"),
+        articleIds: relation<Encoded>("items").collect("articleId")
+      })
+    )
+  )
+
+  const interpreted = toFilter(query, baseSchema)
+  expect(interpreted.computed && Object.keys(interpreted.computed).toSorted()).toEqual([
+    "articleCount",
+    "articleIds",
+    "weight"
+  ])
+})
+
+it("projection schema with computed fields fails without computed map", () => {
+  const baseSchema = S.Struct({
+    id: S.String,
+    items: S.Array(S.Struct({ value: S.Number }))
+  })
+  const query = make<S.Codec.Encoded<typeof baseSchema>>().pipe(
+    projectComputed(S.Struct({ pickedCount: S.NonNegativeInt }), computed({}))
+  )
+  expect(() => toFilter(query, baseSchema)).toThrowError("Missing computed projections for schema keys")
+})
+
+it("projectComputed.every emits relation-every IR", () => {
+  const baseSchema = S.Struct({
+    id: S.String,
+    items: S.Array(S.Struct({ state: S.Struct({ _tag: S.String }) }))
+  })
+  const query = make<S.Codec.Encoded<typeof baseSchema>>().pipe(
+    projectComputed(
+      S.Struct({ allPicked: S.Boolean }),
+      computed({
+        allPicked: relation<S.Codec.Encoded<typeof baseSchema>>("items").every(where("state._tag", "Picked"))
+      })
+    )
+  )
+  const interpreted = toFilter(query, baseSchema)
+  expect(interpreted.computed?.["allPicked"]?._tag).toBe("relation-every")
+  expect(interpreted.computed?.["allPicked"]?.path).toBe("items")
+  expect((interpreted.computed?.["allPicked"] as { filter: unknown } | undefined)?.filter).toEqual([
+    { t: "where", path: "items.-1.state._tag", op: "eq", value: "Picked" }
+  ])
+})
+
+it("projectComputed.distinctCount emits relation-distinct-count IR with field", () => {
+  const baseSchema = S.Struct({
+    id: S.String,
+    items: S.Array(S.Struct({ rowId: S.String, state: S.Struct({ _tag: S.String }) }))
+  })
+  const query = make<S.Codec.Encoded<typeof baseSchema>>().pipe(
+    projectComputed(
+      S.Struct({ positionCount: S.NonNegativeInt }),
+      computed({
+        positionCount: relation<S.Codec.Encoded<typeof baseSchema>>("items").distinctCount(
+          "rowId",
+          where("state._tag", "neq", "cancelled")
+        )
+      })
+    )
+  )
+  const interpreted = toFilter(query, baseSchema)
+  const ir = interpreted.computed?.["positionCount"]
+  expect(ir?._tag).toBe("relation-distinct-count")
+  expect((ir as { field: string } | undefined)?.field).toBe("rowId")
+  expect((ir as { filter: unknown } | undefined)?.filter).toEqual([
+    { t: "where", path: "items.-1.state._tag", op: "neq", value: "cancelled" }
+  ])
+})
+
+it("projectComputed.sum emits relation-sum IR with field", () => {
+  const baseSchema = S.Struct({
+    id: S.String,
+    items: S.Array(S.Struct({ weight: S.Number }))
+  })
+  const query = make<S.Codec.Encoded<typeof baseSchema>>().pipe(
+    projectComputed(
+      S.Struct({ totalWeight: S.Number }),
+      computed({ totalWeight: relation<S.Codec.Encoded<typeof baseSchema>>("items").sum("weight") })
+    )
+  )
+  const interpreted = toFilter(query, baseSchema)
+  const ir = interpreted.computed?.["totalWeight"]
+  expect(ir?._tag).toBe("relation-sum")
+  expect((ir as { field: string } | undefined)?.field).toBe("weight")
+  expect((ir as { filter: unknown } | undefined)?.filter).toEqual([])
+})
+
+it("projectComputed.collect / collectDistinct emit relation-collect IR", () => {
+  const baseSchema = S.Struct({
+    id: S.String,
+    items: S.Array(S.Struct({ articleId: S.String }))
+  })
+  const query = make<S.Codec.Encoded<typeof baseSchema>>().pipe(
+    projectComputed(
+      S.Struct({
+        all: S.Array(S.String),
+        distinct: S.Array(S.String)
+      }),
+      computed({
+        all: relation<S.Codec.Encoded<typeof baseSchema>>("items").collect("articleId"),
+        distinct: relation<S.Codec.Encoded<typeof baseSchema>>("items").collectDistinct("articleId")
+      })
+    )
+  )
+  const interpreted = toFilter(query, baseSchema)
+  const all = interpreted.computed?.["all"]
+  const distinct = interpreted.computed?.["distinct"]
+  expect(all?._tag).toBe("relation-collect")
+  expect((all as { distinct: boolean } | undefined)?.distinct).toBe(false)
+  expect(distinct?._tag).toBe("relation-collect")
+  expect((distinct as { distinct: boolean } | undefined)?.distinct).toBe(true)
+})
+
+it("projectComputed.sumExpr emits relation-sum-expr IR", () => {
+  const baseSchema = S.Struct({
+    id: S.String,
+    items: S.Array(S.Struct({
+      weight: S.Number,
+      tradeUnit: S.Struct({ amount: S.Number, unit: S.String })
+    }))
+  })
+  const query = make<S.Codec.Encoded<typeof baseSchema>>().pipe(
+    projectComputed(
+      S.Struct({ total: S.Number }),
+      computed({
+        total: relation<S.Codec.Encoded<typeof baseSchema>>("items").sumExpr(
+          expr.mul(expr.field("weight"), expr.field("tradeUnit.amount"))
+        )
+      })
+    )
+  )
+  const interpreted = toFilter(query, baseSchema)
+  const ir = interpreted.computed?.["total"]
+  expect(ir?._tag).toBe("relation-sum-expr")
+  expect((ir as { expression: unknown } | undefined)?.expression).toEqual({
+    _tag: "mul",
+    left: { _tag: "field", field: "weight" },
+    right: { _tag: "field", field: "tradeUnit.amount" }
+  })
+})
+
+it("projectComputed.sumExprBy emits relation-sum-expr-by IR", () => {
+  const baseSchema = S.Struct({
+    id: S.String,
+    items: S.Array(S.Struct({
+      weight: S.Number,
+      tradeUnit: S.Struct({ amount: S.Number, unit: S.String })
+    }))
+  })
+  const query = make<S.Codec.Encoded<typeof baseSchema>>().pipe(
+    projectComputed(
+      S.Struct({
+        totals: S.Array(S.Struct({ unit: S.String, total: S.Number }))
+      }),
+      computed({
+        totals: relation<S.Codec.Encoded<typeof baseSchema>>("items").sumExprBy(
+          expr.mul(expr.field("weight"), expr.field("tradeUnit.amount")),
+          { unit: "tradeUnit.unit" }
+        )
+      })
+    )
+  )
+  const interpreted = toFilter(query, baseSchema)
+  const ir = interpreted.computed?.["totals"]
+  expect(ir?._tag).toBe("relation-sum-expr-by")
+  expect((ir as { unit: string } | undefined)?.unit).toBe("tradeUnit.unit")
+})
+
 it(
   "doesn't mess when refining fields",
   () =>
@@ -553,7 +900,7 @@ it(
       .gen(function*() {
         const schema = S.Struct({
           id: S.String,
-          literals: S.Literal("a", "b", "c")
+          literals: S.Literals(["a", "b", "c"])
         })
 
         type Schema = typeof schema.Type
@@ -573,7 +920,7 @@ it(
 
         expect(result).toEqual([])
       })
-      .pipe(Effect.provide(MemoryStoreLive), setupRequestContextFromCurrent(), Effect.runPromise)
+      .pipe(Effect.provide(TestStoreLive), setupRequestContextFromCurrent(), Effect.scoped, Effect.runPromise)
 )
 
 it(
@@ -583,7 +930,7 @@ it(
       .gen(function*() {
         const schema = S.Struct({
           id: S.String,
-          literals: S.Union([S.Literal("a", "b", "c"), S.Null])
+          literals: S.Union([S.Literals(["a", "b", "c"]), S.Null])
         })
 
         type Schema = typeof schema.Type
@@ -617,7 +964,7 @@ it(
 
         expect(result).toEqual([])
       })
-      .pipe(Effect.provide(MemoryStoreLive), setupRequestContextFromCurrent(), Effect.runPromise)
+      .pipe(Effect.provide(TestStoreLive), setupRequestContextFromCurrent(), Effect.scoped, Effect.runPromise)
 )
 
 it(
@@ -661,7 +1008,7 @@ it(
 
         expect(result).toEqual([])
       })
-      .pipe(Effect.provide(MemoryStoreLive), setupRequestContextFromCurrent(), Effect.runPromise)
+      .pipe(Effect.provide(TestStoreLive), setupRequestContextFromCurrent(), Effect.scoped, Effect.runPromise)
 )
 
 it("remove null from one constituent of a tagged union", () =>
@@ -674,7 +1021,7 @@ it("remove null from one constituent of a tagged union", () =>
 
       class BB extends S.Class<BB>("BB")({
         id: S.Literal("BB"),
-        b: S.NullOr(S.Number)
+        b: S.NullOr(S.Finite)
       }) {}
 
       type Union = AA | BB
@@ -710,7 +1057,7 @@ it("remove null from one constituent of a tagged union", () =>
         })[]
       >()
     })
-    .pipe(Effect.provide(MemoryStoreLive), setupRequestContextFromCurrent(), Effect.runPromise))
+    .pipe(Effect.provide(TestStoreLive), setupRequestContextFromCurrent(), Effect.scoped, Effect.runPromise))
 
 it("refine 3", () =>
   Effect
@@ -748,7 +1095,7 @@ it("refine 3", () =>
       const resQuer1 = yield* repo.query(where("id", "AA"))
       expectTypeOf(resQuer1).toEqualTypeOf<readonly AA[]>()
     })
-    .pipe(Effect.provide(MemoryStoreLive), setupRequestContextFromCurrent(), Effect.runPromise))
+    .pipe(Effect.provide(TestStoreLive), setupRequestContextFromCurrent(), Effect.scoped, Effect.runPromise))
 
 it("my test", () =>
   Effect
@@ -766,7 +1113,7 @@ it("my test", () =>
       )
       expectTypeOf(resQuer1).toEqualTypeOf<readonly AA[]>()
     })
-    .pipe(Effect.provide(MemoryStoreLive), setupRequestContextFromCurrent(), Effect.runPromise))
+    .pipe(Effect.provide(TestStoreLive), setupRequestContextFromCurrent(), Effect.scoped, Effect.runPromise))
 
 it("refine inner without imposing a projection", () =>
   Effect
@@ -810,7 +1157,7 @@ it("refine inner without imposing a projection", () =>
         where("union._tag", "AA"),
         // But if I wanna the whole Data as output ignoring the inner refinement
         // I wanna be able to do so
-        project(S.Struct(Data.pick("union")))
+        project(Data.mapFields(Struct.pick(["union"])))
       )
 
       expectTypeOf(query2).toEqualTypeOf<
@@ -841,7 +1188,7 @@ it("refine inner without imposing a projection", () =>
         }[]
       >()
     })
-    .pipe(Effect.provide(MemoryStoreLive), setupRequestContextFromCurrent(), Effect.runPromise))
+    .pipe(Effect.provide(TestStoreLive), setupRequestContextFromCurrent(), Effect.scoped, Effect.runPromise))
 
 it("does not allow string queries on arrays", () =>
   Effect
@@ -876,7 +1223,7 @@ it("does not allow string queries on arrays", () =>
       expectTypeOf(good3).toEqualTypeOf<QueryWhere<Some, Some>>()
       expectTypeOf(good4).toEqualTypeOf<QueryWhere<Some, Some>>()
     })
-    .pipe(Effect.provide(MemoryStoreLive), setupRequestContextFromCurrent(), Effect.runPromise))
+    .pipe(Effect.provide(TestStoreLive), setupRequestContextFromCurrent(), Effect.scoped, Effect.runPromise))
 
 it("test array.length", () =>
   Effect
@@ -917,7 +1264,7 @@ it("test array.length", () =>
         QueryWhere<Something, Something>
       >()
     })
-    .pipe(Effect.provide(MemoryStoreLive), setupRequestContextFromCurrent(), Effect.runPromise))
+    .pipe(Effect.provide(TestStoreLive), setupRequestContextFromCurrent(), Effect.scoped, Effect.runPromise))
 
 it("distribution over union", () =>
   Effect
@@ -941,7 +1288,7 @@ it("distribution over union", () =>
         })[]
       >()
     })
-    .pipe(Effect.provide(MemoryStoreLive), setupRequestContextFromCurrent(), Effect.runPromise))
+    .pipe(Effect.provide(TestStoreLive), setupRequestContextFromCurrent(), Effect.scoped, Effect.runPromise))
 
 it("refine nested union", () =>
   Effect
@@ -982,7 +1329,158 @@ it("refine nested union", () =>
         }[]
       >()
     })
-    .pipe(Effect.provide(MemoryStoreLive), setupRequestContextFromCurrent(), Effect.runPromise))
+    .pipe(Effect.provide(TestStoreLive), setupRequestContextFromCurrent(), Effect.scoped, Effect.runPromise))
+
+it("find with transformed id", () =>
+  Effect
+    .gen(function*() {
+      const ConfiguratorId = S.NonEmptyString255
+
+      class PreconfigurationId extends S.Class<PreconfigurationId>("PreconfigurationId")({
+        configuratorId: ConfiguratorId,
+        label: S.NonEmptyString50
+      }) {}
+
+      const PreconfigurationIdFromString = S.NonEmptyString255.pipe(
+        S.decodeTo(
+          S.toType(PreconfigurationId),
+          SchemaTransformation.transformOrFail({
+            decode: Effect.fnUntraced(function*(value) {
+              const values = value.split("_")
+              const label = yield* S.SchemaParser.decodeUnknownEffect(S.NonEmptyString50)(values.pop())
+              const configuratorId = yield* S.SchemaParser.decodeUnknownEffect(ConfiguratorId)(
+                values.join("_")
+              )
+              return new PreconfigurationId({ configuratorId, label })
+            }),
+            encode: (id) => Effect.succeed(S.NonEmptyString255(`${id.configuratorId}_${id.label}`))
+          })
+        ),
+        S.revealCodec
+      )
+
+      const Preconfiguration = S.Struct({
+        id: PreconfigurationIdFromString,
+        name: S.String
+      })
+
+      const repo = yield* makeRepo("Preconfiguration", Preconfiguration, { idKey: "id" as const })
+
+      const id = new PreconfigurationId({
+        configuratorId: S.NonEmptyString255("myConfigurator"),
+        label: S.NonEmptyString50("myLabel")
+      })
+      const item = { id, name: "test preconfig" }
+
+      yield* repo.saveAndPublish([item])
+
+      const found = yield* repo.find(id)
+      expect(Option.isSome(found)).toBe(true)
+      expect(Option.getOrThrow(found).name).toBe("test preconfig")
+      expect(Option.getOrThrow(found).id).toEqual(id)
+
+      const notFound = yield* repo.find(
+        new PreconfigurationId({
+          configuratorId: S.NonEmptyString255("other"),
+          label: S.NonEmptyString50("nope")
+        })
+      )
+      expect(Option.isNone(notFound)).toBe(true)
+    })
+    .pipe(Effect.provide(TestStoreLive), setupRequestContextFromCurrent(), Effect.scoped, Effect.runPromise))
+
+it("find with transformed id in tagged union", () =>
+  Effect
+    .gen(function*() {
+      const ConfiguratorId = S.NonEmptyString255
+
+      class PreconfigurationId extends S.Class<PreconfigurationId>("PreconfigurationId")({
+        configuratorId: ConfiguratorId,
+        label: S.NonEmptyString50
+      }) {}
+
+      const PreconfigurationIdFromString = S.NonEmptyString255.pipe(
+        S.decodeTo(
+          S.toType(PreconfigurationId),
+          SchemaTransformation.transformOrFail({
+            decode: Effect.fnUntraced(function*(value) {
+              const values = value.split("_")
+              const label = yield* S.SchemaParser.decodeUnknownEffect(S.NonEmptyString50)(values.pop())
+              const configuratorId = yield* S.SchemaParser.decodeUnknownEffect(ConfiguratorId)(
+                values.join("_")
+              )
+              return new PreconfigurationId({ configuratorId, label })
+            }),
+            encode: (id) => Effect.succeed(S.NonEmptyString255(`${id.configuratorId}_${id.label}`))
+          })
+        ),
+        S.revealCodec
+      )
+
+      class Draft extends S.TaggedClass<Draft>()("Draft", {
+        id: PreconfigurationIdFromString,
+        name: S.String
+      }) {}
+
+      class Published extends S.TaggedClass<Published>()("Published", {
+        id: PreconfigurationIdFromString,
+        name: S.String,
+        publishedAt: S.String
+      }) {}
+
+      class Archived extends S.TaggedClass<Archived>()("Archived", {
+        id: PreconfigurationIdFromString,
+        name: S.String,
+        archivedAt: S.String
+      }) {}
+
+      const Preconfiguration = S.Union([Draft, Published, Archived])
+
+      const repo = yield* makeRepo("Preconfiguration", Preconfiguration, {})
+
+      const id1 = new PreconfigurationId({
+        configuratorId: S.NonEmptyString255("conf1"),
+        label: S.NonEmptyString50("draft1")
+      })
+      const id2 = new PreconfigurationId({
+        configuratorId: S.NonEmptyString255("conf2"),
+        label: S.NonEmptyString50("pub1")
+      })
+      const id3 = new PreconfigurationId({
+        configuratorId: S.NonEmptyString255("conf3"),
+        label: S.NonEmptyString50("arch1")
+      })
+
+      const draft = new Draft({ id: id1, name: "my draft" })
+      const published = new Published({ id: id2, name: "my published", publishedAt: "2024-01-01" })
+      const archived = new Archived({ id: id3, name: "my archived", archivedAt: "2024-06-01" })
+
+      yield* repo.saveAndPublish([draft, published, archived])
+
+      // find each by their PreconfigurationId instance
+      const foundDraft = yield* repo.find(id1)
+      expect(Option.isSome(foundDraft)).toBe(true)
+      expect(Option.getOrThrow(foundDraft)._tag).toBe("Draft")
+      expect(Option.getOrThrow(foundDraft).name).toBe("my draft")
+
+      const foundPublished = yield* repo.find(id2)
+      expect(Option.isSome(foundPublished)).toBe(true)
+      expect(Option.getOrThrow(foundPublished)._tag).toBe("Published")
+
+      const foundArchived = yield* repo.find(id3)
+      expect(Option.isSome(foundArchived)).toBe(true)
+      expect(Option.getOrThrow(foundArchived)._tag).toBe("Archived")
+
+      // not found
+      const notFound = yield* repo.find(
+        new PreconfigurationId({
+          configuratorId: S.NonEmptyString255("nope"),
+          label: S.NonEmptyString50("nope")
+        })
+      )
+      expect(Option.isNone(notFound)).toBe(true)
+    })
+    .pipe(Effect.provide(TestStoreLive), setupRequestContextFromCurrent(), Effect.scoped, Effect.runPromise))
 
 it("refine union with nested union", () =>
   Effect
@@ -1097,4 +1595,470 @@ it("refine union with nested union", () =>
         })[]
       >()
     })
-    .pipe(Effect.provide(MemoryStoreLive), setupRequestContextFromCurrent(), Effect.runPromise))
+    .pipe(Effect.provide(TestStoreLive), setupRequestContextFromCurrent(), Effect.scoped, Effect.runPromise))
+
+// ---------------------------------------------------------------------------
+// memFilter: computed projection execution (in-memory) and code filter coverage
+// ---------------------------------------------------------------------------
+
+const computedBaseSchema = S.Struct({
+  id: S.String,
+  status: S.Literals(["active", "archived"]),
+  items: S.Array(S.Struct({
+    id: S.String,
+    tag: S.Literals(["a", "b", "c"]),
+    qty: S.Finite,
+    note: S.String
+  }))
+})
+type ComputedBase = S.Codec.Encoded<typeof computedBaseSchema>
+
+const computedRows: ComputedBase[] = [
+  {
+    id: "r1",
+    status: "active",
+    items: [
+      { id: "i1", tag: "a", qty: 10, note: "alpha" },
+      { id: "i2", tag: "a", qty: 20, note: "alpha" },
+      { id: "i3", tag: "b", qty: 5, note: "beta" }
+    ]
+  },
+  { id: "r2", status: "active", items: [] },
+  {
+    id: "r3",
+    status: "archived",
+    items: [
+      { id: "i4", tag: "b", qty: 7, note: "gamma" },
+      { id: "i5", tag: "b", qty: 7, note: "gamma" },
+      { id: "i6", tag: "c", qty: 3, note: "delta" }
+    ]
+  }
+]
+
+it("memFilter: relation-count with filter", () => {
+  const q = make<ComputedBase>().pipe(
+    projectComputed(
+      S.Struct({ id: S.String, aCount: S.NonNegativeInt }),
+      computed({
+        aCount: relation<ComputedBase>("items").count(where("tag", "a"))
+      })
+    )
+  )
+  expect(memFilter(toFilter(q, computedBaseSchema))(computedRows)).toEqual([
+    { id: "r1", aCount: 2 },
+    { id: "r2", aCount: 0 },
+    { id: "r3", aCount: 0 }
+  ])
+})
+
+it("memFilter: relation-any / every with filter", () => {
+  const q = make<ComputedBase>().pipe(
+    projectComputed(
+      S.Struct({
+        id: S.String,
+        hasA: S.Boolean,
+        allB: S.Boolean
+      }),
+      computed({
+        hasA: relation<ComputedBase>("items").any(where("tag", "a")),
+        allB: relation<ComputedBase>("items").every(where("tag", "b"))
+      })
+    )
+  )
+  expect(memFilter(toFilter(q, computedBaseSchema))(computedRows)).toEqual([
+    { id: "r1", hasA: true, allB: false },
+    // empty array: any → false, every → true (JS Array.every on [] is true)
+    { id: "r2", hasA: false, allB: true },
+    { id: "r3", hasA: false, allB: false }
+  ])
+})
+
+it("memFilter: relation-distinct-count with filter", () => {
+  const q = make<ComputedBase>().pipe(
+    projectComputed(
+      S.Struct({ id: S.String, distinctNotes: S.NonNegativeInt }),
+      computed({
+        distinctNotes: relation<ComputedBase>("items").distinctCount("note", where("tag", "neq", "c"))
+      })
+    )
+  )
+  expect(memFilter(toFilter(q, computedBaseSchema))(computedRows)).toEqual([
+    { id: "r1", distinctNotes: 2 }, // alpha, beta
+    { id: "r2", distinctNotes: 0 },
+    { id: "r3", distinctNotes: 1 } // gamma (delta filtered out)
+  ])
+})
+
+it("memFilter: relation-sum with filter", () => {
+  const q = make<ComputedBase>().pipe(
+    projectComputed(
+      S.Struct({ id: S.String, totalQty: S.Finite }),
+      computed({
+        totalQty: relation<ComputedBase>("items").sum("qty", where("tag", "neq", "c"))
+      })
+    )
+  )
+  expect(memFilter(toFilter(q, computedBaseSchema))(computedRows)).toEqual([
+    { id: "r1", totalQty: 35 },
+    { id: "r2", totalQty: 0 },
+    { id: "r3", totalQty: 14 }
+  ])
+})
+
+it("memFilter: relation-collect / collectDistinct with filter", () => {
+  const q = make<ComputedBase>().pipe(
+    projectComputed(
+      S.Struct({
+        id: S.String,
+        notes: S.Array(S.String),
+        distinctNotes: S.Array(S.String)
+      }),
+      computed({
+        notes: relation<ComputedBase>("items").collect("note", where("tag", "neq", "c")),
+        distinctNotes: relation<ComputedBase>("items").collectDistinct("note", where("tag", "neq", "c"))
+      })
+    )
+  )
+  expect(memFilter(toFilter(q, computedBaseSchema))(computedRows)).toEqual([
+    { id: "r1", notes: ["alpha", "alpha", "beta"], distinctNotes: ["alpha", "beta"] },
+    { id: "r2", notes: [], distinctNotes: [] },
+    { id: "r3", notes: ["gamma", "gamma"], distinctNotes: ["gamma"] }
+  ])
+})
+
+it("memFilter: computed projection with multi-statement relation filter", () => {
+  const q = make<ComputedBase>().pipe(
+    projectComputed(
+      S.Struct({ id: S.String, hits: S.NonNegativeInt }),
+      computed({
+        hits: relation<ComputedBase>("items").count(
+          flow(
+            where("tag", "a"),
+            and("qty", "gt", 10)
+          )
+        )
+      })
+    )
+  )
+  expect(memFilter(toFilter(q, computedBaseSchema))(computedRows)).toEqual([
+    { id: "r1", hits: 1 }, // only i2 (a, qty 20)
+    { id: "r2", hits: 0 },
+    { id: "r3", hits: 0 }
+  ])
+})
+
+it("memFilter: relation-sum-expr / sum-expr-by / sum-expr-normalized", () => {
+  const schema = S.Struct({
+    id: S.String,
+    items: S.Array(S.Struct({
+      weight: S.Finite,
+      tradeUnit: S.Struct({ amount: S.Finite, unit: S.String })
+    }))
+  })
+  type Row = S.Codec.Encoded<typeof schema>
+  const rows: Row[] = [
+    {
+      id: "r1",
+      items: [
+        { weight: 2, tradeUnit: { amount: 5, unit: "kg" } },
+        { weight: 4, tradeUnit: { amount: 1000, unit: "g" } },
+        { weight: 3, tradeUnit: { amount: 1, unit: "kg" } }
+      ]
+    },
+    { id: "r2", items: [] }
+  ]
+  const weighted = expr.mul(expr.field("weight"), expr.field("tradeUnit.amount"))
+  const q = make<Row>().pipe(
+    projectComputed(
+      S.Struct({
+        id: S.String,
+        totalRaw: S.Finite,
+        totalsByUnit: S.Array(S.Struct({ unit: S.String, total: S.Finite })),
+        totalKg: S.Finite
+      }),
+      computed({
+        totalRaw: relation<Row>("items").sumExpr(weighted, where("weight", "gte", 0)),
+        totalsByUnit: relation<Row>("items").sumExprBy(weighted, { unit: "tradeUnit.unit" }, where("weight", "gte", 0)),
+        totalKg: relation<Row>("items").sumExprNormalized(weighted, {
+          unit: "tradeUnit.unit",
+          toBase: "kg",
+          factors: { g: 0.001 }
+        }, where("weight", "gte", 0))
+      })
+    )
+  )
+  expect(memFilter(toFilter(q, schema))(rows)).toEqual([
+    {
+      id: "r1",
+      totalRaw: 4013,
+      totalsByUnit: [{ unit: "kg", total: 13 }, { unit: "g", total: 4000 }],
+      totalKg: 17
+    },
+    { id: "r2", totalRaw: 0, totalsByUnit: [], totalKg: 0 }
+  ])
+})
+
+it("memFilter: computed projection combined with root where filter", () => {
+  const q = make<ComputedBase>().pipe(
+    where("id", "neq", "r3"),
+    projectComputed(
+      S.Struct({ id: S.String, totalQty: S.Finite }),
+      computed({
+        totalQty: relation<ComputedBase>("items").sum("qty", where("tag", "neq", "c"))
+      })
+    )
+  )
+  expect(memFilter(toFilter(q, computedBaseSchema))(computedRows)).toEqual([
+    { id: "r1", totalQty: 35 },
+    { id: "r2", totalQty: 0 }
+  ])
+})
+
+it("memFilter: computed projection with order/limit/skip applied to base rows", () => {
+  const q = make<ComputedBase>().pipe(
+    order("id", "DESC"),
+    page({ skip: 1, take: 1 }),
+    projectComputed(
+      S.Struct({ id: S.String, total: S.NonNegativeInt }),
+      computed({
+        total: relation<ComputedBase>("items").count(where("qty", "gte", 0))
+      })
+    )
+  )
+  expect(memFilter(toFilter(q, computedBaseSchema))(computedRows)).toEqual([
+    { id: "r2", total: 0 }
+  ])
+})
+
+it("memFilter: computed projection - relation missing on row returns empty value", () => {
+  const partial: ComputedBase[] = [
+    { id: "x1" } as ComputedBase,
+    { id: "x2", status: "active", items: undefined as unknown as ComputedBase["items"] }
+  ]
+  const q = make<ComputedBase>().pipe(
+    projectComputed(
+      S.Struct({
+        id: S.String,
+        c: S.NonNegativeInt,
+        s: S.Finite,
+        any_: S.Boolean,
+        every_: S.Boolean,
+        coll: S.Array(S.String)
+      }),
+      computed({
+        c: relation<ComputedBase>("items").count(where("tag", "a")),
+        s: relation<ComputedBase>("items").sum("qty", where("tag", "a")),
+        any_: relation<ComputedBase>("items").any(where("tag", "a")),
+        every_: relation<ComputedBase>("items").every(where("tag", "a")),
+        coll: relation<ComputedBase>("items").collect("note", where("tag", "a"))
+      })
+    )
+  )
+  expect(memFilter(toFilter(q, computedBaseSchema))(partial)).toEqual([
+    { id: "x1", c: 0, s: 0, any_: false, every_: true, coll: [] },
+    { id: "x2", c: 0, s: 0, any_: false, every_: true, coll: [] }
+  ])
+})
+
+it("memFilter: rejects extra computed keys not in projection schema", () => {
+  const q = make<ComputedBase>().pipe(
+    projectComputed(
+      S.Struct({ id: S.String }),
+      // @ts-expect-error extra computed keys are rejected statically; keep runtime guard covered
+      computed({
+        bogus: relation<ComputedBase>("items").count(where("tag", "a"))
+      })
+    )
+  )
+  expect(() => toFilter(q, computedBaseSchema)).toThrowError(
+    "Computed projection keys must exist in projection schema"
+  )
+})
+
+// ---------------------------------------------------------------------------
+// memFilter: code filter (where/and/or/scopes) execution coverage
+// ---------------------------------------------------------------------------
+
+type CFRow = {
+  readonly id: string
+  readonly tag: "x" | "y" | "z"
+  readonly qty: number
+  readonly desc: string
+  readonly tags: ReadonlyArray<string>
+  readonly nested: { readonly kind: "k1" | "k2"; readonly v: number }
+}
+
+const cfRows: CFRow[] = [
+  { id: "1", tag: "x", qty: 10, desc: "Hello World", tags: ["red", "green"], nested: { kind: "k1", v: 1 } },
+  { id: "2", tag: "y", qty: 20, desc: "Goodbye", tags: ["blue"], nested: { kind: "k2", v: 5 } },
+  { id: "3", tag: "z", qty: 0, desc: "Hello again", tags: ["red", "blue", "green"], nested: { kind: "k1", v: 9 } },
+  { id: "4", tag: "y", qty: 30, desc: "World cup", tags: [], nested: { kind: "k2", v: 0 } }
+]
+
+const runCF = (q: any) => (memFilter(toFilter(q))(cfRows) as unknown as readonly CFRow[]).map((_) => _.id)
+
+it("codeFilter: where + and chain", () => {
+  const q = make<CFRow>().pipe(
+    where("tag", "y"),
+    and("qty", "gt", 25)
+  )
+  expect(runCF(q)).toEqual(["4"])
+})
+
+it("codeFilter: where + or chain", () => {
+  const q = make<CFRow>().pipe(
+    where("tag", "x"),
+    or("tag", "z")
+  )
+  expect(runCF(q).sort()).toEqual(["1", "3"])
+})
+
+it("codeFilter: nested scope precedence (a AND (b OR c))", () => {
+  const q = make<CFRow>().pipe(
+    where("tag", "y"),
+    and(
+      where("qty", "gt", 25),
+      or("desc", "contains", "good")
+    )
+  )
+  // tag=y AND (qty>25 OR desc contains "good") → row 2 (Goodbye) and row 4 (qty 30)
+  expect(runCF(q).sort()).toEqual(["2", "4"])
+})
+
+it("codeFilter: contains/startsWith/endsWith are case-insensitive", () => {
+  expect(runCF(make<CFRow>().pipe(where("desc", "contains", "WORLD"))).sort()).toEqual(["1", "4"])
+  expect(runCF(make<CFRow>().pipe(where("desc", "startsWith", "hello"))).sort()).toEqual(["1", "3"])
+  expect(runCF(make<CFRow>().pipe(where("desc", "endsWith", "AGAIN")))).toEqual(["3"])
+})
+
+it("codeFilter: array includes / includes-any / includes-all", () => {
+  expect(runCF(make<CFRow>().pipe(where("tags", "includes", "red"))).sort()).toEqual(["1", "3"])
+  expect(runCF(make<CFRow>().pipe(where("tags", "includes-any", ["blue", "green"]))).sort()).toEqual([
+    "1",
+    "2",
+    "3"
+  ])
+  expect(runCF(make<CFRow>().pipe(where("tags", "includes-all", ["red", "blue"])))).toEqual(["3"])
+})
+
+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"])
+})
+
+it("codeFilter: gt / gte / lt / lte / neq", () => {
+  expect(runCF(make<CFRow>().pipe(where("qty", "gt", 10))).sort()).toEqual(["2", "4"])
+  expect(runCF(make<CFRow>().pipe(where("qty", "gte", 10))).sort()).toEqual(["1", "2", "4"])
+  expect(runCF(make<CFRow>().pipe(where("qty", "lt", 10)))).toEqual(["3"])
+  expect(runCF(make<CFRow>().pipe(where("qty", "lte", 10))).sort()).toEqual(["1", "3"])
+  expect(runCF(make<CFRow>().pipe(where("qty", "neq", 0))).sort()).toEqual(["1", "2", "4"])
+})
+
+it("codeFilter: nested path access through dot notation", () => {
+  expect(runCF(make<CFRow>().pipe(where("nested.kind", "k1"))).sort()).toEqual(["1", "3"])
+  expect(
+    runCF(
+      make<CFRow>().pipe(
+        where("nested.kind", "k2"),
+        and("nested.v", "gt", 0)
+      )
+    )
+  )
+    .toEqual(["2"])
+})
+
+it("codeFilter: array length predicates", () => {
+  expect(runCF(make<CFRow>().pipe(where("tags.length", 0)))).toEqual(["4"])
+  expect(runCF(make<CFRow>().pipe(where("tags.length", "gte", 2))).sort()).toEqual(["1", "3"])
+})
+
+it("codeFilter: order + skip + limit applied after filter", () => {
+  const q = make<CFRow>().pipe(
+    where("tag", "neq", "z"),
+    order("qty", "DESC"),
+    page({ skip: 1, take: 2 })
+  )
+  expect(runCF(q)).toEqual(["2", "1"])
+})
+
+// ─────────────────────────────────────────────────────────────────────────────
+// memFilter: aggregate (GROUP BY) support
+// ─────────────────────────────────────────────────────────────────────────────
+
+it("memFilter: agg-count-when groups rows and counts conditionally", () => {
+  type Row = { city: string; status: string }
+  const rows: Row[] = [
+    { city: "NYC", status: "active" },
+    { city: "NYC", status: "inactive" },
+    { city: "NYC", status: "active" },
+    { city: "LA", status: "active" }
+  ]
+  const result = memFilter<Row>({
+    t: {} as Row,
+    select: [
+      { key: "city", path: "city" },
+      {
+        key: "activeCount",
+        aggregate: {
+          _tag: "agg-count-when",
+          filter: [{ t: "where", path: "status", op: "eq", value: "active" }]
+        }
+      },
+      { key: "total", aggregate: { _tag: "agg-count" } }
+    ] as any
+  })(rows as any) as any[]
+
+  expect(result.length).toBe(2)
+  const nyc = result.find((r: any) => r.city === "NYC")!
+  expect(nyc.activeCount).toBe(2)
+  expect(nyc.total).toBe(3)
+  const la = result.find((r: any) => r.city === "LA")!
+  expect(la.activeCount).toBe(1)
+  expect(la.total).toBe(1)
+})
+
+it("memFilter: agg-sum / agg-min / agg-max aggregate numerics", () => {
+  type Row = { dept: string; salary: number }
+  const rows: Row[] = [
+    { dept: "eng", salary: 100 },
+    { dept: "eng", salary: 200 },
+    { dept: "hr", salary: 50 }
+  ]
+  const result = memFilter<Row>({
+    t: {} as Row,
+    select: [
+      { key: "dept", path: "dept" },
+      { key: "total", aggregate: { _tag: "agg-sum", field: "salary" } },
+      { key: "min", aggregate: { _tag: "agg-min", field: "salary" } },
+      { key: "max", aggregate: { _tag: "agg-max", field: "salary" } }
+    ] as any
+  })(rows as any) as any[]
+
+  expect(result.length).toBe(2)
+  const eng = result.find((r: any) => r.dept === "eng")!
+  expect(eng.total).toBe(300)
+  expect(eng.min).toBe(100)
+  expect(eng.max).toBe(200)
+  const hr = result.find((r: any) => r.dept === "hr")!
+  expect(hr.total).toBe(50)
+})
+
+it("memFilter: aggregate with nested path grouping", () => {
+  type Row = { address: { city: string }; value: number }
+  const rows: Row[] = [
+    { address: { city: "NYC" }, value: 10 },
+    { address: { city: "NYC" }, value: 20 },
+    { address: { city: "LA" }, value: 5 }
+  ]
+  const result = memFilter<Row>({
+    t: {} as Row,
+    select: [
+      { key: "city", path: "address.city" },
+      { key: "count", aggregate: { _tag: "agg-count" } }
+    ] as any
+  })(rows as any) as any[]
+
+  expect(result.length).toBe(2)
+  expect(result.find((r: any) => r.city === "NYC")!.count).toBe(2)
+  expect(result.find((r: any) => r.city === "LA")!.count).toBe(1)
+})