@effect-app/infra 4.0.0-beta.98 → 4.0.0

package/src/{adapters/SQL → SQL}/Model.ts

@@ -17,13 +17,14 @@ import * as Option from "effect/Option"
 import * as Predicate from "effect/Predicate"
 import * as RequestResolver from "effect/RequestResolver"
 import * as Schema from "effect/Schema"
+import * as VariantSchema from "effect/schema/VariantSchema"
 import * as Getter from "effect/SchemaGetter"
 import * as Transformation from "effect/SchemaTransformation"
 import type { Scope } from "effect/Scope"
-import * as VariantSchema from "effect/unstable/schema/VariantSchema"
-import { SqlClient } from "effect/unstable/sql/SqlClient"
-import * as SqlResolver from "effect/unstable/sql/SqlResolver"
-import * as SqlSchema from "effect/unstable/sql/SqlSchema"
+import { SqlClient } from "effect/sql/SqlClient"
+import * as SqlResolver from "effect/sql/SqlResolver"
+import * as SqlSchema from "effect/sql/SqlSchema"
+import { type DbSystem, withDbSpan } from "../otel.ts"
 
 const {
   Class,
@@ -73,8 +74,8 @@ export {
    * @since 1.0.0
    * @category constructors
    * @example
-   * import { Schema } from "effect"
-   * import { Model } from "effect/unstable/schema"
+   * import * as Schema from "effect/Schema"
+   * import { Model } from "effect/schema"
    *
    * export const GroupId = Schema.Number.pipe(Schema.brand("GroupId"))
    *
@@ -331,7 +332,7 @@ export interface Date extends Schema.decodeTo<Schema.instanceOf<DateTime.Utc>, S
  */
 export const Date: Date = Schema.String.pipe(
   Schema.decodeTo(Schema.DateTimeUtc, {
-    decode: Getter.dateTimeUtcFromInput().map(DateTime.removeTime),
+    decode: Getter.map(Getter.dateTimeUtcFromInput(), DateTime.removeTime),
     encode: Getter.transform(DateTime.formatIsoDate)
   })
 )
@@ -545,9 +546,15 @@ export const DateTimeUpdateFromNumber: DateTimeUpdateFromNumber = Field({
  */
 export interface JsonFromString<S extends Schema.Top> extends
   VariantSchema.Field<{
-    readonly select: Schema.fromJsonString<S>
-    readonly insert: Schema.fromJsonString<S>
-    readonly update: Schema.fromJsonString<S>
+    readonly select: Schema.fromJsonString<
+      Schema.Codec<S["Type"], Schema.Json, S["DecodingServices"], S["EncodingServices"]>
+    >
+    readonly insert: Schema.fromJsonString<
+      Schema.Codec<S["Type"], Schema.Json, S["DecodingServices"], S["EncodingServices"]>
+    >
+    readonly update: Schema.fromJsonString<
+      Schema.Codec<S["Type"], Schema.Json, S["DecodingServices"], S["EncodingServices"]>
+    >
     readonly json: S
     readonly jsonCreate: S
     readonly jsonUpdate: S
@@ -565,7 +572,7 @@ export interface JsonFromString<S extends Schema.Top> extends
 export const JsonFromString = <S extends Schema.Top>(
   schema: S
 ): JsonFromString<S> => {
-  const parsed = Schema.fromJsonString(schema)
+  const parsed = Schema.fromJsonString(Schema.toCodecJson(schema))
   return Field({
     select: parsed,
     insert: parsed,
@@ -590,6 +597,7 @@ export const makeRepository = <
   readonly spanPrefix: string
   readonly idColumn: Id
   readonly versionColumn?: string | undefined
+  readonly dbSystem?: DbSystem | undefined
 }): Effect.Effect<
   {
     readonly insert: (
@@ -623,6 +631,15 @@ export const makeRepository = <
     const idSchema = Model.fields[options.idColumn] as Schema.Top
     const idColumn = options.idColumn as string
     const versionColumn = options.versionColumn
+    const system: DbSystem = options.dbSystem ?? "other_sql"
+    const opSpan = (operation: string, idValue?: unknown) =>
+      withDbSpan({
+        operation,
+        system,
+        collection: options.tableName,
+        entity: options.spanPrefix,
+        ...(idValue !== undefined && { extra: { "app.entity.id": idValue } })
+      })
 
     const insertSchema = SqlSchema.findOne({
       Request: Model.insert,
@@ -644,9 +661,7 @@ select * from ${sql(options.tableName)} where ${sql(idColumn)} = LAST_INSERT_ID(
     ): Effect.Effect<S["Type"], Schema.SchemaError, S["DecodingServices"] | S["insert"]["EncodingServices"]> =>
       insertSchema(insert).pipe(
         Effect.catchTag("NoSuchElementError", Effect.die),
-        Effect.withSpan(`${options.spanPrefix}.insert`, {}, {
-          captureStackTrace: false
-        })
+        opSpan("insert")
       ) as any
 
     const insertVoidSchema = SqlSchema.void({
@@ -657,9 +672,7 @@ select * from ${sql(options.tableName)} where ${sql(idColumn)} = LAST_INSERT_ID(
       insert: S["insert"]["Type"]
     ): Effect.Effect<void, Schema.SchemaError, S["insert"]["EncodingServices"]> =>
       insertVoidSchema(insert).pipe(
-        Effect.withSpan(`${options.spanPrefix}.insertVoid`, {}, {
-          captureStackTrace: false
-        })
+        opSpan("insertVoid")
       ) as any
 
     const updateSchema = SqlSchema.findOne({
@@ -706,11 +719,7 @@ select * from ${sql(options.tableName)} where ${sql(idColumn)} = ${request[idCol
     ): Effect.Effect<S["Type"], Schema.SchemaError, S["DecodingServices"] | S["update"]["EncodingServices"]> =>
       updateSchema(update).pipe(
         Effect.catchTag("NoSuchElementError", Effect.die),
-        Effect.withSpan(`${options.spanPrefix}.update`, {
-          attributes: { id: (update as any)[idColumn] }
-        }, {
-          captureStackTrace: false
-        })
+        opSpan("update", (update as any)[idColumn])
       ) as any
 
     const updateVoidSchema = SqlSchema.void({
@@ -729,11 +738,7 @@ select * from ${sql(options.tableName)} where ${sql(idColumn)} = ${request[idCol
       update: S["update"]["Type"]
     ): Effect.Effect<void, Schema.SchemaError, S["update"]["EncodingServices"]> =>
       updateVoidSchema(update).pipe(
-        Effect.withSpan(`${options.spanPrefix}.updateVoid`, {
-          attributes: { id: (update as any)[idColumn] }
-        }, {
-          captureStackTrace: false
-        })
+        opSpan("updateVoid", (update as any)[idColumn])
       ) as any
 
     const findByIdSchema = SqlSchema.findOneOption({
@@ -749,9 +754,7 @@ select * from ${sql(options.tableName)} where ${sql(idColumn)} = ${request[idCol
       S["DecodingServices"] | S["fields"][Id]["EncodingServices"]
     > =>
       findByIdSchema(id).pipe(
-        Effect.withSpan(`${options.spanPrefix}.findById`, { attributes: { id } }, {
-          captureStackTrace: false
-        })
+        opSpan("findById", id)
       ) as any
 
     const deleteSchema = SqlSchema.void({
@@ -762,11 +765,7 @@ select * from ${sql(options.tableName)} where ${sql(idColumn)} = ${request[idCol
       id: S["fields"][Id]["Type"]
     ): Effect.Effect<void, Schema.SchemaError, S["fields"][Id]["EncodingServices"]> =>
       deleteSchema(id).pipe(
-        Effect.withSpan(`${options.spanPrefix}.delete`, {
-          attributes: { id }
-        }, {
-          captureStackTrace: false
-        })
+        opSpan("delete", id)
       ) as any
 
     return { insert, insertVoid, update, updateVoid, findById, delete: delete_ } as const
@@ -789,6 +788,7 @@ export const makeDataLoaders = <
     readonly idColumn: Id
     readonly window: Input
     readonly maxBatchSize?: number | undefined
+    readonly dbSystem?: DbSystem | undefined
   }
 ): Effect.Effect<
   {
@@ -821,6 +821,15 @@ export const makeDataLoaders = <
     const idSchema = Model.fields[options.idColumn] as Schema.Top
     const idColumn = options.idColumn as string
     const setMaxBatchSize = options.maxBatchSize ? RequestResolver.batchN(options.maxBatchSize) : identity
+    const system: DbSystem = options.dbSystem ?? "other_sql"
+    const opSpan = (operation: string, idValue?: unknown) =>
+      withDbSpan({
+        operation,
+        system,
+        collection: options.tableName,
+        entity: options.spanPrefix,
+        ...(idValue !== undefined && { extra: { "app.entity.id": idValue } })
+      })
 
     const insertResolver = SqlResolver
       .ordered({
@@ -854,9 +863,7 @@ select * from ${sql(options.tableName)} where ${sql(idColumn)} = LAST_INSERT_ID(
     > =>
       insertExecute(insert).pipe(
         Effect.catchTag("ResultLengthMismatch", Effect.die),
-        Effect.withSpan(`${options.spanPrefix}.insert`, {}, {
-          captureStackTrace: false
-        })
+        opSpan("insert")
       ) as any
 
     const insertVoidResolver = SqlResolver
@@ -874,9 +881,7 @@ select * from ${sql(options.tableName)} where ${sql(idColumn)} = LAST_INSERT_ID(
       insert: S["insert"]["Type"]
     ): Effect.Effect<void, Schema.SchemaError, S["insert"]["EncodingServices"]> =>
       insertVoidExecute(insert).pipe(
-        Effect.withSpan(`${options.spanPrefix}.insertVoid`, {}, {
-          captureStackTrace: false
-        })
+        opSpan("insertVoid")
       ) as any
 
     const findByIdResolver = SqlResolver
@@ -902,9 +907,7 @@ select * from ${sql(options.tableName)} where ${sql(idColumn)} = LAST_INSERT_ID(
       S["DecodingServices"] | S["fields"][Id]["EncodingServices"]
     > =>
       findByIdExecute(id).pipe(
-        Effect.withSpan(`${options.spanPrefix}.findById`, { attributes: { id } }, {
-          captureStackTrace: false
-        })
+        opSpan("findById", id)
       ) as any
 
     const deleteResolver = SqlResolver
@@ -922,9 +925,7 @@ select * from ${sql(options.tableName)} where ${sql(idColumn)} = LAST_INSERT_ID(
       id: S["fields"][Id]["Type"]
     ): Effect.Effect<void, Schema.SchemaError, S["fields"][Id]["EncodingServices"]> =>
       deleteExecute(id).pipe(
-        Effect.withSpan(`${options.spanPrefix}.delete`, { attributes: { id } }, {
-          captureStackTrace: false
-        })
+        opSpan("delete", id)
       ) as any
 
     return { insert, insertVoid, findById, delete: delete_ } as const

package/src/SQL.ts

@@ -0,0 +1 @@
+export * as SQLModel from "./SQL/Model.ts"

package/src/Store/Cosmos/query.ts

@@ -1,11 +1,15 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable @typescript-eslint/no-unsafe-return */
-import { Array, Effect, type NonEmptyReadonlyArray } from "effect-app"
+import * as Array from "effect-app/Array"
+import type { NonEmptyReadonlyArray } from "effect-app/Array"
+import * as Effect from "effect-app/Effect"
+import type { FilterR, FilterResult, Ops } from "effect-app/Model/filter/filterApi"
+import type { AggregateIrExpression, ComputedProjectionIrExpression, ComputedProjectionMathIrExpression } from "effect-app/Model/query"
+import type { SupportedValues } from "effect-app/Store"
 import { assertUnreachable } from "effect-app/utils"
-import { InfraLogger } from "../../logger.js"
-import type { FilterR, FilterResult, Ops } from "../../Model/filter/filterApi.js"
-import { isRelationCheck } from "../codeFilter.js"
-import type { SupportedValues } from "../service.js"
+import { InfraLogger } from "../../logger.ts"
+import { isRelationCheck } from "../codeFilter.ts"
+import { jsonifyFilter, type JsonLower } from "../utils.ts"
 
 export function logQuery(q: {
   query: string
@@ -40,12 +44,30 @@ 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
+    } | {
+      key: string
+      path: string
+    } | {
+      key: string
+      aggregate: AggregateIrExpression
+    }
+  >,
   order?: NonEmptyReadonlyArray<{ key: string; direction: "ASC" | "DESC" }>,
   skip?: number,
-  limit?: number
+  limit?: number,
+  json?: JsonLower
 ) {
-  const statement = (x: FilterR, i: number, values: any[]) => {
+  // defaultValues are already JSON-lowered at store construction; a second
+  // schema encode of an ISO Date string throws "Expected a valid Date".
+  filter = (json?.jsonifyFilter ?? jsonifyFilter)(filter)
+  const statement = (x: FilterR, i: number) => {
     if (x.path === idKey) {
       x = { ...x, path: "id" }
     }
@@ -60,8 +82,6 @@ export function buildWhereCosmosQuery3(
 
     const v = "@v" + i
 
-    const realValue = values[i]
-
     switch (x.op) {
       case "in":
         return `ARRAY_CONTAINS(${v}, ${k})`
@@ -74,14 +94,55 @@ 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 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 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 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 readonly unknown[]).map((_, i) => `${v}__${i}`).join(", ")
+        }))`
+
+      case "hasKey":
+        return `EXISTS(SELECT VALUE p FROM p IN ${k} WHERE p[0] = ${v})`
+      case "notHasKey":
+        return `(NOT EXISTS(SELECT VALUE p FROM p IN ${k} WHERE p[0] = ${v}))`
+      case "hasValue":
+        return `EXISTS(SELECT VALUE p FROM p IN ${k} WHERE p[1] = ${v})`
+      case "notHasValue":
+        return `(NOT EXISTS(SELECT VALUE p FROM p IN ${k} WHERE p[1] = ${v}))`
+      case "hasKeyValue":
+        return `ARRAY_CONTAINS(${k}, ${v})`
+      case "notHasKeyValue":
+        return `(NOT ARRAY_CONTAINS(${k}, ${v}))`
+      case "hasKey-any":
+        return `EXISTS(SELECT VALUE p FROM p IN ${k} WHERE ARRAY_CONTAINS(${v}, p[0]))`
+      case "notHasKey-any":
+        return `(NOT EXISTS(SELECT VALUE p FROM p IN ${k} WHERE ARRAY_CONTAINS(${v}, p[0])))`
+      case "hasKey-all":
+        return `(NOT EXISTS(SELECT VALUE key FROM key IN ${v} WHERE NOT EXISTS(SELECT VALUE p FROM p IN ${k} WHERE p[0] = key)))`
+      case "notHasKey-all":
+        return `EXISTS(SELECT VALUE key FROM key IN ${v} WHERE NOT EXISTS(SELECT VALUE p FROM p IN ${k} WHERE p[0] = key))`
+      case "hasValue-any":
+        return `EXISTS(SELECT VALUE p FROM p IN ${k} WHERE ARRAY_CONTAINS(${v}, p[1]))`
+      case "notHasValue-any":
+        return `(NOT EXISTS(SELECT VALUE p FROM p IN ${k} WHERE ARRAY_CONTAINS(${v}, p[1])))`
+      case "hasValue-all":
+        return `(NOT EXISTS(SELECT VALUE val FROM val IN ${v} WHERE NOT EXISTS(SELECT VALUE p FROM p IN ${k} WHERE p[1] = val)))`
+      case "notHasValue-all":
+        return `EXISTS(SELECT VALUE val FROM val IN ${v} WHERE NOT EXISTS(SELECT VALUE p FROM p IN ${k} WHERE p[1] = val))`
+      case "hasKeyValue-any":
+        return `EXISTS(SELECT VALUE pair FROM pair IN ${v} WHERE ARRAY_CONTAINS(${k}, pair))`
+      case "notHasKeyValue-any":
+        return `(NOT EXISTS(SELECT VALUE pair FROM pair IN ${v} WHERE ARRAY_CONTAINS(${k}, pair)))`
+      case "hasKeyValue-all":
+        return `(NOT EXISTS(SELECT VALUE pair FROM pair IN ${v} WHERE NOT ARRAY_CONTAINS(${k}, pair)))`
+      case "notHasKeyValue-all":
+        return `EXISTS(SELECT VALUE pair FROM pair IN ${v} WHERE NOT ARRAY_CONTAINS(${k}, pair))`
 
       case "contains":
         return `CONTAINS(${k}, ${v}, true)`
@@ -143,6 +204,24 @@ export function buildWhereCosmosQuery3(
     "notIncludes-any": "includes-any",
     "includes-all": "notIncludes-all",
     "notIncludes-all": "includes-all",
+    hasKey: "notHasKey",
+    notHasKey: "hasKey",
+    hasValue: "notHasValue",
+    notHasValue: "hasValue",
+    hasKeyValue: "notHasKeyValue",
+    notHasKeyValue: "hasKeyValue",
+    "hasKey-any": "notHasKey-any",
+    "notHasKey-any": "hasKey-any",
+    "hasKey-all": "notHasKey-all",
+    "notHasKey-all": "hasKey-all",
+    "hasValue-any": "notHasValue-any",
+    "notHasValue-any": "hasValue-any",
+    "hasValue-all": "notHasValue-all",
+    "notHasValue-all": "hasValue-all",
+    "hasKeyValue-any": "notHasKeyValue-any",
+    "notHasKeyValue-any": "hasKeyValue-any",
+    "hasKeyValue-all": "notHasKeyValue-all",
+    "notHasKeyValue-all": "hasKeyValue-all",
     in: "notIn",
     notIn: "in"
   } satisfies Record<Ops, Ops>
@@ -165,7 +244,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 +253,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 +268,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 +276,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 +293,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 +312,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,40 +350,182 @@ export function buildWhereCosmosQuery3(
           ? getValues(_.result)
           : [_]
       )
-  const values = getValues(filter)
+  const computedFilters = select
+    ? select.flatMap((_) =>
+      typeof _ === "object" && "computed" in _ && "filter" in _.computed ? getValues(_.computed.filter) : []
+    )
+    : []
+  const aggregateFilters = select
+    ? select.flatMap((_) =>
+      typeof _ === "object" && "aggregate" in _ && "filter" in _.aggregate ? getValues(_.aggregate.filter) : []
+    )
+    : []
+  const values = [...computedFilters, ...aggregateFilters, ...getValues(filter)]
+
+  const hasAggregates = select
+    ? select.some((s) => typeof s === "object" && s !== null && "aggregate" in s)
+    : false
+
+  const aggregateSelectExpr = (key: string, agg: AggregateIrExpression): string => {
+    switch (agg._tag) {
+      case "agg-count":
+        return `COUNT(1) AS ${key}`
+      case "agg-count-when": {
+        if (agg.filter.length === 0) return `COUNT(1) AS ${key}`
+        const cond = print(agg.filter, null, false)
+        // Cosmos supports SUM(IIF(cond, 1, 0)) as a conditional count
+        return `SUM(IIF(${cond}, 1, 0)) AS ${key}`
+      }
+      case "agg-sum": {
+        const fieldRef = dottedToAccess(`f.${agg.field}`)
+        return `SUM(${fieldRef}) AS ${key}`
+      }
+      case "agg-min": {
+        const fieldRef = dottedToAccess(`f.${agg.field}`)
+        return `MIN(${fieldRef}) AS ${key}`
+      }
+      case "agg-max": {
+        const fieldRef = dottedToAccess(`f.${agg.field}`)
+        return `MAX(${fieldRef}) AS ${key}`
+      }
+      default:
+        return assertUnreachable(agg)
+    }
+  }
+
+  const computedSelectExpr = (key: string, computed: ComputedProjectionIrExpression) => {
+    const relationPath = computed.path
+    const relationAlias = relationPath
+    const relationSource = dottedToAccess(`f.${relationPath}`)
+    const compileExpr = (expression: ComputedProjectionMathIrExpression): string => {
+      switch (expression._tag) {
+        case "field":
+          return dottedToAccess(`${relationAlias}.${expression.field}`)
+        case "mul":
+          return `(${compileExpr(expression.left)} * ${compileExpr(expression.right)})`
+        default:
+          return assertUnreachable(expression)
+      }
+    }
+    const factorExpr = (unitExpr: string, toBase: string, factors: Readonly<Record<string, number>>) => {
+      const entries = Object.entries(factors).filter(([, factor]) => Number.isFinite(factor))
+      return entries.reduceRight<string>(
+        (acc, [unit, factor]) => `IIF(${unitExpr} = ${JSON.stringify(unit)}, ${factor}, ${acc})`,
+        `IIF(${unitExpr} = ${JSON.stringify(toBase)}, 1, 0)`
+      )
+    }
+    const filter = "filter" in computed ? computed.filter : []
+    // Print filter once — `print` mutates the outer `i` parameter counter, so
+    // re-walking the same filter would double-bump it and desync @v indices.
+    const filterSql = filter.length > 0 ? print(filter, relationPath, false) : ""
+    const where = filterSql ? ` WHERE ${filterSql}` : ""
+    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 (filter.length === 0) return `true AS ${key}`
+        return `NOT EXISTS(SELECT VALUE ${relationAlias} FROM ${relationAlias} IN ${relationSource} WHERE NOT (${filterSql})) 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-sum-expr": {
+        const expression = compileExpr(computed.expression)
+        return `(SELECT VALUE SUM(${expression}) FROM ${relationAlias} IN ${relationSource}${where}) AS ${key}`
+      }
+      case "relation-sum-expr-by": {
+        const unitRef = dottedToAccess(`${relationAlias}.${computed.unit}`)
+        const expression = compileExpr(computed.expression)
+        return `ARRAY(SELECT VALUE { "unit": ${unitRef}, "total": SUM(${expression}) } FROM ${relationAlias} IN ${relationSource}${where} GROUP BY ${unitRef}) AS ${key}`
+      }
+      case "relation-sum-expr-normalized": {
+        const unitRef = dottedToAccess(`${relationAlias}.${computed.unit}`)
+        const expression = compileExpr(computed.expression)
+        const factor = factorExpr(unitRef, computed.toBase, computed.factors)
+        return `(SELECT VALUE SUM((${expression}) * (${factor})) 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}`
+      }
+      case "relation-length":
+        return `ARRAY_LENGTH(${relationSource}) AS ${key}`
+      case "relation-collect-fields": {
+        const subqueries = computed.fields.map((field) => {
+          const fieldRef = dottedToAccess(`${relationAlias}.${field}`)
+          return computed.distinct
+            ? `ARRAY(SELECT DISTINCT VALUE ${fieldRef} FROM ${relationAlias} IN ${relationSource}${where})`
+            : `ARRAY(SELECT VALUE ${fieldRef} FROM ${relationAlias} IN ${relationSource}${where})`
+        })
+        const combined = computed.distinct
+          ? subqueries.reduce((acc, sq) => `SetUnion(${acc}, ${sq})`)
+          : subqueries.reduce((acc, sq) => `ARRAY_CONCAT(${acc}, ${sq})`)
+        return `${combined} AS ${key}`
+      }
+    }
+  }
+
+  const buildSelectList = (): string => {
+    if (!select) return "f"
+    return select
+      .map((s) => {
+        if (typeof s === "string") {
+          return dottedToAccess(s === idKey ? "f.id" : `f.${s}`)
+        }
+        if ("computed" in s) return computedSelectExpr(s.key, s.computed)
+        if ("aggregate" in s) return aggregateSelectExpr(s.key, s.aggregate)
+        if ("path" in s) return `${dottedToAccess(`f.${s.path}`)} AS ${s.key}`
+        // subKeys
+        return `ARRAY (SELECT ${s.subKeys.map((_) => dottedToAccess(`t.${_}`)).join(",")}
+                FROM t in ${dottedToAccess(`f.${s.key}`)}) AS ${s.key}`
+      })
+      .join(", ")
+  }
+
+  const groupByClause = hasAggregates && select
+    ? (() => {
+      const groupByExprs = select
+        .filter((s): s is { key: string; path: string } =>
+          typeof s === "object" && s !== null && "path" in s && !("aggregate" in s)
+        )
+        .map((s) => dottedToAccess(`f.${s.path}`))
+      return groupByExprs.length > 0 ? `GROUP BY ${groupByExprs.join(", ")}` : ""
+    })()
+    : ""
+
+  const orderExpr = (key: string) => hasAggregates ? key : dottedToAccess(`f.${key}`)
+
   // with joins, you should use DISTINCT
   // or you can end up with duplicates
   return {
     query: `
-    SELECT ${
-      select
-        ? `${
-          select
-            .map((s) =>
-              typeof s === "string"
-                ? dottedToAccess(s === idKey ? "f.id" : `f.${s}`) // x["y"} vs x.y, helps with reserved keywords like "value"
-                : `ARRAY (SELECT ${s.subKeys.map((_) => dottedToAccess(`t.${_}`)).join(",")}
-                FROM t in ${dottedToAccess(`f.${s.key}`)}) AS ${s.key}`
-            )
-            .join(", ")
-        }`
-        : "f"
-    }
+    SELECT ${buildSelectList()}
     FROM ${name} f
 
-    ${filter.length ? `WHERE (${print(filter, values.map((_) => _.value), null, false)})` : ""}
-    ${order ? `ORDER BY ${order.map((_) => `${dottedToAccess(`f.${_.key}`)} ${_.direction}`).join(", ")}` : ""}
+    ${filter.length ? `WHERE (${print(filter, null, false)})` : ""}
+    ${groupByClause}
+    ${order ? `ORDER BY ${order.map((_) => `${orderExpr(_.key)} ${_.direction}`).join(", ")}` : ""}
     ${skip !== undefined || limit !== undefined ? `OFFSET ${skip ?? 0} LIMIT ${limit ?? 999999}` : ""}`,
-    parameters: [
-      ...values
-        .flatMap((x, i) =>
-          [{
-            name: `@v${i}`,
-            value: x.value as any
-          }]
-            // TODO: only for arrays that are used with _ANY or _ALL
-            .concat(Array.isArray(x.value) ? x.value.map((_, i2) => ({ name: `@v${i}__${i2}`, value: _ as any })) : [])
-        )
-    ]
+    parameters: values
+      .flatMap((x, i) =>
+        [{
+          name: `@v${i}`,
+          value: x.value as any
+        }]
+          // TODO: only for arrays that are used with _ANY or _ALL
+          .concat(Array.isArray(x.value) ? x.value.map((_, i2) => ({ name: `@v${i}__${i2}`, value: _ as any })) : [])
+      )
   }
 }