@effect-app/infra 0.200.2 → 0.201.0

package/src/services/RepositoryBase.ts

@@ -1,3 +1,6 @@
+/* eslint-disable @typescript-eslint/no-unsafe-return */
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable @typescript-eslint/ban-types */
 // import type { ParserEnv } from "@effect-app/schema/custom/Parser"
@@ -23,13 +26,14 @@ import { makeFilters } from "@effect-app/infra/filter"
 import type { ParseResult, Schema } from "@effect-app/schema"
 import { NonNegativeInt } from "@effect-app/schema"
 import type { Context, NonEmptyArray, NonEmptyReadonlyArray } from "effect-app"
-import { Chunk, Effect, flow, Option, pipe, PubSub, ReadonlyArray, S } from "effect-app"
+import { Chunk, Effect, flow, Option, pipe, PubSub, ReadonlyArray, S, Unify } from "effect-app"
 import { runTerm } from "effect-app/Pure"
 import type { FixEnv, PureEnv } from "effect-app/Pure"
 import { assignTag } from "effect-app/service"
+import type { NoInfer } from "effect/Types"
 import { type InvalidStateError, NotFoundError, type OptimisticConcurrencyException } from "../errors.js"
 import type { FieldValues } from "../filter/types.js"
-import { make as makeQuery, page, query } from "./query.js"
+import { make as makeQuery, page } from "./query.js"
 import type { QAll, Query, QueryEnd, QueryProjection, QueryWhere } from "./query.js"
 import * as Q2 from "./query.js"
 import { ContextMapContainer } from "./Store/ContextMapContainer.js"
@@ -99,17 +103,17 @@ export abstract class RepositoryBaseC<
   /** @deprecated use q2 */
   abstract readonly mapped: Mapped<PM, Omit<PM, "_etag">>
   abstract readonly q2: {
-    <A, R, From extends FieldValues>(
-      q: (initial: Query<Omit<PM, "_etag">>) => QueryProjection<Omit<PM, "_etag"> extends From ? From : never, A, R>
-    ): Effect.Effect<readonly A[], S.ParseResult.ParseError, R>
     <R = never>(
       q: (initial: Query<Omit<PM, "_etag">>) => QAll<Omit<PM, "_etag">, T, R>
     ): Effect.Effect<readonly T[], never, R>
+    <A, R, From extends FieldValues>(
+      q: (initial: Query<Omit<PM, "_etag">>) => QueryProjection<Omit<PM, "_etag"> extends From ? From : never, A, R>
+    ): Effect.Effect<readonly A[], S.ParseResult.ParseError, R>
 
+    <R = never>(q: QAll<Omit<PM, "_etag">, T, R>): Effect.Effect<readonly T[], never, R>
     <A, R, From extends FieldValues>(
       q: QueryProjection<Omit<PM, "_etag"> extends From ? From : never, A, R>
     ): Effect.Effect<readonly A[], S.ParseResult.ParseError, R>
-    <R = never>(q: QAll<Omit<PM, "_etag">, T, R>): Effect.Effect<readonly T[], never, R>
   }
 }
 
@@ -195,7 +199,7 @@ export class RepositoryBaseC3<
     q: (q: Query<Omit<PM, "_etag">>) => Query<Omit<PM, "_etag">> | QueryEnd<Omit<PM, "_etag">>,
     pure: Effect<A, E2, FixEnv<R2, Evt, T, T2>>
   ) =>
