@effect-app/infra 4.0.0-beta.22 → 4.0.0-beta.221

package/src/Store/Cosmos/query.ts

@@ -1,9 +1,12 @@
 /* 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 { assertUnreachable } from "effect-app/utils"
 import { InfraLogger } from "../../logger.js"
 import type { FilterR, FilterResult, Ops } from "../../Model/filter/filterApi.js"
+import type { ComputedProjectionIrExpression, ComputedProjectionMathIrExpression } from "../../Model/query.js"
 import { isRelationCheck } from "../codeFilter.js"
 import type { SupportedValues } from "../service.js"
 
@@ -40,12 +43,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 +71,6 @@ export function buildWhereCosmosQuery3(
 
     const v = "@v" + i
 
-    const realValue = values[i]
-
     switch (x.op) {
       case "in":
         return `ARRAY_CONTAINS(${v}, ${k})`
@@ -74,14 +83,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 +182,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 +191,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 +206,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 +214,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 +231,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 +250,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 +288,123 @@ 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 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 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-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-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}`
+      }
+    }
+  }
   // 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(",")}
+        ? select
+          .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}`
-            )
-            .join(", ")
-        }`
+          )
+          .join(", ")
         : "f"
     }
     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
-        .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 })) : [])
+      )
   }
 }