@effect-app/infra 4.0.0-beta.247 → 4.0.0-beta.249

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

@@ -1,484 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-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
-  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

@@ -1,13 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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/QueueMaker/service.ts

@@ -1,19 +0,0 @@
-import type { NonEmptyReadonlyArray } from "effect-app/Array"
-import type * as Effect from "effect-app/Effect"
-import type * as Scope from "effect/Scope"
-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

package/src/RequestContext.ts

@@ -1,62 +0,0 @@
-import * as Context from "effect-app/Context"
-import { UserProfileId } from "effect-app/ids"
-import * as S from "effect-app/Schema"
-import { NonEmptyString255 } from "effect-app/Schema"
-
-export const Locale = S.Literals(["en", "de"])
-export type Locale = typeof Locale.Type
-
-export class LocaleRef extends Context.Reference("Locale", { defaultValue: (): Locale => "en" }) {}
-
-export class RequestContext extends S.Opaque<
-  RequestContext,
-  RequestContext.Encoded
->()(S.Struct({
-  span: S.Struct({
-    traceId: S.String,
-    spanId: S.String,
-    sampled: S.Boolean
-  }),
-  name: NonEmptyString255,
-  locale: Locale,
-  sourceId: S.optional(NonEmptyString255), // TODO?
-  namespace: NonEmptyString255,
-  /** @deprecated */
-  userProfile: S.optional(S.Struct({ sub: UserProfileId })) //
-})) {
-  // static Tag = Context.Tag<RequestContext>()
-
-  static toMonitoring(this: void, self: RequestContext) {
-    return {
-      operationName: self.name,
-      locale: self.locale
-    }
-  }
-}
-
-export const spanAttributes = (ctx: Pick<RequestContext, "locale" | "namespace"> & Partial<RequestContext>) => ({
-  "code.function.name": ctx.name,
-  "app.locale": ctx.locale,
-  "app.tenant.id": ctx.namespace,
-  ...ctx.sourceId ? { "client.id": ctx.sourceId } : {},
-  ...(ctx.userProfile?.sub
-    ? {
-      "user.id": ctx
-        .userProfile
-        .sub,
-      "user.roles": "roles" in ctx
-          .userProfile
-        ? ctx.userProfile.roles
-        : undefined
-    }
-    : {})
-})
-
-// codegen:start {preset: model}
-//
-export namespace RequestContext {
-  export interface Encoded extends S.StructNestedEncoded<typeof RequestContext> {}
-}
-//
-// codegen:end
-//