@effect-app/infra 4.0.0-beta.24 → 4.0.0-beta.241

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

@@ -1,13 +1,109 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
-import { Array, identity, Match, Option, pipe, S } from "effect-app"
+import * as Array from "effect-app/Array"
 import { toNonEmptyArray } from "effect-app/Array"
+import * as Option from "effect-app/Option"
+import * as S from "effect-app/Schema"
 import { dropUndefinedT } from "effect-app/utils"
+import { identity, pipe } from "effect/Function"
+import * as Match from "effect/Match"
+import * as SchemaAST from "effect/SchemaAST"
 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
@@ -15,7 +111,9 @@ type Result<TFieldValues extends FieldValues, A = TFieldValues, R = never> = {
   skip: number | undefined
   order: { key: FieldPath<TFieldValues>; direction: "ASC" | "DESC" }[]
   ttype: "one" | "many" | "count" | undefined
-  mode: "collect" | "project" | "transform" | undefined
+  mode: "collect" | "project" | "transform" | "aggregate" | undefined
+  computed: Record<string, ComputedProjectionIrExpression> | undefined
+  aggregateMap: Record<string, AggregateIrItem> | undefined
 }
 
 const interpret = <
@@ -33,7 +131,9 @@ const interpret = <
     skip: undefined,
     order: [],
     ttype: undefined,
-    mode: undefined
+    mode: undefined,
+    computed: undefined,
+    aggregateMap: undefined
   }
 
   const upd = (
@@ -46,6 +146,8 @@ const interpret = <
     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 =>
@@ -135,8 +237,112 @@ const interpret = <
       },
       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.mode
+        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
       }
     })
   )
@@ -157,15 +363,42 @@ export const toFilter = <
   R,
   TFieldValuesRefined extends TFieldValues = TFieldValues
 >(
-  q: QAll<TFieldValues, TFieldValuesRefined, A, R>
+  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[] })[] = []
+  let select: (keyof TFieldValues | { key: string; subKeys: string[] } | {
+    key: string
+    computed: ComputedProjectionIrExpression
+  })[] = []
   // TODO: support more complex (nested) schemas?
   if (schema) {
-    const t = walkTransformation(schema.ast)
+    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) {
@@ -194,12 +427,53 @@ export const toFilter = <
       }
     }
   }
+  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",

package/src/Model.ts

@@ -1,3 +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"