effect-app 4.0.0-beta.25 → 4.0.0-beta.250

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

@@ -0,0 +1,484 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+import { identity, pipe } from "effect/Function"
+import * as Match from "effect/Match"
+import * as SchemaAST from "effect/SchemaAST"
+import * as Array from "../../Array.js"
+import { toNonEmptyArray } from "../../Array.js"
+import * as Option from "../../Option.js"
+import * as S from "../../Schema.js"
+import { dropUndefinedT } from "../../utils.js"
+import type { FilterResult } from "../filter/filterApi.js"
+import type { FieldValues } from "../filter/types.js"
+import type { FieldPath } from "../filter/types/path/eager.js"
+import { make, type Q, type QAll } from "../query/dsl.js"
+
+export type AggregateIrExpression =
+  | { readonly _tag: "agg-count" }
+  | { readonly _tag: "agg-count-when"; readonly filter: readonly FilterResult[] }
+  | { readonly _tag: "agg-sum"; readonly field: string }
+  | { readonly _tag: "agg-min"; readonly field: string }
+  | { readonly _tag: "agg-max"; readonly field: string }
+
+export type AggregateIrItem =
+  | AggregateIrExpression
+  | { readonly _tag: "agg-field"; readonly path: string }
+
+export type ComputedProjectionMathIrExpression =
+  | {
+    readonly _tag: "field"
+    readonly field: string
+  }
+  | {
+    readonly _tag: "mul"
+    readonly left: ComputedProjectionMathIrExpression
+    readonly right: ComputedProjectionMathIrExpression
+  }
+
+export type ComputedProjectionIrExpression =
+  | {
+    readonly _tag: "relation-count"
+    readonly path: string
+    readonly filter: readonly FilterResult[]
+  }
+  | {
+    readonly _tag: "relation-any"
+    readonly path: string
+    readonly filter: readonly FilterResult[]
+  }
+  | {
+    readonly _tag: "relation-every"
+    readonly path: string
+    readonly filter: readonly FilterResult[]
+  }
+  | {
+    readonly _tag: "relation-distinct-count"
+    readonly path: string
+    readonly field: string
+    readonly filter: readonly FilterResult[]
+  }
+  | {
+    readonly _tag: "relation-sum"
+    readonly path: string
+    readonly field: string
+    readonly filter: readonly FilterResult[]
+  }
+  | {
+    readonly _tag: "relation-sum-expr"
+    readonly path: string
+    readonly expression: ComputedProjectionMathIrExpression
+    readonly filter: readonly FilterResult[]
+  }
+  | {
+    readonly _tag: "relation-sum-expr-by"
+    readonly path: string
+    readonly expression: ComputedProjectionMathIrExpression
+    readonly unit: string
+    readonly filter: readonly FilterResult[]
+  }
+  | {
+    readonly _tag: "relation-sum-expr-normalized"
+    readonly path: string
+    readonly expression: ComputedProjectionMathIrExpression
+    readonly unit: string
+    readonly toBase: string
+    readonly factors: Readonly<Record<string, number>>
+    readonly filter: readonly FilterResult[]
+  }
+  | {
+    readonly _tag: "relation-collect"
+    readonly path: string
+    readonly field: string
+    readonly distinct: boolean
+    readonly filter: readonly FilterResult[]
+  }
+  | {
+    readonly _tag: "relation-collect-fields"
+    readonly path: string
+    readonly fields: readonly string[]
+    readonly distinct: boolean
+    readonly filter: readonly FilterResult[]
+  }
+  | {
+    readonly _tag: "relation-length"
+    readonly path: string
+  }
+
+type Result<TFieldValues extends FieldValues, A = TFieldValues, R = never> = {
+  filter: FilterResult[]
+  schema: S.Codec<A, TFieldValues, R> | undefined
+  limit: number | undefined
+  skip: number | undefined
+  order: { key: FieldPath<TFieldValues>; direction: "ASC" | "DESC" }[]
+  ttype: "one" | "many" | "count" | undefined
+  mode: "collect" | "project" | "transform" | "aggregate" | undefined
+  computed: Record<string, ComputedProjectionIrExpression> | undefined
+  aggregateMap: Record<string, AggregateIrItem> | undefined
+}
+
+const interpret = <
+  TFieldValues extends FieldValues,
+  TFieldValuesRefined extends TFieldValues = TFieldValues,
+  A = TFieldValues,
+  R = never
+>(_: QAll<TFieldValues, TFieldValuesRefined, A, R>) => {
+  const a = _ as Q<TFieldValues>
+
+  const data: Result<TFieldValues, any, any> = {
+    filter: [],
+    schema: undefined,
+    limit: undefined,
+    skip: undefined,
+    order: [],
+    ttype: undefined,
+    mode: undefined,
+    computed: undefined,
+    aggregateMap: undefined
+  }
+
+  const upd = (
+    v: Result<TFieldValues, any, any>
+  ) => {
+    data.filter.push(...v.filter)
+    data.order.push(...v.order)
+    if (v.limit !== undefined) data.limit = v.limit
+    if (v.skip !== undefined) data.skip = v.skip
+    if (v.ttype !== undefined) data.ttype = v.ttype
+    if (v.schema !== undefined) data.schema = v.schema
+    if (v.mode !== undefined) data.mode = v.mode
+    if (v.computed !== undefined) data.computed = v.computed
+    if (v.aggregateMap !== undefined) data.aggregateMap = v.aggregateMap
+  }
+
+  const applyPath = (path: string) => (_: FilterResult): FilterResult =>
+    _.t === "where" || _.t === "and" || _.t === "or"
+      ? { ..._, path: `${path}.-1.${_.path}` }
+      : { ..._, result: _.result.map(applyPath(path)) }
+
+  pipe(
+    a,
+    Match.valueTags({
+      value: () => {
+        // data.filter.push(value)
+      },
+      where: ({ current, operation, relation, subPath }) => {
+        upd(interpret(current))
+        if (typeof operation === "function") {
+          data.filter.push(
+            {
+              t: "where-scope",
+              result: interpret(operation(make())).filter.map(subPath ? applyPath(subPath) : identity),
+              relation
+            }
+          )
+        } else {
+          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, relation }) => {
+        upd(interpret(current))
+        if (typeof operation === "function") {
+          data.filter.push(
+            { t: "and-scope", result: interpret(operation(make())).filter, relation }
+          )
+        } 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, relation }) => {
+        upd(interpret(current))
+        if (typeof operation === "function") {
+          data.filter.push(
+            { t: "or-scope", result: interpret(operation(make())).filter, relation }
+          )
+        } else {
+          data.filter.push(
+            {
+              t: "or",
+              path: operation[0],
+              op: operation.length === 2 ? "eq" : operation[1],
+              value: operation.length === 2 ? operation[1] : operation[2]
+            }
+          )
+        }
+      },
+      one: ({ current }) => {
+        upd(interpret(current))
+        data.limit = 1
+        data.ttype = "one"
+      },
+      count: ({ current }) => {
+        upd(interpret(current))
+        data.ttype = "count"
+        data.schema = S.Struct({ id: S.String }) as any
+      },
+      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))
+        if (v.mode === "aggregate" && v.aggregateMap) {
+          data.schema = v.schema
+          data.mode = "aggregate"
+          data.aggregateMap = Object.fromEntries(
+            Object.entries(v.aggregateMap).map(([key, expression]) => {
+              switch (expression._tag) {
+                case "agg-field":
+                  return [key, { _tag: "agg-field" as const, path: expression.path }]
+                case "agg-count":
+                  return [key, { _tag: "agg-count" as const }]
+                case "agg-count-when": {
+                  const filter = interpret(expression.operation(make())).filter
+                  return [key, { _tag: "agg-count-when" as const, filter }]
+                }
+                case "agg-sum":
+                  return [key, { _tag: "agg-sum" as const, field: expression.field }]
+                case "agg-min":
+                  return [key, { _tag: "agg-min" as const, field: expression.field }]
+                case "agg-max":
+                  return [key, { _tag: "agg-max" as const, field: expression.field }]
+              }
+            })
+          )
+          return
+        }
+        if (v.computed && v.mode === "transform") {
+          throw new Error("Computed projections require mode 'project' or 'collect', not 'transform'")
+        }
+        data.schema = v.schema
+        data.mode = v.computed
+          ? v.mode === "collect" ? "collect" : "project"
+          : v.mode
+        data.computed = v.computed
+          ? Object.fromEntries(
+            Object.entries(v.computed).map(([key, expression]) => {
+              const e = expression
+              const op = "operation" in e ? e.operation : undefined
+              const filter = op ? interpret(op(make())).filter.map(applyPath(e.path)) : []
+              switch (e._tag) {
+                case "relation-count":
+                case "relation-any":
+                case "relation-every":
+                  return [key, { _tag: e._tag, path: e.path, filter } as ComputedProjectionIrExpression]
+                case "relation-distinct-count":
+                case "relation-sum":
+                  return [
+                    key,
+                    { _tag: e._tag, path: e.path, field: e.field, filter } as ComputedProjectionIrExpression
+                  ]
+                case "relation-sum-expr":
+                  return [
+                    key,
+                    { _tag: e._tag, path: e.path, expression: e.expression, filter } as ComputedProjectionIrExpression
+                  ]
+                case "relation-sum-expr-by":
+                  return [
+                    key,
+                    {
+                      _tag: e._tag,
+                      path: e.path,
+                      expression: e.expression,
+                      unit: e.unit,
+                      filter
+                    } as ComputedProjectionIrExpression
+                  ]
+                case "relation-sum-expr-normalized":
+                  return [
+                    key,
+                    {
+                      _tag: e._tag,
+                      path: e.path,
+                      expression: e.expression,
+                      unit: e.unit,
+                      toBase: e.toBase,
+                      factors: e.factors,
+                      filter
+                    } as ComputedProjectionIrExpression
+                  ]
+                case "relation-collect":
+                  return [
+                    key,
+                    {
+                      _tag: e._tag,
+                      path: e.path,
+                      field: e.field,
+                      distinct: e.distinct,
+                      filter
+                    } as ComputedProjectionIrExpression
+                  ]
+                case "relation-collect-fields":
+                  return [
+                    key,
+                    {
+                      _tag: e._tag,
+                      path: e.path,
+                      fields: e.fields,
+                      distinct: e.distinct,
+                      filter
+                    } as ComputedProjectionIrExpression
+                  ]
+                case "relation-length":
+                  return [key, { _tag: e._tag, path: e.path } as ComputedProjectionIrExpression]
+              }
+            })
+          )
+          : undefined
+      }
+    })
+  )
+
+  return data
+}
+
+const walkTransformation = (t: S.AST.AST): S.AST.AST => {
+  if (S.AST.isDeclaration(t) && t.typeParameters.length > 0) {
+    return walkTransformation(t.typeParameters[0]!)
+  }
+  return t
+}
+
+export const toFilter = <
+  TFieldValues extends FieldValues,
+  A,
+  R,
+  TFieldValuesRefined extends TFieldValues = TFieldValues
+>(
+  q: QAll<TFieldValues, TFieldValuesRefined, A, R>,
+  baseSchema?: S.Schema<unknown>
+) => {
+  // TODO: Native interpreter for each db adapter, instead of the intermediate "new-kid" format
+  const a = interpret(q)
+
+  // Aggregate mode: build select entirely from aggregateMap (no schema-driven field list)
+  if (a.mode === "aggregate" && a.aggregateMap) {
+    const aggSelect = Object.entries(a.aggregateMap).map(([key, item]) => {
+      if (item._tag === "agg-field") {
+        return { key, path: item.path }
+      }
+      return { key, aggregate: item }
+    })
+    return dropUndefinedT({
+      t: null as unknown as TFieldValues,
+      limit: a.limit,
+      skip: a.skip,
+      select: Option.getOrUndefined(toNonEmptyArray(aggSelect)) as any,
+      schema: a.schema,
+      computed: undefined,
+      order: Option.getOrUndefined(toNonEmptyArray(a.order)),
+      ttype: a.ttype,
+      mode: "aggregate" as const,
+      filter: a.filter.length ? a.filter : undefined
+    })
+  }
+
+  const schema = a.schema
+  let select: (keyof TFieldValues | { key: string; subKeys: string[] } | {
+    key: string
+    computed: ComputedProjectionIrExpression
+  })[] = []
+  // TODO: support more complex (nested) schemas?
+  if (schema) {
+    const t = walkTransformation(SchemaAST.toEncoded(schema.ast))
+    if (S.AST.isObjects(t)) {
+      select = t.propertySignatures.map((_) => _.name as string)
+      for (const prop of t.propertySignatures) {
+        if (S.AST.isArrays(prop.type)) {
+          // make sure we only select when there are actually type literals in the tuple...
+          // otherwise we might be dealing with strings etc.
+          // TODO; be more strict, can't support arrays with unions that have non TypeLiteral members etc..
+          const arraySelect = {
+            key: prop.name as string,
+            subKeys: Array.flatMap(
+              prop.type.rest,
+              (x) => {
+                const t = walkTransformation(x)
+                return S.AST.isObjects(t) ? t.propertySignatures.map((y) => y.name as string) : []
+              }
+            )
+          }
+          if (arraySelect.subKeys.length > 0) {
+            select.push(arraySelect)
+            // make sure we don't double select?
+            if (select.includes(prop.name as string)) {
+              select.splice(select.indexOf(prop.name as string), 1)
+            }
+          }
+        }
+      }
+    }
+  }
+  const computed = a.computed
+  const getSelectKey = (_: (typeof select)[number]) => {
+    if (typeof _ === "string") {
+      return _
+    }
+    if (typeof _ === "object" && _ !== null && "key" in _) {
+      return _.key
+    }
+    return String(_)
+  }
+  const schemaKeys = select.map(getSelectKey)
+  const nonEncodedSchemaKeys = (() => {
+    if (!baseSchema) {
+      return [] as string[]
+    }
+    const encoded = walkTransformation(SchemaAST.toEncoded(baseSchema.ast))
+    if (!S.AST.isObjects(encoded)) {
+      return [] as string[]
+    }
+    const encodedKeys = encoded.propertySignatures.map((_) => _.name as string)
+    return schemaKeys.filter((key) => !encodedKeys.includes(key))
+  })()
+  const missingComputedKeys = nonEncodedSchemaKeys.filter((key) => !(computed && key in computed))
+
+  if (Array.isArrayNonEmpty(missingComputedKeys)) {
+    throw new Error(`Missing computed projections for schema keys: ${missingComputedKeys.join(", ")}`)
+  }
+
+  if (computed) {
+    const computedKeys = Object.keys(computed)
+    const extraComputedKeys = computedKeys.filter((key) => !schemaKeys.includes(key))
+    if (Array.isArrayNonEmpty(extraComputedKeys)) {
+      throw new Error(`Computed projection keys must exist in projection schema: ${extraComputedKeys.join(", ")}`)
+    }
+    select = select.filter((_) => {
+      const key = getSelectKey(_)
+      return !(key in computed)
+    })
+    select.push(...Object.entries(computed).map(([key, expression]) => ({ key, computed: expression })))
+  }
+  return dropUndefinedT({
+    t: null as unknown as TFieldValues,
+    limit: a.limit,
+    skip: a.skip,
+    select: Option.getOrUndefined(toNonEmptyArray(select)),
+    schema,
+    computed,
+    order: Option.getOrUndefined(toNonEmptyArray(a.order)),
+    ttype: a.ttype,
+    mode: a.mode ?? "transform",
+    filter: a.filter.length
+      ? a.filter
+      : undefined
+  })
+}

