@effect-app/infra 0.196.3 → 0.196.5

package/dist/services/simpledb/simpledb.d.ts

@@ -17,7 +17,7 @@ export interface RecordCache extends ReturnType<typeof makeLiveRecordCache> {
 }
 export declare const RecordCache: import("effect/Context").Tag<RecordCache, RecordCache>;
 export declare const LiveRecordCache: import("effect/Layer").Layer<RecordCache, never, never>;
-export declare function find<R, RDecode, EDecode, E, EA, A>(tryRead: (id: string) => Effect<Option<CachedRecord<EA>>, E, R>, decode: (d: EA) => Effect<A, EDecode, RDecode>, type: string): (id: string) => import("effect/Effect").Effect<import("effect/Option").Option<A>, InvalidStateError | E, RecordCache | R | RDecode>;
+export declare function find<R, RDecode, EDecode, E, EA, A>(tryRead: (id: string) => Effect<Option<CachedRecord<EA>>, E, R>, decode: (d: EA) => Effect<A, EDecode, RDecode>, type: string): (id: string) => import("effect/Effect").Effect<import("effect/Option").Option<A>, E | InvalidStateError, R | RDecode | RecordCache>;
 export declare function storeDirectly<R, E, TKey extends string, A extends DBRecord<TKey>>(save: (r: A, version: Option<Version>) => Effect<CachedRecord<A>, E, R>, type: string): (record: A) => import("effect/Effect").Effect<A, E, RecordCache | R>;
-export declare function store<R, E, R2, E2, TKey extends string, EA, A extends DBRecord<TKey>>(tryRead: (id: string) => Effect<Option<CachedRecord<EA>>, E, R>, save: (r: A, version: Option<Version>) => Effect<CachedRecord<A>, E, R>, lock: (id: string) => Effect<unknown, E2, R2 | Scope>, type: string): (record: A) => import("effect/Effect").Effect<A, OptimisticLockException | InvalidStateError | E | E2, RecordCache | R | Exclude<R2, import("effect/Scope").Scope>>;
+export declare function store<R, E, R2, E2, TKey extends string, EA, A extends DBRecord<TKey>>(tryRead: (id: string) => Effect<Option<CachedRecord<EA>>, E, R>, save: (r: A, version: Option<Version>) => Effect<CachedRecord<A>, E, R>, lock: (id: string) => Effect<unknown, E2, R2 | Scope>, type: string): (record: A) => import("effect/Effect").Effect<A, E | E2 | InvalidStateError | OptimisticLockException, R | RecordCache | Exclude<R2, import("effect/Scope").Scope>>;
 //# sourceMappingURL=simpledb.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect-app/infra",
-  "version": "0.196.3",
+  "version": "0.196.5",
   "license": "MIT",
   "type": "module",
   "dependencies": {
@@ -18,10 +18,10 @@
     "proper-lockfile": "^4.1.2",
     "pure-rand": "6.0.4",
     "redlock": "^4.2.0",
-    "@effect-app/infra-adapters": "0.133.2",
+    "@effect-app/infra-adapters": "0.133.3",
     "@effect-app/core": "0.146.1",
+    "effect-app": "0.173.3",
     "@effect-app/fluent-extensions": "0.139.0",
-    "effect-app": "0.173.2",
     "@effect-app/schema": "0.197.1"
   },
   "devDependencies": {
@@ -696,6 +696,16 @@
         "default": "./_cjs/services/Store/utils.cjs"
       }
     },
+    "./services/query": {
+      "import": {
+        "types": "./dist/services/query.d.ts",
+        "default": "./dist/services/query.js"
+      },
+      "require": {
+        "types": "./dist/services/query.d.ts",
+        "default": "./_cjs/services/query.cjs"
+      }
+    },
     "./services/simpledb/cosmosdb": {
       "import": {
         "types": "./dist/services/simpledb/cosmosdb.d.ts",

package/src/services/RepositoryBase.ts

@@ -23,6 +23,8 @@ import { makeFilters } from "@effect-app/infra/filter"
 import { Effect, S } from "effect-app"
 import { type FixEnv, runTerm } from "effect-app/Pure"
 import { type InvalidStateError, NotFoundError, type OptimisticConcurrencyException } from "../errors.js"
+import type { FieldValues } from "../filter/types.js"
+import { make as makeQuery, type QAll, type Query, query, type QueryProjection } from "./query.js"
 import { ContextMapContainer } from "./Store/ContextMapContainer.js"
 import * as Q from "./Store/filterApi/query.js"
 
@@ -88,6 +90,19 @@ export abstract class RepositoryBaseC<
   ) => Effect<void>
 
   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: 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>
+  }
 }
 
 export abstract class RepositoryBaseC1<