-    this.q2(flow(q, page({ limit: 1 }))).pipe(
+    this.q2(flow(q, page({ take: 1 }))).pipe(
       Effect.map(ReadonlyArray.toNonEmptyArray),
       Effect.flatMap(Effect.mapError(() => new NotFoundError({ type: this.itemType, id: q }))),
       Effect.andThen((_) => saveWithPure_(this, _[0], pure))
@@ -206,7 +210,7 @@ export class RepositoryBaseC3<
     pure: Effect<A, E2, FixEnv<R2, Evt, readonly T[], readonly T2[]>>,
     batchSize?: number
   ) =>
-    this.q2(flow(q, page({ limit: 1 }))).pipe(
+    this.q2(flow(q, page({ take: 1 }))).pipe(
       Effect.andThen((_) =>
         batchSize === undefined
           ? saveManyWithPure_(this, _, pure)
@@ -782,6 +786,50 @@ export function makeRepo<
             })
           }
 
+          const query: {
+            <
+              T extends { id: unknown },
+              PM extends PersistenceModelType<string>,
+              Evt,
+              ItemType extends string,
+              A,
+              R,
+              From extends FieldValues
+            >(
+              repo: Repository<T, PM, Evt, ItemType>,
+              q: QueryProjection<PM extends From ? From : never, A, R>
+            ): Effect.Effect<readonly A[], S.ParseResult.ParseError, R>
+            <
+              T extends { id: unknown },
+              PM extends PersistenceModelType<string>,
+              Evt,
+              ItemType extends string,
+              A,
+              R
+            >(
+              repo: Repository<T, PM, Evt, ItemType>,
+              q: QAll<NoInfer<PM>, A, R>
+            ): Effect.Effect<readonly A[], never, R>
+          } = (<
+            T extends { id: unknown },
+            PM extends PersistenceModelType<string>,
+            Evt,
+            ItemType extends string,
+            A,
+            R
+          >(repo: Repository<T, PM, Evt, ItemType>, q: QAll<PM, A, R>) => {
+            const a = Q2.toFilter(q)
+            return Effect.flatMap(
+              repo.utils.filter(a),
+              (_) =>
+                Unify.unify(
+                  a.schema
+                    ? repo.utils.parseMany2(_, a.schema as any)
+                    : repo.utils.parseMany(_)
+                )
+            )
+          }) as any
+
           const r: Repository<T, PM, Evt, ItemType> = {
             /**
              * @internal
@@ -1105,17 +1153,17 @@ export interface RepoFunctions<T extends { id: unknown }, PM extends { id: strin
   }
 
   readonly q2: {
-    <A, R, From extends FieldValues>(
-      q: (initial: Query<Omit<PM, "_etag">>) => QueryProjection<Omit<PM, "_etag"> extends From ? From : never, A, R>
-    ): Effect.Effect<readonly A[], S.ParseResult.ParseError, Service | R>
     <R = never>(
       q: (initial: Query<Omit<PM, "_etag">>) => QAll<Omit<PM, "_etag">, T, R>
     ): Effect.Effect<readonly T[], never, Service | R>
+    <A, R, From extends FieldValues>(
+      q: (initial: Query<Omit<PM, "_etag">>) => QueryProjection<Omit<PM, "_etag"> extends From ? From : never, A, R>
+    ): Effect.Effect<readonly A[], S.ParseResult.ParseError, Service | R>
 
+    <R = never>(q: QAll<Omit<PM, "_etag">, T, R>): Effect.Effect<readonly T[], never, Service | R>
     <A, R, From extends FieldValues>(
       q: QueryProjection<Omit<PM, "_etag"> extends From ? From : never, A, R>
     ): Effect.Effect<readonly A[], S.ParseResult.ParseError, Service | R>
-    <R = never>(q: QAll<Omit<PM, "_etag">, T, R>): Effect.Effect<readonly T[], never, Service | R>
   }
 }
 

package/src/services/query/dsl.ts

@@ -0,0 +1,290 @@
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import type { FieldValues } from "@effect-app/infra/filter/types"
+import type { FieldPath, FieldPathValue } from "@effect-app/infra/filter/types/path/eager"
+import type { Ops } from "@effect-app/infra/services/Store/filterApi/proxy"
+import type { S } from "effect-app"
+import { Data } from "effect-app"
+import type { Covariant } from "effect/Types"
+
+export type QAll<TFieldValues extends FieldValues, A = TFieldValues, R = never> =
+  | Query<TFieldValues>
+  | QueryWhere<TFieldValues>
+  | QueryEnd<TFieldValues>
+  | QueryProjection<TFieldValues, A, R>
+
+export const QId = Symbol()
+export type QId = typeof QId
+
+export interface QueryTogether<
+  out TFieldValues extends FieldValues,
+  out T extends "initial" | "where" | "end" | "projection" = "initial",
+  out A = TFieldValues,
+  out R = never
+> {
+  readonly [QId]: {
+    readonly _TFieldValues: Covariant<TFieldValues>
+    readonly _T: Covariant<T>
+    readonly _A: Covariant<A>
+    readonly _R: Covariant<R>
+  }
+}
+
+export type Query<TFieldValues extends FieldValues> = QueryTogether<TFieldValues, "initial">
+export type QueryWhere<TFieldValues extends FieldValues> = QueryTogether<TFieldValues, "where">
+
+export type QueryEnd<TFieldValues extends FieldValues> = QueryTogether<TFieldValues, "end">
+
+export type QueryProjection<TFieldValues extends FieldValues, A = TFieldValues, R = never> = QueryTogether<
+  TFieldValues,
+  "projection",
+  A,
+  R
+>
+
+export type Q<TFieldValues extends FieldValues> =
+  | Initial<TFieldValues>
+  | Where<TFieldValues>
+  | And<TFieldValues>
+  | Or<TFieldValues>
+  | Order<TFieldValues, any>
+  | Page<TFieldValues>
+  | Project<any, TFieldValues, any>
+
+export class Initial<TFieldValues extends FieldValues> extends Data.TaggedClass("value")<{ value: "initial" }>
+  implements Query<TFieldValues>
+{
+  readonly [QId]!: any
+  constructor() {
+    super({ value: "initial" as const })
+  }
+}
+
+export class Where<TFieldValues extends FieldValues> extends Data.TaggedClass("where")<{
+  current: Query<TFieldValues>
+  operation: [string, Ops, any] | [string, any]
+}> implements QueryWhere<TFieldValues> {
+  readonly [QId]!: any
+}
+
+export class And<TFieldValues extends FieldValues> extends Data.TaggedClass("and")<{
+  current: Query<TFieldValues>
+  operation: [string, Ops, any] | [string, any] | ((q: Query<TFieldValues>) => QueryWhere<TFieldValues>)
+}> implements QueryWhere<TFieldValues> {
+  readonly [QId]!: any
+}
+
+export class Or<TFieldValues extends FieldValues> extends Data.TaggedClass("or")<{
+  current: Query<TFieldValues>
+  operation: [string, Ops, any] | [string, any] | ((q: Query<TFieldValues>) => QueryWhere<TFieldValues>)
+}> implements QueryWhere<TFieldValues> {
+  readonly [QId]!: any
+}
+
+export class Page<TFieldValues extends FieldValues> extends Data.TaggedClass("page")<{
+  current: Query<TFieldValues> | QueryWhere<TFieldValues> | QueryEnd<TFieldValues>
+  take?: number | undefined
+  skip?: number | undefined
+}> implements QueryEnd<TFieldValues> {
+  readonly [QId]!: any
+}
+
+export class Order<TFieldValues extends FieldValues, TFieldName extends FieldPath<TFieldValues>>
+  extends Data.TaggedClass("order")<{
+    current: Query<TFieldValues> | QueryWhere<TFieldValues> | QueryEnd<TFieldValues>
+    field: TFieldName
+    direction: "ASC" | "DESC"
+  }>
+  implements QueryEnd<TFieldValues>
+{
+  readonly [QId]!: any
+}
+
+export class Project<A, TFieldValues extends FieldValues, R> extends Data.TaggedClass("project")<{
+  current: Query<TFieldValues> | QueryWhere<TFieldValues> | QueryEnd<TFieldValues>
+  schema: S.Schema<A, TFieldValues, R>
+}> implements QueryProjection<TFieldValues, A, R> {
+  readonly [QId]!: any
+}
+
+export const make: <TFieldValues extends FieldValues>() => Query<TFieldValues> = () => new Initial()
+
+export const where: FilterWhere = (...operation: any[]) => (current: any) => new Where({ current, operation } as any)
+
+export const and: FilterContinuation = (...operation: any[]) => (current: any) =>
+  new And({ current, operation: typeof operation[0] === "function" ? operation[0] : operation } as any)
+
+export const or: FilterContinuation = (...operation: any[]) => (current: any) =>
+  new Or({ current, operation: typeof operation[0] === "function" ? operation[0] : operation } as any)
+
+export const order: <TFieldValues extends FieldValues, TFieldName extends FieldPath<TFieldValues>>(
+  field: TFieldName,
+  direction?: "ASC" | "DESC"
+) => (current: Query<TFieldValues> | QueryWhere<TFieldValues> | QueryEnd<TFieldValues>) => QueryEnd<TFieldValues> =
+  (field, direction = "ASC") => (current) => new Order({ current, field, direction })
+
+export const page: <TFieldValues extends FieldValues>(
+  page: { skip?: number; take?: number }
+) => (current: Query<TFieldValues> | QueryWhere<TFieldValues> | QueryEnd<TFieldValues>) => QueryEnd<TFieldValues> =
+  ({ skip, take }) => (current) =>
+    new Page({
+      current,
+      take,
+      skip
+    })
+
+export const project: <TFieldValues extends FieldValues, A = FieldValues, R = never>(
+  schema: S.Schema<A, TFieldValues, R>
+) => (
+  current: Query<TFieldValues> | QueryWhere<TFieldValues> | QueryEnd<TFieldValues>
+) => QueryProjection<TFieldValues, A, R> = (schema) => (current) => new Project({ current, schema })
+
+export type FilterWheres = {
+  <
+    TFieldValues extends FieldValues,
+    TFieldName extends FieldPath<TFieldValues>,
+    V extends FieldPathValue<TFieldValues, TFieldName>
+  >(
+    path: TFieldName,
+    value: V
+  ): (
+    current: Query<TFieldValues>
+  ) => QueryWhere<TFieldValues>
+  <
+    TFieldValues extends FieldValues,
+    TFieldName extends FieldPath<TFieldValues>,
+    V extends FieldPathValue<TFieldValues, TFieldName>
+  >(
+    path: TFieldName,
+    op: "neq",
+    value: V
+  ): (
+    current: Query<TFieldValues>
+  ) => QueryWhere<TFieldValues>
+  <
+    TFieldValues extends FieldValues,
+    TFieldName extends FieldPath<TFieldValues>,
+    V extends FieldPathValue<TFieldValues, TFieldName>
+  >(
+    path: TFieldName,
+    op: "gt" | "gte" | "lt" | "lte",
+    value: V // only numbers?
+  ): (
+    current: Query<TFieldValues>
+  ) => QueryWhere<TFieldValues>
+  <
+    TFieldValues extends FieldValues,
+    TFieldName extends FieldPath<TFieldValues>,
+    V extends FieldPathValue<TFieldValues, TFieldName>
+  >(
+    path: TFieldName,
+    op: "startsWith" | "endsWith" | "contains" | "notContains" | "notStartsWith" | "notEndsWith",
+    value: V // only strings?
+  ): (
+    current: Query<TFieldValues>
+  ) => QueryWhere<TFieldValues>
+  <
+    TFieldValues extends FieldValues,
+    TFieldName extends FieldPath<TFieldValues>,
+    V extends FieldPathValue<TFieldValues, TFieldName>
+  >(
+    path: TFieldName,
+    op: "in" | "notIn",
+    value: readonly V[]
+  ): (
+    current: Query<TFieldValues>
+  ) => QueryWhere<TFieldValues>
+}
+
+export type FilterWhere = {
+  <
+    TFieldValues extends FieldValues,
+    TFieldName extends FieldPath<TFieldValues>,
+    V extends FieldPathValue<TFieldValues, TFieldName>
+  >(f: {
+    path: TFieldName
+    op: Ops
+    value: V
+  }): (
+    current: Query<TFieldValues>
+  ) => QueryWhere<TFieldValues>
+} & FilterWheres
+
+export type FilterContinuations = {
+  <
+    TFieldValues extends FieldValues,
+    TFieldName extends FieldPath<TFieldValues>,
+    V extends FieldPathValue<TFieldValues, TFieldName>
+  >(
+    path: TFieldName,
+    value: V
+  ): (
+    current: QueryWhere<TFieldValues>
+  ) => QueryWhere<TFieldValues>
+  <
+    TFieldValues extends FieldValues,
+    TFieldName extends FieldPath<TFieldValues>,
+    V extends FieldPathValue<TFieldValues, TFieldName>
+  >(
+    path: TFieldName,
+    op: "neq",
+    value: V
+  ): (
+    current: QueryWhere<TFieldValues>
+  ) => QueryWhere<TFieldValues>
+  <
+    TFieldValues extends FieldValues,
+    TFieldName extends FieldPath<TFieldValues>,
+    V extends FieldPathValue<TFieldValues, TFieldName>
+  >(
+    path: TFieldName,
+    op: "gt" | "gte" | "lt" | "lte",
+    value: V // only numbers?
+  ): (
+    current: QueryWhere<TFieldValues>
+  ) => QueryWhere<TFieldValues>
+  <
+    TFieldValues extends FieldValues,
+    TFieldName extends FieldPath<TFieldValues>,
+    V extends FieldPathValue<TFieldValues, TFieldName>
+  >(
+    path: TFieldName,
+    op: "startsWith" | "endsWith" | "contains" | "notContains" | "notStartsWith" | "notEndsWith",
+    value: V // only strings?
+  ): (
+    current: QueryWhere<TFieldValues>
+  ) => QueryWhere<TFieldValues>
+  <
+    TFieldValues extends FieldValues,
+    TFieldName extends FieldPath<TFieldValues>,
+    V extends FieldPathValue<TFieldValues, TFieldName>
+  >(
+    path: TFieldName,
+    op: "in" | "notIn",
+    value: readonly V[]
+  ): (
+    current: QueryWhere<TFieldValues>
+  ) => QueryWhere<TFieldValues>
+}
+
+export type FilterContinuation = {
+  <TFieldValues extends FieldValues>(
+    fb: (
+      current: Query<TFieldValues>
+    ) => QueryWhere<TFieldValues>
+  ): (
+    current: QueryWhere<TFieldValues>
+  ) => QueryWhere<TFieldValues>
+  <
+    TFieldValues extends FieldValues,
+    TFieldName extends FieldPath<TFieldValues>,
+    V extends FieldPathValue<TFieldValues, TFieldName>
+  >(f: {
+    path: TFieldName
+    op: Ops
+    value: V
+  }): (
+    current: QueryWhere<TFieldValues>
+  ) => QueryWhere<TFieldValues>
+} & FilterContinuations

package/src/services/query/new-kid-interpreter.ts

@@ -0,0 +1,143 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+import { toNonEmptyArray } from "@effect-app/core/Array"
+import { Match, Option, pipe, S } from "effect-app"
+import { dropUndefinedT } from "effect-app/utils"
+import type { FieldValues } from "../../filter/types.js"
+import type { FieldPath } from "../../filter/types/path/eager.js"
+import { make, type Q, type QAll } from "../query.js"
+import type { FilterResult, QueryBuilder } from "../Store/filterApi/query.js"
+
+type Result<TFieldValues extends FieldValues, A = TFieldValues, R = never> = {
+  filter: FilterResult[]
+  schema: S.Schema<A, TFieldValues, R> | undefined
+  limit: number | undefined
+  skip: number | undefined
+  order: { key: FieldPath<TFieldValues>; direction: "ASC" | "DESC" }[]
+}
+
+const interpret = <TFieldValues extends FieldValues, A = TFieldValues, R = never>(_: QAll<TFieldValues, A, R>) => {
+  const a = _ as Q<TFieldValues>
+
+  const data: Result<TFieldValues, any, any> = {
+    filter: [],
+    schema: undefined,
+    limit: undefined,
+    skip: undefined,
+    order: []
+  }
+
+  const upd = (
+    v: Result<TFieldValues, any, any>
+  ) => {
+    data.filter.push(...v.filter)
+    data.order.push(...v.order)
+    data.limit = v.limit
+    data.skip = v.skip
+    data.schema = v.schema
+  }
+
+  pipe(
+    a,
+    Match.valueTags({
+      value: () => {
+        // data.filter.push(value)
+      },
+      where: ({ current, operation }) => {
+        upd(interpret(current))
+        data.filter.push(
+          {
+            t: "where",
+            path: operation[0],
+            op: operation.length === 2 ? "eq" : operation[1],
+            value: operation.length === 2 ? operation[1] : operation[2]
+          }
+        )
+      },
+      and: ({ current, operation }) => {
+        upd(interpret(current))
+        if (typeof operation === "function") {
+          data.filter.push(
+            { t: "and-scope", result: interpret(operation(make())).filter }
+          )
+        } else {
+          data.filter.push(
+            {
+              t: "and",
+              path: operation[0],
+              op: operation.length === 2 ? "eq" : operation[1],
+              value: operation.length === 2 ? operation[1] : operation[2]
+            }
+          )
+        }
+      },
+      or: ({ current, operation }) => {
+        upd(interpret(current))
+        if (typeof operation === "function") {
+          data.filter.push(
+            { t: "or-scope", result: interpret(operation(make())).filter }
+          )
+        } else {
+          data.filter.push(
+            {
+              t: "or",
+              path: operation[0],
+              op: operation.length === 2 ? "eq" : operation[1],
+              value: operation.length === 2 ? operation[1] : operation[2]
+            }
+          )
+        }
+      },
+      order: ({ current, direction, field }) => {
+        upd(interpret(current))
+        data.order.push({ key: field, direction })
+      },
+      page: (v) => {
+        upd(interpret(v.current))
+        data.limit = v.take
+        data.skip = v.skip
+      },
+      project: (v) => {
+        upd(interpret(v.current))
+        data.schema = v.schema
+      }
+    })
+  )
+
+  return data
+}
+
+export const toFilter = <
+  TFieldValues extends FieldValues,
+  A,
+  R
+>(
+  q: QAll<TFieldValues, A, R>
+) => {
+  // TODO: Native interpreter for each db adapter, instead of the intermediate "new-kid" format
+  const a = interpret(q)
+  const schema = a.schema
+  let select: (keyof TFieldValues)[] = []
+  if (schema) {
+    let t = schema.ast
+    if (S.AST.isTransform(t)) {
+      t = t.from
+    }
+    if (S.AST.isTypeLiteral(t)) {
+      select = t.propertySignatures.map((_) => _.name) as any
+    }
+  }
+  return dropUndefinedT({
+    limit: a.limit,
+    skip: a.skip,
+    select: Option.getOrUndefined(toNonEmptyArray(select)),
+    schema,
+    order: Option.getOrUndefined(toNonEmptyArray(a.order)),
+    filter: a.filter.length
+      ? {
+        type: "new-kid" as const,
+        build: () => a.filter
+      } as QueryBuilder<any>
+      : undefined
+  })
+}

package/src/services/query.test.ts

@@ -0,0 +1,83 @@
+import { Effect, flow, pipe, S } from "effect-app"
+import { TagClassMakeId } from "effect-app/service"
+import { pick } from "effect-app/utils"
+import { inspect } from "util"
+import { and, make, or, order, page, project, toFilter, where } from "./query.js"
+import { RepositoryDefaultImpl } from "./RepositoryBase.js"
+import { memFilter } from "./Store/Memory.js"
+
+export class s
+  extends S.Class<s>()({ id: S.StringId.withDefault, displayName: S.NonEmptyString255, n: S.Date.withDefault })
+{}
+export declare namespace s {
+  export type From = S.Schema.From<typeof s>
+}
+
+const MakeSomeService = Effect.succeed({ a: 1 })
+export class SomeService extends TagClassMakeId("SomeService", MakeSomeService)<SomeService>() {}
+
+const q = pipe(
+  make<s.From>(), // provided automatically inside Repo.q2()
+  where("displayName", "Verona"),
+  or(flow(
+    where("displayName", "Riley"),
+    and("n", "gt", "2021-01-01T00:00:00Z") // TODO: work with To type translation, so Date?
+  )),
+  order("displayName"),
+  page({ take: 10 }),
+  project(
+    S.transformOrFail(
+      S.struct({ displayName: S.string }), // for projection performance benefit, this should be limited to the fields interested, and leads to SELECT fields
+      S.struct(pick(s.fields, "displayName")),
+      (_) => Effect.andThen(SomeService, _),
+      () => Effect.die(new Error("not implemented"))
+    )
+  )
+)
+
+it("works", () => {
+  console.log("raw", inspect(q, undefined, 25))
+  const interpreted = toFilter(q)
+  console.log("interpreted", inspect(interpreted, undefined, 25))
+  const filtersBuilt = interpreted.filter.build()
+  console.log("filtersBuilt", inspect(filtersBuilt, undefined, 25))
+  const items = [
+    new s({ displayName: S.NonEmptyString255("Verona"), n: new Date("2020-01-01T00:00:00Z") }),
+    new s({ displayName: S.NonEmptyString255("Riley") }),
+    new s({ displayName: S.NonEmptyString255("Riley"), n: new Date("2020-01-01T00:00:00Z") })
+  ]
+    .map((_) => S.encodeSync(s)(_))
+
+  const processed = memFilter(interpreted)(items)
+
+  expect(processed).toEqual(items.slice(0, 2).toReversed().map(({ displayName }) => ({ displayName })))
+})
+
+it.skip("works with repo", () => {
+  class TestRepo extends RepositoryDefaultImpl<TestRepo>()<s.From & { _etag: string | undefined }, never>()(
+    "test",
+    s
+  ) {}
+  const q1 = TestRepo.q2(() => q)
+
+  // same as above, but with the `flow` helper
+  const q2 = TestRepo.q2(flow(
+    where("displayName", "Verona"),
+    or(flow(
+      where("displayName", "Riley"),
+      and("n", "gt", "2021-01-01T00:00:00Z") // TODO: work with To type translation, so Date?
+    )),
+    order("displayName"),
+    page({ take: 10 }),
+    project(
+      S.transformOrFail(
+        S.struct({ displayName: S.string }), // for projection performance benefit, this should be limited to the fields interested, and leads to SELECT fields
+        S.struct(pick(s.fields, "displayName")),
+        (_) => Effect.andThen(SomeService, _),
+        () => Effect.die(new Error("not implemented"))
+      )
+    )
+  ))
+
+  expect([q1, q2]).toEqual([q1, q1])
+})