@effect-app/infra 4.0.0-beta.213 → 4.0.0-beta.215

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

@@ -19,6 +19,30 @@ export type ComputedProjectionIrExpression =
     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[]
@@ -162,7 +186,29 @@ const interpret = <
             Object.entries(v.computed).map(([key, expression]) => {
               const e = expression
               const filter = e.operation ? interpret(e.operation(make())).filter.map(applyPath(e.path)) : []
-              return [key, { _tag: e._tag, path: e.path, filter } as const]
+              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

package/src/Store/Cosmos/query.ts

@@ -303,6 +303,29 @@ export function buildWhereCosmosQuery3(
         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

package/src/Store/Memory.ts

@@ -2,9 +2,11 @@
 
 import { Array, Context, Effect, flow, type NonEmptyReadonlyArray, Option, Order, pipe, Ref, Result, Semaphore, Struct } from "effect-app"
 import { NonEmptyString255 } from "effect-app/Schema"
+import { assertUnreachable } from "effect-app/utils"
 import { InfraLogger } from "../logger.js"
 import type { FilterResult } from "../Model/filter/filterApi.js"
 import type { FieldValues } from "../Model/filter/types.js"
+import type { ComputedProjectionIrExpression } from "../Model/query.js"
 import { annotateDb } from "../otel.js"
 import { codeFilter, codeFilter3_ } from "./codeFilter.js"
 import { type FilterArgs, type PersistenceModelType, type Store, type StoreConfig, StoreMaker } from "./service.js"
@@ -30,24 +32,73 @@ const stripRelationFilterPaths = (state: readonly FilterResult[], relationPath:
   )
 }
 
+const emptyValueFor = (tag: ComputedProjectionIrExpression["_tag"]) => {
+  switch (tag) {
+    case "relation-count":
+    case "relation-distinct-count":
+    case "relation-sum":
+      return 0
+    case "relation-any":
+      return false
+    case "relation-every":
+      return true
+    case "relation-collect":
+      return [] as unknown[]
+    default:
+      return assertUnreachable(tag)
+  }
+}
+
 const computeProjectionValue = (
   row: FieldValues,
-  computed: {
-    readonly _tag: "relation-count" | "relation-any"
-    readonly path: string
-    readonly filter: readonly FilterResult[]
-  }
+  computed: ComputedProjectionIrExpression
 ) => {
   const relation = get(row, computed.path)
   if (!Array.isArray(relation)) {
-    return computed._tag === "relation-count" ? 0 : false
+    return emptyValueFor(computed._tag)
   }
   const filter = stripRelationFilterPaths(computed.filter, computed.path)
+  // empty filter = unconditional match (codeFilter3_ uses eval on a built
+  // string and chokes on `( )`, so short-circuit before invoking it).
+  const matches = filter.length === 0
+    ? (_value: unknown) => true
+    : (value: unknown) => codeFilter3_(filter, value)
   switch (computed._tag) {
     case "relation-count":
-      return relation.reduce<number>((acc, value) => codeFilter3_(filter, value) ? acc + 1 : acc, 0)
+      return relation.reduce<number>((acc, value) => matches(value) ? acc + 1 : acc, 0)
     case "relation-any":
-      return relation.some((value) => codeFilter3_(filter, value))
+      return relation.some(matches)
+    case "relation-every":
+      return relation.every(matches)
+    case "relation-distinct-count": {
+      const seen = new Set<unknown>()
+      for (const value of relation) {
+        if (matches(value)) seen.add(get(value, computed.field))
+      }
+      return seen.size
+    }
+    case "relation-sum":
+      return relation.reduce<number>((acc, value) => {
+        if (!matches(value)) return acc
+        const v = get(value, computed.field)
+        return acc + (typeof v === "number" ? v : Number(v) || 0)
+      }, 0)
+    case "relation-collect": {
+      const out: unknown[] = []
+      const seen = computed.distinct ? new Set<unknown>() : undefined
+      for (const value of relation) {
+        if (!matches(value)) continue
+        const v = get(value, computed.field)
+        if (seen) {
+          if (seen.has(v)) continue
+          seen.add(v)
+        }
+        out.push(v)
+      }
+      return out
+    }
+    default:
+      return assertUnreachable(computed)
   }
 }
 
@@ -67,11 +118,7 @@ export function memFilter<T extends FieldValues, U extends keyof T = never>(f: F
         )
         const computedKeys = entries.filter((entry): entry is {
           key: string
-          computed: {
-            readonly _tag: "relation-count" | "relation-any"
-            readonly path: string
-            readonly filter: readonly FilterResult[]
-          }
+          computed: ComputedProjectionIrExpression
         } => typeof entry === "object" && entry !== null && "computed" in entry)
         const n = Struct.pick(i, keys)
         subKeys.forEach((subKey) => {

package/src/Store/SQL/query.ts

@@ -391,18 +391,48 @@ export function buildWhereSQLQuery(
     const relationPath = dottedToJsonPath(computed.path)
     const relationAlias = `_${computed.path}`
     const relationFrom = dialect.jsonEachFrom(relationPath, relationAlias)
-    const where = computed.filter.length > 0
-      ? ` WHERE ${print(computed.filter, computed.path, false)}`
-      : ""
+    const whereClause = () =>
+      computed.filter.length > 0
+        ? ` WHERE ${print(computed.filter, computed.path, false)}`
+        : ""
+    const boolExpr = (sqlExpr: string) =>
+      dialect.jsonColumnType === "JSON"
+        ? `CASE WHEN ${sqlExpr} THEN 'true' ELSE 'false' END AS "${key}"`
+        : `${sqlExpr} AS "${key}"`
     switch (computed._tag) {
       case "relation-count":
-        return `(SELECT COUNT(1) FROM ${relationFrom}${where}) AS "${key}"`
-      case "relation-any": {
-        const existsExpr = `EXISTS(SELECT 1 FROM ${relationFrom}${where})`
+        return `(SELECT COUNT(1) FROM ${relationFrom}${whereClause()}) AS "${key}"`
+      case "relation-any":
+        return boolExpr(`EXISTS(SELECT 1 FROM ${relationFrom}${whereClause()})`)
+      case "relation-every":
+        // ∀x.P(x) ≡ ¬∃x.¬P(x). When no filter, no element exists that violates ⊤ → true.
+        return boolExpr(
+          computed.filter.length === 0
+            ? `1=1`
+            : `NOT EXISTS(SELECT 1 FROM ${relationFrom} WHERE NOT (${print(computed.filter, computed.path, false)}))`
+        )
+      case "relation-distinct-count": {
+        const fieldExtract = dialect.jsonExtractElement(relationAlias, computed.field)
+        return `(SELECT COUNT(DISTINCT ${fieldExtract}) FROM ${relationFrom}${whereClause()}) AS "${key}"`
+      }
+      case "relation-sum": {
+        const fieldExtract = dialect.jsonExtractElement(relationAlias, computed.field)
+        const cast = dialect.jsonColumnType === "JSON"
+          ? `CAST(${fieldExtract} AS REAL)`
+          : `(${fieldExtract})::numeric`
+        return `(SELECT COALESCE(SUM(${cast}), 0) FROM ${relationFrom}${whereClause()}) AS "${key}"`
+      }
+      case "relation-collect": {
+        const fieldExtract = dialect.jsonExtractElement(relationAlias, computed.field)
         if (dialect.jsonColumnType === "JSON") {
-          return `CASE WHEN ${existsExpr} THEN 'true' ELSE 'false' END AS "${key}"`
+          // sqlite: json_group_array does not accept DISTINCT; emulate via inner DISTINCT subquery
+          if (computed.distinct) {
+            return `(SELECT COALESCE(json_group_array(__v), json_array()) FROM (SELECT DISTINCT ${fieldExtract} AS __v FROM ${relationFrom}${whereClause()})) AS "${key}"`
+          }
+          return `(SELECT COALESCE(json_group_array(${fieldExtract}), json_array()) FROM ${relationFrom}${whereClause()}) AS "${key}"`
         }
-        return `${existsExpr} AS "${key}"`
+        const aggArg = computed.distinct ? `DISTINCT ${fieldExtract}` : fieldExtract
+        return `(SELECT COALESCE(jsonb_agg(${aggArg}), '[]'::jsonb) FROM ${relationFrom}${whereClause()}) AS "${key}"`
       }
       default:
         return assertUnreachable(computed)

package/test/dist/rawQuery.test.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rawQuery.test.d.ts","sourceRoot":"","sources":["../rawQuery.test.ts"],"names":[],"mappings":"AACA,OAAO,EAA+C,cAAc,EAAmC,MAAM,YAAY,CAAA;AASzH,eAAO,MAAM,EAAE,6CAWb,CAAA"}
+{"version":3,"file":"rawQuery.test.d.ts","sourceRoot":"","sources":["../rawQuery.test.ts"],"names":[],"mappings":"AACA,OAAO,EAA+C,cAAc,EAA2C,MAAM,YAAY,CAAA;AASjI,eAAO,MAAM,EAAE,6CAWb,CAAA"}