@@ -121,6 +136,7 @@ export class RepositoryBaseC2<
     this.utils = this.impl.utils
     this.changeFeed = this.impl.changeFeed
     this.mapped = this.impl.mapped
+    this.q2 = this.impl.q2
   }
   // makes super calls a compiler error, as it should
   override saveAndPublish
@@ -130,6 +146,7 @@ export class RepositoryBaseC2<
   override utils
   override changeFeed
   override mapped
+  override q2
 }
 
 const anyQb = Q.QueryBuilder.make<any>()
@@ -782,7 +799,8 @@ export function makeRepo<
           find,
           all,
           saveAndPublish,
-          removeAndPublish
+          removeAndPublish,
+          q2: (q: any) => query(r, typeof q === "function" ? q(makeQuery()) : q) as any
         }
         return r
       })
@@ -970,26 +988,27 @@ export interface RepoFunctions<T extends { id: unknown }, PM extends { id: strin
   save: (...items: T[]) => Effect<void, InvalidStateError | OptimisticConcurrencyException, Service>
   get: (id: T["id"]) => Effect<T, NotFoundError<ItemType>, Service>
 
-  query: (b: (fn: Q.FilterTest<PM>, fields: Q.Filter<PM, never>) => Q.QueryBuilder<PM>) => Effect<T[], never, never>
+  query: (b: (fn: Q.FilterTest<PM>, fields: Q.Filter<PM, never>) => Q.QueryBuilder<PM>) => Effect<T[], never, Service>
   queryLegacy: <S = T>(map: {
     filter?: Filter<PM>
     collect?: (t: T) => Option<S>
     limit?: number
     skip?: number
-  }) => Effect<S[], never, never>
+  }) => Effect<S[], never, Service>
 
   mapped: MM<Service, PM, Omit<PM, "_etag">>
 }
 
 const makeRepoFunctions = (tag: any) => {
   const { all } = Effect.serviceConstants(tag) as any
-  const { find, get, query, queryLegacy, removeAndPublish, removeById, save, saveAndPublish } = Effect.serviceFunctions(
-    tag
-  ) as any
+  const { find, get, q2, query, queryLegacy, removeAndPublish, removeById, save, saveAndPublish } = Effect
+    .serviceFunctions(
+      tag
+    ) as any
 
   const mapped = (s: any) => tag.map((_: any) => _.mapped(s))
 
-  return { all, find, removeById, saveAndPublish, removeAndPublish, save, get, query, queryLegacy, mapped }
+  return { all, find, removeById, saveAndPublish, removeAndPublish, save, get, query, queryLegacy, q2, mapped }
 }
 
 export const RepositoryBaseImpl = <Service>() => {

package/src/services/query.ts

@@ -0,0 +1,458 @@
+/* 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 { Repository } from "@effect-app/infra/services/Repository"
+import type { PersistenceModelType } from "@effect-app/infra/services/Store"
+import type { Ops } from "@effect-app/infra/services/Store/filterApi/proxy"
+import type { FilterResult, QueryBuilder } from "@effect-app/infra/services/Store/filterApi/query"
+import { Data, Effect, Match, pipe, S, Unify } from "effect-app"
+import type { NoInfer } from "effect/Types"
+
+export type QAll<TFieldValues extends FieldValues, A = TFieldValues, R = never> =
+  | Query<TFieldValues>
+  | QueryWhere<TFieldValues>
+  | QueryEnd<TFieldValues>
+  | QueryProjection<TFieldValues, A, R>
+
+export interface Query<TFieldValues extends FieldValues> {
+  readonly args: { TFieldValues: TFieldValues }
+  readonly _id: unique symbol
+}
+export interface QueryWhere<TFieldValues extends FieldValues> extends Query<TFieldValues> {
+  readonly args: { TFieldValues: TFieldValues }
+  readonly _id2: unique symbol
+}
+
+export interface QueryEnd<TFieldValues extends FieldValues> {
+  readonly args: { TFieldValues: TFieldValues }
+  readonly _id3: unique symbol
+}
+
+export interface QueryProjection<TFieldValues extends FieldValues, A = TFieldValues, R = never> {
+  readonly args: { TFieldValues: TFieldValues; A: A; R: R }
+  readonly _id4: unique symbol
+}
+
+// Impl, later
+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 _id: any
+  readonly args: 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> {
+  _id2!: any
+  _id: any
+  readonly args: 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> {
+  _id2!: any
+  _id: any
+  readonly args: 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> {
+  _id2!: any
+  _id: any
+  readonly args: any
+}
+
+export class Page<TFieldValues extends FieldValues> extends Data.TaggedClass("page")<{
+  current: Query<TFieldValues> | QueryEnd<TFieldValues>
+  limit?: number | undefined
+  skip?: number | undefined
+}> implements QueryEnd<TFieldValues> {
+  _id3!: any
+  readonly args: any
+}
+
+export class Order<TFieldValues extends FieldValues, TFieldName extends FieldPath<TFieldValues>>
+  extends Data.TaggedClass("order")<{
+    current: Query<TFieldValues> | QueryEnd<TFieldValues>
+    field: TFieldName
+    desc?: boolean | undefined
+  }>
+  implements QueryEnd<TFieldValues>
+{
+  _id3!: any
+  readonly args: any
+}
+
+export class Project<A, TFieldValues extends FieldValues, R> extends Data.TaggedClass("project")<{
+  current: Query<TFieldValues> | QueryEnd<TFieldValues>
+  schema: S.Schema<A, TFieldValues, R>
+}> implements QueryProjection<TFieldValues, A, R> {
+  _id4!: any
+  readonly args: any
+}
+
+const wh: any = (...operation: any[]) => (current: any[]) => new Where({ current, operation } as any)
+export const where: FilterWhere = wh
+
+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,
+  desc?: boolean
+) => (current: Query<TFieldValues> | QueryEnd<TFieldValues>) => QueryEnd<TFieldValues> = (field, desc) => (current) =>
+  new Order({ current, field, desc })
+
+export const page: <TFieldValues extends FieldValues>(
+  page: { limit?: number; skip?: number }
+) => (current: Query<TFieldValues> | QueryEnd<TFieldValues>) => QueryEnd<TFieldValues> =
+  ({ limit, skip }) => (current) =>
+    new Page({
+      current,
+      limit,
+      skip
+    })
+
+export const project: <TFieldValues extends FieldValues, A, R>(
+  schema: S.Schema<A, TFieldValues, R>
+  // TODO: should be able to use a subset of FieldValues and use select
+) => (current: Query<TFieldValues> | QueryEnd<TFieldValues>) => QueryProjection<TFieldValues, A, R> =
+  (schema) => (current) => new Project({ current, schema })
+
+// TODO: able to switch to Order and Limit/Take, which are "enders"
+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
+
+export const make: <TFieldValues extends FieldValues>() => Query<TFieldValues> = () => new Initial()
+export interface A {
+  a: string
+  b: number
+  c: boolean
+}
+
+const interpret = <TFieldValues extends FieldValues, A = TFieldValues, R = never>(_: QAll<TFieldValues, A, R>) => {
+  const values: FilterResult[] = []
+  const a = _ as Q<TFieldValues>
+
+  let schema: S.Schema<A, TFieldValues, R> | undefined = undefined as any
+  let limit: number | undefined = undefined as any
+  let skip: number | undefined = undefined as any
+
+  const upd = (v: { schema: any; limit: any; skip: any; filter: readonly FilterResult[] }) => {
+    values.push(...v.filter)
+    limit = v.limit
+    skip = v.skip
+    schema = v.schema
+  }
+
+  pipe(
+    a,
+    Match.valueTags({
+      value: () => {
+        // values.push(value)
+      },
+      where: ({ current, operation }) => {
+        upd(interpret(current))
+        values.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") {
+          values.push(
+            { t: "and-scope", result: interpret(operation(make())).filter }
+          )
+        } else {
+          values.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") {
+          values.push(
+            { t: "or-scope", result: interpret(operation(make())).filter }
+          )
+        } else {
+          values.push(
+            {
+              t: "or",
+              path: operation[0],
+              op: operation.length === 2 ? "eq" : operation[1],
+              value: operation.length === 2 ? operation[1] : operation[2]
+            }
+          )
+        }
+      },
+      order: ({ current }) => {
+        upd(interpret(current))
+        console.log("missing order implementation")
+      },
+      page: (v) => {
+        upd(interpret(v.current))
+        limit = v.limit
+        skip = v.skip
+      },
+      project: (v) => {
+        upd(interpret(v.current))
+        schema = v.schema
+      }
+    })
+  )
+
+  // TODO
+  return {
+    filter: values,
+    limit,
+    skip,
+    schema
+  }
+}
+
+export 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 T[], 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>) => {
+  // 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 PM)[] = []
+  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 pipe(
+    a.filter.length === 0
+      ? repo.utils.all
+      : repo.utils.filter({
+        limit: a.limit,
+        skip: a.skip,
+        select: select.toNonEmpty.value ?? undefined,
+        filter: a.filter.length
+          ? {
+            type: "new-kid" as const,
+            build: () => a.filter
+          } as any as QueryBuilder<any>
+          : undefined
+      }),
+    Effect.flatMap((_) =>
+      Unify.unify(
+        schema
+          ? repo.utils.parseMany2(_, schema as any)
+          : repo.utils.parseMany(_)
+      )
+    )
+  )
+}) as any