@effect-app/infra 0.223.1 → 0.224.0

package/src/services/query/dsl.ts

@@ -5,10 +5,12 @@ 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 { NonNegativeInt } from "@effect-app/schema"
-import type { Option, S } from "effect-app"
-import { Data } from "effect-app"
+import type { Option, Pipeable, S } from "effect-app"
+import { Data, flow } from "effect-app"
 import type { Covariant } from "effect/Types"
 
+import { pipeArguments } from "effect/Pipeable"
+
 export type QAll<TFieldValues extends FieldValues, A = TFieldValues, R = never, TType extends "one" | "many" = "many"> =
   | Query<TFieldValues>
   | QueryWhere<TFieldValues>
@@ -24,7 +26,7 @@ export interface QueryTogether<
   out A = TFieldValues,
   out R = never,
   out TType extends "many" | "one" | "count" = "many"
-> {
+> extends Pipeable.Pipeable {
   readonly [QId]: {
     readonly _TFieldValues: Covariant<TFieldValues>
     readonly _T: Covariant<T>
@@ -75,6 +77,10 @@ export class Initial<TFieldValues extends FieldValues> extends Data.TaggedClass(
   constructor() {
     super({ value: "initial" as const })
   }
+  pipe() {
+    // eslint-disable-next-line prefer-rest-params
+    return pipeArguments(this, arguments)
+  }
 }
 
 export class Where<TFieldValues extends FieldValues> extends Data.TaggedClass("where")<{
@@ -82,6 +88,11 @@ export class Where<TFieldValues extends FieldValues> extends Data.TaggedClass("w
   operation: [string, Ops, any] | [string, any]
 }> implements QueryWhere<TFieldValues> {
   readonly [QId]!: any
+
+  pipe() {
+    // eslint-disable-next-line prefer-rest-params
+    return pipeArguments(this, arguments)
+  }
 }
 
 export class And<TFieldValues extends FieldValues> extends Data.TaggedClass("and")<{
@@ -89,6 +100,10 @@ export class And<TFieldValues extends FieldValues> extends Data.TaggedClass("and
   operation: [string, Ops, any] | [string, any] | ((q: Query<TFieldValues>) => QueryWhere<TFieldValues>)
 }> implements QueryWhere<TFieldValues> {
   readonly [QId]!: any
+  pipe() {
+    // eslint-disable-next-line prefer-rest-params
+    return pipeArguments(this, arguments)
+  }
 }
 
 export class Or<TFieldValues extends FieldValues> extends Data.TaggedClass("or")<{
@@ -96,6 +111,10 @@ export class Or<TFieldValues extends FieldValues> extends Data.TaggedClass("or")
   operation: [string, Ops, any] | [string, any] | ((q: Query<TFieldValues>) => QueryWhere<TFieldValues>)
 }> implements QueryWhere<TFieldValues> {
   readonly [QId]!: any
+  pipe() {
+    // eslint-disable-next-line prefer-rest-params
+    return pipeArguments(this, arguments)
+  }
 }
 
 export class Page<TFieldValues extends FieldValues> extends Data.TaggedClass("page")<{
@@ -104,18 +123,30 @@ export class Page<TFieldValues extends FieldValues> extends Data.TaggedClass("pa
   skip?: number | undefined
 }> implements QueryEnd<TFieldValues> {
   readonly [QId]!: any
+  pipe() {
+    // eslint-disable-next-line prefer-rest-params
+    return pipeArguments(this, arguments)
+  }
 }
 
 export class One<TFieldValues extends FieldValues> extends Data.TaggedClass("one")<{
   current: Query<TFieldValues> | QueryWhere<TFieldValues> | QueryEnd<TFieldValues>
 }> implements QueryEnd<TFieldValues, "one"> {
   readonly [QId]!: any
+  pipe() {
+    // eslint-disable-next-line prefer-rest-params
+    return pipeArguments(this, arguments)
+  }
 }
 
 export class Count<TFieldValues extends FieldValues> extends Data.TaggedClass("count")<{
   current: Query<TFieldValues> | QueryWhere<TFieldValues> | QueryEnd<TFieldValues>
 }> implements QueryEnd<TFieldValues, "count"> {
   readonly [QId]!: any
+  pipe() {
+    // eslint-disable-next-line prefer-rest-params
+    return pipeArguments(this, arguments)
+  }
 }
 
 export class Order<TFieldValues extends FieldValues, TFieldName extends FieldPath<TFieldValues>>
@@ -127,6 +158,10 @@ export class Order<TFieldValues extends FieldValues, TFieldName extends FieldPat
   implements QueryEnd<TFieldValues>
 {
   readonly [QId]!: any
+  pipe() {
+    // eslint-disable-next-line prefer-rest-params
+    return pipeArguments(this, arguments)
+  }
 }
 
 export class Project<A, TFieldValues extends FieldValues, R, TType extends "one" | "many" = "many">
@@ -138,6 +173,10 @@ export class Project<A, TFieldValues extends FieldValues, R, TType extends "one"
   implements QueryProjection<TFieldValues, A, R>
 {
   readonly [QId]!: any
+  pipe() {
+    // eslint-disable-next-line prefer-rest-params
+    return pipeArguments(this, arguments)
+  }
 }
 
 export const make: <TFieldValues extends FieldValues>() => Query<TFieldValues> = () => new Initial()
@@ -145,10 +184,10 @@ export const make: <TFieldValues extends FieldValues>() => Query<TFieldValues> =
 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)
+  new And({ current, operation: typeof operation[0] === "function" ? flow(...operation as [any]) : operation } as any)
 
 export const or: FilterContinuation = (...operation: any[]) => (current: any) =>
-  new Or({ current, operation: typeof operation[0] === "function" ? operation[0] : operation } as any)
+  new Or({ current, operation: typeof operation[0] === "function" ? flow(...operation as [any]) : operation } as any)
 
 export const order: <TFieldValues extends FieldValues, TFieldName extends FieldPath<TFieldValues>>(
   field: TFieldName,
@@ -308,24 +347,25 @@ export type FilterContinuations = {
   ): (
     current: QueryWhere<TFieldValues>
   ) => QueryWhere<TFieldValues>
+  // breaks flow pipe type inference
+  // <
+  //   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: "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",
+    op: "gt" | "gte" | "lt" | "lte" | "neq",
     value: V // only numbers?
   ): (
     current: QueryWhere<TFieldValues>
@@ -354,23 +394,135 @@ export type FilterContinuations = {
   ) => QueryWhere<TFieldValues>
 }
 
-export type FilterContinuation = {
+export type FilterContinuationClosure = {
+  <TFieldValues extends FieldValues>(
+    fb: (current: Query<TFieldValues>) => QueryWhere<TFieldValues>
+  ): (current: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>
+
+  <TFieldValues extends FieldValues>(
+    fb: (current: Query<TFieldValues>) => QueryWhere<TFieldValues>,
+    fc: (query: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>
+  ): (current: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>
+
+  <TFieldValues extends FieldValues>(
+    fb: (current: Query<TFieldValues>) => QueryWhere<TFieldValues>,
+    fc: (query: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>,
+    fd: (query: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>
+  ): (current: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>
+
+  <TFieldValues extends FieldValues>(
+    fb: (current: Query<TFieldValues>) => QueryWhere<TFieldValues>,
+    fc: (query: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>,
+    fd: (query: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>,
+    fe: (query: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>
+  ): (current: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>
+
+  <TFieldValues extends FieldValues>(
+    fb: (current: Query<TFieldValues>) => QueryWhere<TFieldValues>,
+    fc: (query: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>,
+    fd: (query: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>,
+    fe: (query: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>,
+    ff: (query: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>
+  ): (current: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>
+  <TFieldValues extends FieldValues>(
+    fb: (current: Query<TFieldValues>) => QueryWhere<TFieldValues>,
+    fc: (query: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>,
+    fd: (query: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>,
+    fe: (query: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>,
+    fg: (query: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>
+  ): (current: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>
+  <TFieldValues extends FieldValues>(
+    fb: (current: Query<TFieldValues>) => QueryWhere<TFieldValues>,
+    fc: (query: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>,
+    fd: (query: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>,
+    fe: (query: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>,
+    fg: (query: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>,
+    fh: (query: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>
+  ): (current: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>
+  <TFieldValues extends FieldValues>(
+    fb: (current: Query<TFieldValues>) => QueryWhere<TFieldValues>,
+    fc: (query: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>,
+    fd: (query: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>,
+    fe: (query: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>,
+    fg: (query: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>,
+    fh: (query: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>,
+    fi: (query: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>
+  ): (current: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>
   <TFieldValues extends FieldValues>(
-    fb: (
-      current: Query<TFieldValues>
+    fb: (current: Query<TFieldValues>) => QueryWhere<TFieldValues>,
+    fc: (query: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>,
+    fd: (query: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>,
+    fe: (query: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>,
+    fg: (query: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>,
+    fh: (query: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>,
+    fi: (query: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>,
+    fj: (query: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>
+  ): (current: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>
+  <TFieldValues extends FieldValues>(
+    fb: (current: Query<TFieldValues>) => QueryWhere<TFieldValues>,
+    fc: (query: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>,
+    fd: (query: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>,
+    fe: (query: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>,
+    fg: (query: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>,
+    fh: (query: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>,
+    fi: (query: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>,
+    fj: (query: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>,
+    fk: (query: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>
+  ): (current: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>
+  <TFieldValues extends FieldValues>(
+    fb: (current: Query<TFieldValues>) => QueryWhere<TFieldValues>,
+    fc: (query: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>,
+    fd: (query: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>,
+    fe: (query: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>,
+    fg: (query: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>,
+    fh: (query: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>,
+    fi: (query: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>,
+    fj: (query: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>,
+    fk: (query: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>,
+    fl: (query: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>
+  ): (current: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>
+  <TFieldValues extends FieldValues>(
+    fb: (current: Query<TFieldValues>) => QueryWhere<TFieldValues>,
+    fc: (query: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>,
+    fd: (query: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>,
+    fe: (query: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>,
+    fg: (query: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>,
+    fh: (query: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>,
+    fi: (query: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>,
+    fj: (query: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>,
+    fk: (query: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>,
+    fl: (query: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>,
+    fm: (query: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>
+  ): (current: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>
+  <TFieldValues extends FieldValues>(
+    fb: (current: Query<TFieldValues>) => QueryWhere<TFieldValues>,
+    fc: (query: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>,
+    fd: (query: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>,
+    fe: (query: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>,
+    fg: (query: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>,
+    fh: (query: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>,
+    fi: (query: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>,
+    fj: (query: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>,
+    fk: (query: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>,
+    fl: (query: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>,
+    fm: (query: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>,
+    fn: (query: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>
+  ): (current: QueryWhere<TFieldValues>) => QueryWhere<TFieldValues>
+}
+
+export type FilterContinuation =
+  & FilterContinuationClosure
+  & {
+    <
+      TFieldValues extends FieldValues,
+      TFieldName extends FieldPath<TFieldValues>,
+      V extends FieldPathValue<TFieldValues, TFieldName>
+    >(f: {
+      path: TFieldName
+      op: Ops
+      value: V
+    }): (
+      current: QueryWhere<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
+  }
+  & FilterContinuations

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

@@ -1 +1 @@
-{"version":3,"file":"query.test.d.ts","sourceRoot":"","sources":["../query.test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAQ,KAAK,EAAgB,CAAC,EAAE,MAAM,YAAY,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAcjE,qBAAa,CAAE,SAAQ,MAKrB;CAAG;AACL,MAAM,CAAC,OAAO,WAAW,CAAC,CAAC;IACzB,KAAY,IAAI,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAA;CAC9C;;;;;;;;;;;;;;;;;;;;;;;;;AAGD,qBAAa,WAAY,SAAQ,gBAA6D;CAAG"}
+{"version":3,"file":"query.test.d.ts","sourceRoot":"","sources":["../query.test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAQ,KAAK,EAAgB,CAAC,EAAU,MAAM,YAAY,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAazE,qBAAa,SAAU,SAAQ,cAK7B;CAAG;AACL,MAAM,CAAC,OAAO,WAAW,SAAS,CAAC;IACjC,UAAiB,OAAQ,SAAQ,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,SAAS,CAAC;KAAG;CACvE;;;;;;;;;;;;;;;;;;;;;;;;;AAGD,qBAAa,WAAY,SAAQ,gBAA6D;CAAG"}

package/test/query.test.ts

@@ -1,6 +1,5 @@
-import { Effect, flow, Layer, Option, pipe, S } from "effect-app"
+import { Effect, flow, Layer, Option, pipe, S, Struct } from "effect-app"
 import { TagClassMakeId } from "effect-app/service"
-import { pick } from "effect-app/utils"
 import { inspect } from "util"
 import { expect, it } from "vitest"
 import { and, make, one, or, order, page, project, toFilter, where } from "../src/services/query.js"
@@ -12,48 +11,71 @@ const str = S.struct({ _tag: S.literal("string"), value: S.string })
 const num = S.struct({ _tag: S.literal("number"), value: S.number })
 const someUnion = S.union(str, num)
 
-export class s extends S.Class<s>()({
+export class Something extends S.Class<Something>()({
   id: S.StringId.withDefault,
   displayName: S.NonEmptyString255,
   n: S.Date.withDefault,
   union: someUnion.pipe(S.withDefaultConstructor(() => ({ _tag: "string" as const, value: "hi" })))
 }) {}
-export declare namespace s {
-  export type From = S.Schema.Encoded<typeof s>
+export declare namespace Something {
+  export interface Encoded extends S.Schema.Encoded<typeof Something> {}
 }
 
 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({ id: S.StringId, 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, "id", "displayName")),
-      (_) => Effect.andThen(SomeService, _),
-      () => Effect.die(new Error("not implemented"))
+const q = make<Something.Encoded>()
+  .pipe( // provided automatically inside Repo.q2()
+    where("displayName", "Verona"),
+    or(
+      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.transformToOrFail(
+        S.struct({ id: S.StringId, displayName: S.string }), // for projection performance benefit, this should be limited to the fields interested, and leads to SELECT fields
+        S.struct(Struct.pick(Something.fields, "id", "displayName")),
+        (_) => Effect.andThen(SomeService, _)
+      )
     )
   )
-)
 
 const items = [
-  new s({ displayName: S.NonEmptyString255("Verona"), n: new Date("2020-01-01T00:00:00Z") }),
-  new s({ displayName: S.NonEmptyString255("Riley") }),
-  new s({
+  new Something({ displayName: S.NonEmptyString255("Verona"), n: new Date("2020-01-01T00:00:00Z") }),
+  new Something({ displayName: S.NonEmptyString255("Riley") }),
+  new Something({
     displayName: S.NonEmptyString255("Riley"),
     n: new Date("2020-01-01T00:00:00Z"),
     union: { _tag: "number", value: 1 }
   })
 ]
 
+// TODO: .merge queries?
+// where(x, y).or(a, b) + where(z, v) = (where(x, y) or(a,b)) and where(z, v)) ?
+
+it("merge", () => {
+  const a = make().pipe(where("a", "b"), or("c", "d"))
+  const b = make().pipe(where("d", "e"), or("f", "g"))
+
+  const merge = (b: any) => (a: any) => pipe(a, and(() => b))
+
+  const r = pipe(a, merge(b), toFilter, (_) => _.filter.build())
+
+  // TODO: instead this should probably scope the first where/or together e.g (where x, or y) and (...)
+  const expected = make().pipe(
+    where("a", "b"),
+    or("c", "d"),
+    and(where("d", "e"), or("f", "g")),
+    toFilter,
+    (_) => _.filter.build()
+  )
+
+  console.log(JSON.stringify({ r, expected }, undefined, 2))
+  expect(r).toEqual(expected)
+})
+
 it("works", () => {
   console.log("raw", inspect(q, undefined, 25))
   const interpreted = toFilter(q)
@@ -62,16 +84,16 @@ it("works", () => {
   console
     .log("filtersBuilt", inspect(filtersBuilt, undefined, 25))
 
-  const processed = memFilter(interpreted)(items.map((_) => S.encodeSync(s)(_)))
+  const processed = memFilter(interpreted)(items.map((_) => S.encodeSync(Something)(_)))
 
-  expect(processed).toEqual(items.slice(0, 2).toReversed().map((_) => pick(_, "id", "displayName")))
+  expect(processed).toEqual(items.slice(0, 2).toReversed().map(Struct.pick("id", "displayName")))
 })
 
-class TestRepo extends RepositoryDefaultImpl<TestRepo>()(
+class SomethingRepo extends RepositoryDefaultImpl<SomethingRepo>()(
   "test",
-  s
+  Something
 ) {
-  static readonly Test = Layer.effect(TestRepo, TestRepo.makeWith({}, (_) => new TestRepo(_))).pipe(
+  static readonly Test = Layer.effect(SomethingRepo, SomethingRepo.makeWith({}, (_) => new SomethingRepo(_))).pipe(
     Layer.provide(Layer.merge(MemoryStoreLive, ContextMapContainer.live))
   )
 }
@@ -79,50 +101,49 @@ class TestRepo extends RepositoryDefaultImpl<TestRepo>()(
 it("works with repo", () =>
   Effect
     .gen(function*($) {
-      yield* $(TestRepo.saveAndPublish(items))
+      yield* $(SomethingRepo.saveAndPublish(items))
 
-      const q1 = yield* $(TestRepo.query(() => q))
+      const q1 = yield* $(SomethingRepo.query(() => q))
       // same as above, but with the `flow` helper
       const q2 = yield* $(
-        TestRepo
+        SomethingRepo
           .query(flow(
             where("displayName", "Verona"),
-            or(flow(
+            or(
               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.transformToOrFail(
                 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"))
+                S.struct(Struct.pick(Something.fields, "displayName")),
+                (_) => Effect.andThen(SomeService, _)
               )
             )
           ))
       )
-      expect(q1).toEqual(items.slice(0, 2).toReversed().map((_) => pick(_, "id", "displayName")))
-      expect(q2).toEqual(items.slice(0, 2).toReversed().map((_) => pick(_, "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(TestRepo.Test, SomeService.toLayer())), Effect.runPromise))
+    .pipe(Effect.provide(Layer.mergeAll(SomethingRepo.Test, SomeService.toLayer())), Effect.runPromise))
 
 it("collect", () =>
   Effect
     .gen(function*($) {
-      yield* $(TestRepo.saveAndPublish(items))
+      yield* $(SomethingRepo.saveAndPublish(items))
 
       expect(
         yield* $(
-          TestRepo
+          SomethingRepo
             .query(flow(
               where("displayName", "Riley"), // TODO: work with To type translation, so Date?
               // one,
               project(
                 S.transformTo(
                   // TODO: sample case with narrowing down a union?
-                  S.encodedSchema(S.struct(pick(s.fields, "displayName", "n"))), // for projection performance benefit, this should be limited to the fields interested, and leads to SELECT fields
+                  S.encodedSchema(S.struct(Struct.pick(Something.fields, "displayName", "n"))), // for projection performance benefit, this should be limited to the fields interested, and leads to SELECT fields
                   S.typeSchema(S.option(S.string)),
                   (_) =>
                     _.displayName === "Riley" && _.n === "2020-01-01T00:00:00.000Z"
@@ -138,14 +159,14 @@ it("collect", () =>
 
       expect(
         yield* $(
-          TestRepo
+          SomethingRepo
             .query(flow(
               where("union._tag", "string"),
               one,
               project(
                 S.transformTo(
                   // TODO: sample case with narrowing down a union?
-                  S.encodedSchema(S.struct(pick(s.fields, "union"))), // for projection performance benefit, this should be limited to the fields interested, and leads to SELECT fields
+                  S.encodedSchema(S.struct(Struct.pick(Something.fields, "union"))), // for projection performance benefit, this should be limited to the fields interested, and leads to SELECT fields
                   S.typeSchema(S.option(S.string)),
                   (_) =>
                     _.union._tag === "string"
@@ -159,4 +180,4 @@ it("collect", () =>
       )
         .toEqual("hi")
     })
-    .pipe(Effect.provide(Layer.mergeAll(TestRepo.Test, SomeService.toLayer())), Effect.runPromise))
+    .pipe(Effect.provide(Layer.mergeAll(SomethingRepo.Test, SomeService.toLayer())), Effect.runPromise))