@effect-app/infra 4.0.0-beta.26 → 4.0.0-beta.260

package/src/Store/Cosmos/query.ts

@@ -1,11 +1,14 @@
 /* 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"
 
 export function logQuery(q: {
   query: string
@@ -40,12 +43,26 @@ 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
 ) {
-  const statement = (x: FilterR, i: number, values: any[]) => {
+  const statement = (x: FilterR, i: number) => {
     if (x.path === idKey) {
       x = { ...x, path: "id" }
     }
@@ -60,8 +77,6 @@ export function buildWhereCosmosQuery3(
 
     const v = "@v" + i
 
-    const realValue = values[i]
-
     switch (x.op) {
       case "in":
         return `ARRAY_CONTAINS(${v}, ${k})`
@@ -74,14 +89,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 +188,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 +197,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 +212,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 +220,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 +237,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 +256,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 +294,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 })) : [])
+      )
   }
 }