@effect-app/infra 4.0.0-beta.212 → 4.0.0-beta.214

package/src/Model/query/dsl.ts

@@ -97,6 +97,46 @@ export type QueryProjection<
   R,
   TType
 >
+
+export type ComputedProjectionOperation = (q: Query<any>) => QueryWhere<any, any, any>
+
+export type ComputedProjectionExpression =
+  | {
+    readonly _tag: "relation-count"
+    readonly path: string
+    readonly operation?: ComputedProjectionOperation
+  }
+  | {
+    readonly _tag: "relation-any"
+    readonly path: string
+    readonly operation?: ComputedProjectionOperation
+  }
+  | {
+    readonly _tag: "relation-every"
+    readonly path: string
+    readonly operation: ComputedProjectionOperation
+  }
+  | {
+    readonly _tag: "relation-distinct-count"
+    readonly path: string
+    readonly field: string
+    readonly operation?: ComputedProjectionOperation
+  }
+  | {
+    readonly _tag: "relation-sum"
+    readonly path: string
+    readonly field: string
+    readonly operation?: ComputedProjectionOperation
+  }
+  | {
+    readonly _tag: "relation-collect"
+    readonly path: string
+    readonly field: string
+    readonly distinct: boolean
+    readonly operation?: ComputedProjectionOperation
+  }
+
+export type ComputedProjectionMap = Readonly<Record<string, ComputedProjectionExpression>>
 export type Q<TFieldValues extends FieldValues> =
   | Initial<TFieldValues>
   | Where<TFieldValues>
@@ -211,6 +251,7 @@ export class Project<A, TFieldValues extends FieldValues, R, TType extends "one"
     current: Query<TFieldValues> | QueryWhere<any, TFieldValues> | QueryEnd<TFieldValues, TType>
     schema: S.Codec<A, TFieldValues, R>
     mode: "collect" | "project" | "transform"
+    computed?: ComputedProjectionMap
   }>
   implements QueryProjection<TFieldValues, A, R>
 {
@@ -299,6 +340,35 @@ export const count: {
   ): QueryProjection<ExtractFieldValuesRefined<Q>, NonNegativeInt, never, "count", ExtractExclusiveness<Q>>
 } = (current) => new Count({ current })
 
+/**
+ * Attach a projection schema to a query.
+ *
+ * The `select` clause sent to the store is derived from the schema's encoded
+ * AST property names (top-level + per-array sub-keys), so a projection always
+ * narrows what is read from the store. The repository augments that select
+ * with `id` and `_etag` for change tracking. See {@link toFilter} and the
+ * dispatch in `Repository/internal/internal.ts`.
+ *
+ * Modes — pick based on shape of the decoded value and on whether the
+ * persistence-model (PM) reverse-mapping is needed:
+ *
+ * - `"transform"` (default when `mode` omitted): goes through the repo's
+ *   `parseMany`/`parseMany2` pipeline. The raw row is reverse-mapped via the
+ *   etag/PM cache (re-injecting `_etag` and any PM-shape state) before
+ *   decoding. Decode failures `orDie` (error channel = `never`). Use when
+ *   the schema operates on the full PM shape (e.g. full-entity reads that
+ *   must preserve etag tracking).
+ *
+ * - `"project"`: decodes the raw encoded row directly with the supplied
+ *   schema. No PM reverse-mapping, no etag cache merge. Decode failures
+ *   surface as `S.SchemaError`. Use for slim DTOs / aggregations that do not
+ *   need etag tracking and whose schema input is a plain subset of `Encoded`.
+ *
+ * - `"collect"`: like `"project"`, but the schema yields `Option<A>` and
+ *   `None` values are dropped post-decode (`Array.getSomes`). Use to filter
+ *   rows during decode (e.g. discriminated-union narrowing where some rows
+ *   should not appear in the result).
+ */
 export const project: {
   <
     Q extends Query<any> | QueryWhere<any, any, any> | QueryEnd<any, "one" | "many", any>,
@@ -356,6 +426,127 @@ export const project: {
   ) => QueryProjection<ExtractFieldValuesRefined<Q>, A, R, ExtractTType<Q>, E>
 } = (schema: any, mode = "transform") => (current: any) => new Project({ current, schema, mode } as any)
 