package/src/Model/query.ts

@@ -0,0 +1,13 @@
+export * from "./query/dsl.js"
+export * from "./query/new-kid-interpreter.js"
+
+export interface RawQuery<Encoded, Out> {
+  cosmos: (vals: { name: string }) => {
+    query: string
+    parameters: {
+      name: string
+      value: any
+    }[]
+  }
+  memory: (t: readonly Encoded[]) => readonly Out[]
+}

package/src/Model.ts

@@ -0,0 +1,4 @@
+export * from "./Model/dsl.js"
+export * as Q from "./Model/query.js"
+export { makeRepo } from "./Model/Repository.js"
+export { type RegisteredRepository, RepositoryRegistry, RepositoryRegistryLive } from "./Model/Repository.js"

package/src/NonEmptySet.ts

@@ -1,5 +1,7 @@
-import { type Equivalence, Option, type Order } from "effect"
 import type { NonEmptyReadonlyArray } from "effect/Array"
+import type * as Equivalence from "effect/Equivalence"
+import * as Option from "effect/Option"
+import type * as Order from "effect/Order"
 import { flow, pipe } from "./Function.js"
 import { filter_, filterMap, filterMap_, fromArray as fromArrayOriginal, insert as insertOriginal, insert_ as insert_Original, map, map_, reduce, reduce_, remove, remove_, type Set, toArray as toArrayOriginal } from "./Set.js"
 