+export const relation = <TFieldValues extends FieldValues>(
+  path: FieldPath<TFieldValues>
+) => ({
+  count: (operation?: ComputedProjectionOperation): ComputedProjectionExpression =>
+    operation
+      ? {
+        _tag: "relation-count",
+        path: path as string,
+        operation
+      }
+      : {
+        _tag: "relation-count",
+        path: path as string
+      },
+  any: (operation?: ComputedProjectionOperation): ComputedProjectionExpression =>
+    operation
+      ? {
+        _tag: "relation-any",
+        path: path as string,
+        operation
+      }
+      : {
+        _tag: "relation-any",
+        path: path as string
+      },
+  every: (operation: ComputedProjectionOperation): ComputedProjectionExpression => ({
+    _tag: "relation-every",
+    path: path as string,
+    operation
+  }),
+  distinctCount: (field: string, operation?: ComputedProjectionOperation): ComputedProjectionExpression =>
+    operation
+      ? {
+        _tag: "relation-distinct-count",
+        path: path as string,
+        field,
+        operation
+      }
+      : {
+        _tag: "relation-distinct-count",
+        path: path as string,
+        field
+      },
+  sum: (field: string, operation?: ComputedProjectionOperation): ComputedProjectionExpression =>
+    operation
+      ? {
+        _tag: "relation-sum",
+        path: path as string,
+        field,
+        operation
+      }
+      : {
+        _tag: "relation-sum",
+        path: path as string,
+        field
+      },
+  collect: (field: string, operation?: ComputedProjectionOperation): ComputedProjectionExpression =>
+    operation
+      ? {
+        _tag: "relation-collect",
+        path: path as string,
+        field,
+        distinct: false,
+        operation
+      }
+      : {
+        _tag: "relation-collect",
+        path: path as string,
+        field,
+        distinct: false
+      },
+  collectDistinct: (field: string, operation?: ComputedProjectionOperation): ComputedProjectionExpression =>
+    operation
+      ? {
+        _tag: "relation-collect",
+        path: path as string,
+        field,
+        distinct: true,
+        operation
+      }
+      : {
+        _tag: "relation-collect",
+        path: path as string,
+        field,
+        distinct: true
+      }
+})
+
+export const computed = <T extends ComputedProjectionMap>(value: T): T => value
+
+export const projectComputed: {
+  <
+    Q extends Query<any> | QueryWhere<any, any, any> | QueryEnd<any, "one" | "many", any>,
+    I extends Record<string, unknown>,
+    A = ExtractFieldValuesRefined<Q>,
+    R = never,
+    E extends boolean = ExtractExclusiveness<Q>
+  >(
+    schema: S.Codec<Option.Option<A>, I, R>,
+    computedProjection: ComputedProjectionMap,
+    mode: "collect"
+  ): (
+    current: Q
+  ) => QueryProjection<ExtractFieldValuesRefined<Q>, A, R, ExtractTType<Q>, E>
+
+  <
+    Q extends Query<any> | QueryWhere<any, any, any> | QueryEnd<any, "one" | "many", any>,
+    I extends Record<string, unknown>,
+    A = ExtractFieldValuesRefined<Q>,
+    R = never,
+    E extends boolean = ExtractExclusiveness<Q>
+  >(
+    schema: S.Codec<A, I, R>,
+    computedProjection: ComputedProjectionMap,
+    mode?: "project"
+  ): (
+    current: Q
+  ) => QueryProjection<ExtractFieldValuesRefined<Q>, A, R, ExtractTType<Q>, E>
+} = (schema: any, computedProjection: ComputedProjectionMap, mode = "project") => (current: any) =>
+  new Project({ current, schema, mode, computed: computedProjection } as any)
+
 type GetArV<T> = T extends readonly (infer R)[] ? R : never
 
 export type FilterContinuations<IsCurrentInitial extends boolean = false> = {

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

@@ -8,6 +8,42 @@ 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 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-collect"
+    readonly path: string
+    readonly field: string
+    readonly distinct: boolean
+    readonly filter: readonly FilterResult[]
+  }
+
 type Result<TFieldValues extends FieldValues, A = TFieldValues, R = never> = {
   filter: FilterResult[]
   schema: S.Codec<A, TFieldValues, R> | undefined
@@ -16,6 +52,7 @@ type Result<TFieldValues extends FieldValues, A = TFieldValues, R = never> = {
   order: { key: FieldPath<TFieldValues>; direction: "ASC" | "DESC" }[]
   ttype: "one" | "many" | "count" | undefined
   mode: "collect" | "project" | "transform" | undefined
+  computed: Record<string, ComputedProjectionIrExpression> | undefined
 }
 
 const interpret = <
@@ -33,7 +70,8 @@ const interpret = <
     skip: undefined,
     order: [],
     ttype: undefined,
-    mode: undefined
+    mode: undefined,
+    computed: undefined
   }
 
   const upd = (
@@ -46,6 +84,7 @@ 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
   }
 
   const applyPath = (path: string) => (_: FilterResult): FilterResult =>
@@ -135,8 +174,44 @@ const interpret = <
       },
       project: (v) => {
         upd(interpret(v.current))
+        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 filter = e.operation ? interpret(e.operation(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-collect":
+                  return [
+                    key,
+                    {
+                      _tag: e._tag,
+                      path: e.path,
+                      field: e.field,
+                      distinct: e.distinct,
+                      filter
+                    } as ComputedProjectionIrExpression
+                  ]
+              }
+            })
+          )
+          : undefined
       }
     })
   )
@@ -157,12 +232,16 @@ 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)
   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(SchemaAST.toEncoded(schema.ast))
@@ -194,12 +273,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/Store/Cosmos/query.ts

@@ -4,6 +4,7 @@ import { Array, Effect, type NonEmptyReadonlyArray } from "effect-app"
 import { assertUnreachable } from "effect-app/utils"
 import { InfraLogger } from "../../logger.js"
 import type { FilterR, FilterResult, Ops } from "../../Model/filter/filterApi.js"
+import type { ComputedProjectionIrExpression } from "../../Model/query.js"
 import { isRelationCheck } from "../codeFilter.js"
 import type { SupportedValues } from "../service.js"
 
@@ -40,12 +41,20 @@ export function buildWhereCosmosQuery3(
   filter: readonly FilterResult[],
   name: string,
   defaultValues: Record<string, unknown>,
-  select?: NonEmptyReadonlyArray<string | { key: string; subKeys: readonly string[] }>,
+  select?: NonEmptyReadonlyArray<
+    string | {
+      key: string
+      subKeys: readonly string[]
+    } | {
+      key: string
+      computed: ComputedProjectionIrExpression
+    }
+  >,
   order?: NonEmptyReadonlyArray<{ key: string; direction: "ASC" | "DESC" }>,
   skip?: number,
   limit?: number
 ) {
-  const statement = (x: FilterR, i: number, values: any[]) => {
+  const statement = (x: FilterR, i: number) => {
     if (x.path === idKey) {
       x = { ...x, path: "id" }
     }
@@ -60,8 +69,6 @@ export function buildWhereCosmosQuery3(
 
     const v = "@v" + i
 
-    const realValue = values[i]
-
     switch (x.op) {
       case "in":
         return `ARRAY_CONTAINS(${v}, ${k})`
@@ -74,14 +81,22 @@ export function buildWhereCosmosQuery3(
         return `(NOT ARRAY_CONTAINS(${k}, ${v}))`
 
       case "includes-any":
-        return `ARRAY_CONTAINS_ANY(${k}, ${(realValue as any[]).map((_, i) => `${v}__${i}`).join(", ")})`
+        return `ARRAY_CONTAINS_ANY(${k}, ${
+          (x.value as unknown as readonly unknown[]).map((_, i) => `${v}__${i}`).join(", ")
+        })`
       case "notIncludes-any":
-        return `(NOT ARRAY_CONTAINS_ANY(${k}, ${(realValue as any[]).map((_, i) => `${v}__${i}`).join(", ")}))`
+        return `(NOT ARRAY_CONTAINS_ANY(${k}, ${
+          (x.value as unknown as readonly unknown[]).map((_, i) => `${v}__${i}`).join(", ")
+        }))`
 
       case "includes-all":
-        return `ARRAY_CONTAINS_ALL(${k}, ${(realValue as any[]).map((_, i) => `${v}__${i}`).join(", ")})`
+        return `ARRAY_CONTAINS_ALL(${k}, ${
+          (x.value as unknown as readonly unknown[]).map((_, i) => `${v}__${i}`).join(", ")
+        })`
       case "notIncludes-all":
-        return `(NOT ARRAY_CONTAINS_ALL(${k}, ${(realValue as any[]).map((_, i) => `${v}__${i}`).join(", ")}))`
+        return `(NOT ARRAY_CONTAINS_ALL(${k}, ${
+          (x.value as unknown as readonly unknown[]).map((_, i) => `${v}__${i}`).join(", ")
+        }))`
 
       case "contains":
         return `CONTAINS(${k}, ${v}, true)`
@@ -165,7 +180,7 @@ export function buildWhereCosmosQuery3(
         : _
       : _
 
-  const print = (state: readonly FilterResult[], values: any[], isRelation: string | null, every: boolean) => {
+  const print = (state: readonly FilterResult[], isRelation: string | null, every: boolean) => {
     let s = ""
     let l = 0
     const printN = (n: number) => {
@@ -174,13 +189,13 @@ export function buildWhereCosmosQuery3(
     for (const e of state) {
       switch (e.t) {
         case "where":
-          s += statement(e, i++, values)
+          s += statement(e, i++)
           break
         case "or":
-          s += ` OR ${statement(e, i++, values)}`
+          s += ` OR ${statement(e, i++)}`
           break
         case "and":
-          s += ` AND ${statement(e, i++, values)}`
+          s += ` AND ${statement(e, i++)}`
           break
         case "or-scope": {
           ++l
@@ -189,7 +204,7 @@ export function buildWhereCosmosQuery3(
           if (rel) {
             const rel = (e.result[0]! as { path: string }).path.split(".-1.")[0]
             s += isRelation
-              ? ` OR (\n${printN(l + 1)}${print(e.result, values, rel, every)}\n${printN(l)})`
+              ? ` OR (\n${printN(l + 1)}${print(e.result, rel, every)}\n${printN(l)})`
               : ` OR (\n${printN(l + 1)}${
                 every ? "NOT " : ""
               }EXISTS(SELECT VALUE ${rel} FROM ${rel} IN f.${rel} WHERE ${
@@ -197,13 +212,12 @@ export function buildWhereCosmosQuery3(
                   e
                     .result
                     .map(flip(every)),
-                  values,
                   rel,
                   every
                 )
               }))`
           } else {
-            s += ` OR (\n${printN(l + 1)}${print(e.result, values, null, every)}\n${printN(l)})`
+            s += ` OR (\n${printN(l + 1)}${print(e.result, null, every)}\n${printN(l)})`
           }
           --l
           break
@@ -215,14 +229,14 @@ export function buildWhereCosmosQuery3(
           if (rel) {
             const rel = (e.result[0]! as { path: string }).path.split(".-1.")[0]
             s += isRelation
-              ? ` AND (\n${printN(l + 1)}${print(e.result, values, rel, every)}\n${printN(l)})`
+              ? ` AND (\n${printN(l + 1)}${print(e.result, rel, every)}\n${printN(l)})`
               : ` AND (\n${printN(l + 1)}${
                 every ? "NOT " : ""
               }EXISTS(SELECT VALUE ${rel} FROM ${rel} IN f.${rel} WHERE ${
-                print(e.result.map(flip(every)), values, rel, every)
+                print(e.result.map(flip(every)), rel, every)
               }))`
           } else {
-            s += ` AND (\n${printN(l + 1)}${print(e.result, values, null, every)}\n${printN(l)})`
+            s += ` AND (\n${printN(l + 1)}${print(e.result, null, every)}\n${printN(l)})`
           }
           --l
           break
@@ -234,12 +248,12 @@ export function buildWhereCosmosQuery3(
           if (rel) {
             const rel = (e.result[0]! as { path: string }).path.split(".-1.")[0]
             s += isRelation
-              ? `(\n${printN(l + 1)}${print(e.result, values, rel, every)}\n${printN(l)})`
+              ? `(\n${printN(l + 1)}${print(e.result, rel, every)}\n${printN(l)})`
               : `(\n${printN(l + 1)}${every ? "NOT " : ""}EXISTS(SELECT VALUE ${rel} FROM ${rel} IN f.${rel} WHERE ${
-                print(e.result.map(flip(every)), values, rel, every)
+                print(e.result.map(flip(every)), rel, every)
               }))`
           } else {
-            s += `(\n${printN(l + 1)}${print(e.result, values, null, every)}\n${printN(l)})`
+            s += `(\n${printN(l + 1)}${print(e.result, null, every)}\n${printN(l)})`
           }
           // ;--l
           break
@@ -272,7 +286,48 @@ export function buildWhereCosmosQuery3(
           ? getValues(_.result)
           : [_]
       )
-  const values = getValues(filter)
+  const computedFilters = select
+    ? select.flatMap((_) => typeof _ === "object" && "computed" in _ ? getValues(_.computed.filter) : [])
+    : []
+  const values = [...computedFilters, ...getValues(filter)]
+
+  const computedSelectExpr = (key: string, computed: ComputedProjectionIrExpression) => {
+    const relationPath = computed.path
+    const relationAlias = relationPath
+    const relationSource = dottedToAccess(`f.${relationPath}`)
+    const where = computed.filter.length > 0
+      ? ` WHERE ${print(computed.filter, relationPath, false)}`
+      : ""
+    switch (computed._tag) {
+      case "relation-count":
+        return `(SELECT VALUE COUNT(1) FROM ${relationAlias} IN ${relationSource}${where}) AS ${key}`
+      case "relation-any":
+        return `EXISTS(SELECT VALUE ${relationAlias} FROM ${relationAlias} IN ${relationSource}${where}) AS ${key}`
+      case "relation-every": {
+        // ∀x.P(x) ≡ ¬∃x.¬P(x). Cosmos has no NOT(...) on EXISTS subqueries directly,
+        // but we can flip via NOT EXISTS(... WHERE NOT (filter)).
+        if (computed.filter.length === 0) return `true AS ${key}`
+        return `NOT EXISTS(SELECT VALUE ${relationAlias} FROM ${relationAlias} IN ${relationSource} WHERE NOT (${
+          print(computed.filter, relationPath, false)
+        })) AS ${key}`
+      }
+      case "relation-distinct-count": {
+        const fieldRef = dottedToAccess(`${relationAlias}.${computed.field}`)
+        return `(SELECT VALUE COUNT(1) FROM (SELECT DISTINCT VALUE ${fieldRef} FROM ${relationAlias} IN ${relationSource}${where})) AS ${key}`
+      }
+      case "relation-sum": {
+        const fieldRef = dottedToAccess(`${relationAlias}.${computed.field}`)
+        return `(SELECT VALUE SUM(${fieldRef}) FROM ${relationAlias} IN ${relationSource}${where}) AS ${key}`
+      }
+      case "relation-collect": {
+        const fieldRef = dottedToAccess(`${relationAlias}.${computed.field}`)
+        if (computed.distinct) {
+          return `ARRAY(SELECT DISTINCT VALUE ${fieldRef} FROM ${relationAlias} IN ${relationSource}${where}) AS ${key}`
+        }
+        return `ARRAY(SELECT VALUE ${fieldRef} FROM ${relationAlias} IN ${relationSource}${where}) AS ${key}`
+      }
+    }
+  }
   // with joins, you should use DISTINCT
   // or you can end up with duplicates
   return {
@@ -283,6 +338,8 @@ export function buildWhereCosmosQuery3(
           .map((s) =>
             typeof s === "string"
               ? dottedToAccess(s === idKey ? "f.id" : `f.${s}`) // x["y"} vs x.y, helps with reserved keywords like "value"
+              : "computed" in s
+              ? computedSelectExpr(s.key, s.computed)
               : `ARRAY (SELECT ${s.subKeys.map((_) => dottedToAccess(`t.${_}`)).join(",")}
                 FROM t in ${dottedToAccess(`f.${s.key}`)}) AS ${s.key}`
           )
@@ -291,7 +348,7 @@ export function buildWhereCosmosQuery3(
     }
     FROM ${name} f
 
-    ${filter.length ? `WHERE (${print(filter, values.map((_) => _.value), null, false)})` : ""}
+    ${filter.length ? `WHERE (${print(filter, null, false)})` : ""}
     ${order ? `ORDER BY ${order.map((_) => `${dottedToAccess(`f.${_.key}`)} ${_.direction}`).join(", ")}` : ""}
     ${skip !== undefined || limit !== undefined ? `OFFSET ${skip ?? 0} LIMIT ${limit ?? 999999}` : ""}`,
     parameters: values

package/src/Store/Cosmos.ts

@@ -7,7 +7,7 @@ import { CosmosClient, CosmosClientLayer } from "../adapters/cosmos-client.js"
 import { OptimisticConcurrencyException } from "../errors.js"
 import { InfraLogger } from "../logger.js"
 import type { FieldValues } from "../Model/filter/types.js"
-import { type RawQuery } from "../Model/query.js"
+import { type ComputedProjectionIrExpression, type RawQuery } from "../Model/query.js"
 import { annotateCosmosResponse, annotateDb } from "../otel.js"
 import { buildWhereCosmosQuery3, logQuery } from "./Cosmos/query.js"
 import { storeId } from "./Memory.js"
@@ -451,7 +451,15 @@ const makeCosmosStore = Effect.fnUntraced(function*({ prefix }: StorageConfig) {
                   name,
                   defaultValues,
                   f.select as
-                    | NonEmptyReadonlyArray<string | { key: string; subKeys: readonly string[] }>
+                    | NonEmptyReadonlyArray<
+                      string | {
+                        key: string
+                        subKeys: readonly string[]
+                      } | {
+                        key: string
+                        computed: ComputedProjectionIrExpression
+                      }
+                    >
                     | undefined,
                   f.order as NonEmptyReadonlyArray<{ key: string; direction: "ASC" | "DESC" }> | undefined,
                   skip,