package/src/Option.ts

@@ -2,6 +2,8 @@
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
 /* eslint-disable @typescript-eslint/no-unsafe-return */
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
+// eslint-disable-next-line import/no-unassigned-import
+import "./builtin.js"
 import { getOrUndefined as value, type Some } from "effect/Option"
 import * as Option from "effect/Option"
 

package/src/Pure.ts

@@ -1,7 +1,10 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { Chunk, Effect, Layer, Result } from "effect"
+import * as Chunk from "effect/Chunk"
+import * as Effect from "effect/Effect"
+import * as Layer from "effect/Layer"
+import * as Result from "effect/Result"
+import * as Context from "./Context.js"
 import { tuple } from "./Function.js"
-import * as ServiceMap from "./ServiceMap.js"
 
 const S1 = Symbol()
 const S2 = Symbol()
@@ -86,9 +89,9 @@ export function GMU<W, S, S2, GA, MR, ME>(modify: (i: GA) => Pure<W, S, S2, MR,
   ) => GMU_(get, modify, update)
 }
 
-const tagg = ServiceMap.Service<{ env: PureEnv<never, unknown, never> }>("PureEnv")
+const tagg = Context.Service<{ env: PureEnv<never, unknown, never> }>("PureEnv")
 function castTag<W, S, S2>() {
-  return tagg as any as ServiceMap.Service<PureEnvEnv<W, S, S2>, PureEnvEnv<W, S, S2>>
+  return tagg as any as Context.Service<PureEnvEnv<W, S, S2>, PureEnvEnv<W, S, S2>>
 }
 
 export const ServiceTag = Symbol()
@@ -100,9 +103,9 @@ export abstract class PhantomTypeParameter<Identifier extends keyof any, Instant
   }
 }
 
-export type ServiceShape<T extends ServiceMap.ServiceClass.Shape<any, any>> = Omit<
+export type ServiceShape<T extends Context.ServiceClass.Shape<any, any>> = Omit<
   T,
-  keyof ServiceMap.ServiceClass.Shape<any, any>
+  keyof Context.ServiceClass.Shape<any, any>
 >
 
 export abstract class ServiceTagged<ServiceKey> extends PhantomTypeParameter<string, ServiceKey> {}
@@ -117,11 +120,11 @@ export interface PureEnvEnv<W, S, S2> extends ServiceTagged<typeof PureEnvEnv> {
 }
 
 export function get<S>(): Pure<never, S, S, never, never, S> {
-  return (castTag<never, S, S>() as any).use((_: any) => _.env.state)
+  return (castTag<never, S, S>()).useSync((_) => _.env.state)
 }
 
 export function set<S>(s: S): Pure<never, S, S, never, never, void> {
-  return (castTag<never, S, S>() as any).use((_: any) => {
+  return (castTag<never, S, S>()).useSync((_) => {
     _.env.state = s
   })
 }
@@ -129,13 +132,13 @@ export function set<S>(s: S): Pure<never, S, S, never, never, void> {
 export type PureLogT<W> = Pure<W, unknown, never, never, never, void>
 
 export function log<W>(w: W): PureLogT<W> {
-  return (castTag<W, unknown, never>() as any).use((_: any) => {
+  return (castTag<W, unknown, never>()).useSync((_) => {
     _.env.log = Chunk.append(_.env.log, w)
   })
 }
 
 export function logMany<W>(w: Iterable<W>): PureLogT<W> {
-  return (castTag<W, unknown, never>() as any).use((_: any) => {
+  return (castTag<W, unknown, never>()).useSync((_) => {
     _.env.log = Chunk.appendAll(_.env.log, Chunk.fromIterable(w))
   })
 }
@@ -150,17 +153,16 @@ export function runAll<R, E, A, W3, S1, S3, S4 extends S1>(
 > {
   const a = Effect
     .flatMap(self, (x) =>
-      (castTag<W3, S1, S3>() as any)
-        .use(
-          ({ env: _ }: any) => Effect.sync(() => ({ log: _.log, state: _.state }))
+      (castTag<W3, S1, S3>())
+        .useSync(
+          ({ env: _ }) => ({ log: _.log, state: _.state })
         )
         .pipe(
-          Effect.flatMap((_: any) => Effect.succeed(_)),
           Effect.map(
-            ({ log, state }: any) => tuple(log, Result.succeed(tuple(state, x)))
+            ({ log, state }) => tuple(log, Result.succeed(tuple(state, x)))
           )
         ))
-    .pipe(Effect.catch((err: any) => (tagg as any).use((env: any) => tuple(env.env.log, Result.fail(err)))))
+    .pipe(Effect.catch((err: any) => tagg.useSync((env) => tuple(env.env.log, Result.fail(err)))))
   return Effect.provide(a, Layer.succeed(tagg, { env: makePureEnv<W3, S3, S4>(s) as any }) as any) as any
 }
 
@@ -198,11 +200,11 @@ export function runA<R, E, A, W3, S1, S3, S4 extends S1>(
 export function modify<S2, A, S3>(
   mod: (s: S2) => readonly [S3, A]
 ): Effect.Effect<A, never, { env: PureEnv<never, S2, S3> }> {
-  return (castTag<never, S3, S2>() as any).use((_: any) => {
+  return (castTag<never, S3, S2>()).useSync((_) => {
     const [s, a] = mod(_.env.state)
     _.env.state = s as any
     return a
-  })
+  }) as any
 }
 
 export function modifyM<W, R, E, A, S2, S3>(
@@ -210,7 +212,7 @@ export function modifyM<W, R, E, A, S2, S3>(
 ): Effect.Effect<A, E, FixEnv<R, W, S2, S3>> {
   // return serviceWithEffect(_ => Ref.modifyM_(_.state, mod))
   return Effect.flatMap(
-    (castTag<W, S3, S2>() as any).use((_: any) => _),
+    (castTag<W, S3, S2>()).useSync((_) => _),
     (_: any) =>
       Effect.map(mod(_.env.state), ([s, a]: any) => {
         _.env.state = s

package/src/QueueMaker.ts

@@ -0,0 +1,19 @@
+import type * as Scope from "effect/Scope"
+import type { NonEmptyReadonlyArray } from "./Array.js"
+import type * as Effect from "./Effect.js"
+import { RequestContext } from "./RequestContext.js"
+
+export interface QueueBase<Evt, DrainEvt> {
+  drain: <DrainE, DrainR>(
+    makeHandleEvent: (ks: DrainEvt) => Effect.Effect<void, DrainE, DrainR>,
+    sessionId?: string
+  ) => Effect.Effect<never, never, Scope.Scope | DrainR>
+  publish: (
+    ...messages: NonEmptyReadonlyArray<Evt>
+  ) => Effect.Effect<void>
+}
+
+export interface QueueMakerOps {}
+export const QueueMaker: QueueMakerOps = {}
+
+export const QueueMeta = RequestContext