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

package/src/Model/query/dsl.ts

@@ -100,6 +100,17 @@ export type QueryProjection<
 
 export type ComputedProjectionOperation = (q: Query<any>) => QueryWhere<any, any, any>
 
+export type ComputedProjectionMathExpression =
+  | {
+    readonly _tag: "field"
+    readonly field: string
+  }
+  | {
+    readonly _tag: "mul"
+    readonly left: ComputedProjectionMathExpression
+    readonly right: ComputedProjectionMathExpression
+  }
+
 export type ComputedProjectionExpression =
   | {
     readonly _tag: "relation-count"
@@ -128,6 +139,28 @@ export type ComputedProjectionExpression =
     readonly field: string
     readonly operation?: ComputedProjectionOperation
   }
+  | {
+    readonly _tag: "relation-sum-expr"
+    readonly path: string
+    readonly expression: ComputedProjectionMathExpression
+    readonly operation?: ComputedProjectionOperation
+  }
+  | {
+    readonly _tag: "relation-sum-expr-by"
+    readonly path: string
+    readonly expression: ComputedProjectionMathExpression
+    readonly unit: string
+    readonly operation?: ComputedProjectionOperation
+  }
+  | {
+    readonly _tag: "relation-sum-expr-normalized"
+    readonly path: string
+    readonly expression: ComputedProjectionMathExpression
+    readonly unit: string
+    readonly toBase: string
+    readonly factors: Readonly<Record<string, number>>
+    readonly operation?: ComputedProjectionOperation
+  }
   | {
     readonly _tag: "relation-collect"
     readonly path: string
@@ -482,6 +515,64 @@ export const relation = <TFieldValues extends FieldValues>(
         path: path as string,
         field
       },
+  sumExpr: (
+    expression: ComputedProjectionMathExpression,
+    operation?: ComputedProjectionOperation
+  ): ComputedProjectionExpression =>
+    operation
+      ? {
+        _tag: "relation-sum-expr",
+        path: path as string,
+        expression,
+        operation
+      }
+      : {
+        _tag: "relation-sum-expr",
+        path: path as string,
+        expression
+      },
+  sumExprBy: (
+    expression: ComputedProjectionMathExpression,
+    options: { unit: string },
+    operation?: ComputedProjectionOperation
+  ): ComputedProjectionExpression =>
+    operation
+      ? {
+        _tag: "relation-sum-expr-by",
+        path: path as string,
+        expression,
+        unit: options.unit,
+        operation
+      }
+      : {
+        _tag: "relation-sum-expr-by",
+        path: path as string,
+        expression,
+        unit: options.unit
+      },
+  sumExprNormalized: (
+    expression: ComputedProjectionMathExpression,
+    options: { unit: string; toBase: string; factors: Readonly<Record<string, number>> },
+    operation?: ComputedProjectionOperation
+  ): ComputedProjectionExpression =>
+    operation
+      ? {
+        _tag: "relation-sum-expr-normalized",
+        path: path as string,
+        expression,
+        unit: options.unit,
+        toBase: options.toBase,
+        factors: options.factors,
+        operation
+      }
+      : {
+        _tag: "relation-sum-expr-normalized",
+        path: path as string,
+        expression,
+        unit: options.unit,
+        toBase: options.toBase,
+        factors: options.factors
+      },
   collect: (field: string, operation?: ComputedProjectionOperation): ComputedProjectionExpression =>
     operation
       ? {
@@ -514,6 +605,14 @@ export const relation = <TFieldValues extends FieldValues>(
       }
 })
 
+export const expr = {
+  field: (field: string): ComputedProjectionMathExpression => ({ _tag: "field", field }),
+  mul: (
+    left: ComputedProjectionMathExpression,
+    right: ComputedProjectionMathExpression
+  ): ComputedProjectionMathExpression => ({ _tag: "mul", left, right })
+} as const
+
 export const computed = <T extends ComputedProjectionMap>(value: T): T => value
 
 export const projectComputed: {

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

@@ -8,6 +8,17 @@ 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 ComputedProjectionMathIrExpression =
+  | {
+    readonly _tag: "field"
+    readonly field: string
+  }
+  | {
+    readonly _tag: "mul"
+    readonly left: ComputedProjectionMathIrExpression
+    readonly right: ComputedProjectionMathIrExpression
+  }
+
 export type ComputedProjectionIrExpression =
   | {
     readonly _tag: "relation-count"
@@ -36,6 +47,28 @@ export type ComputedProjectionIrExpression =
     readonly field: string
     readonly filter: readonly FilterResult[]
   }
+  | {
+    readonly _tag: "relation-sum-expr"
+    readonly path: string
+    readonly expression: ComputedProjectionMathIrExpression
+    readonly filter: readonly FilterResult[]
+  }
+  | {
+    readonly _tag: "relation-sum-expr-by"
+    readonly path: string
+    readonly expression: ComputedProjectionMathIrExpression
+    readonly unit: string
+    readonly filter: readonly FilterResult[]
+  }
+  | {
+    readonly _tag: "relation-sum-expr-normalized"
+    readonly path: string
+    readonly expression: ComputedProjectionMathIrExpression
+    readonly unit: string
+    readonly toBase: string
+    readonly factors: Readonly<Record<string, number>>
+    readonly filter: readonly FilterResult[]
+  }
   | {
     readonly _tag: "relation-collect"
     readonly path: string
@@ -197,6 +230,35 @@ const interpret = <
                     key,
                     { _tag: e._tag, path: e.path, field: e.field, filter } as ComputedProjectionIrExpression
                   ]
+                case "relation-sum-expr":
+                  return [
+                    key,
+                    { _tag: e._tag, path: e.path, expression: e.expression, filter } as ComputedProjectionIrExpression
+                  ]
+                case "relation-sum-expr-by":
+                  return [
+                    key,
+                    {
+                      _tag: e._tag,
+                      path: e.path,
+                      expression: e.expression,
+                      unit: e.unit,
+                      filter
+                    } as ComputedProjectionIrExpression
+                  ]
+                case "relation-sum-expr-normalized":
+                  return [
+                    key,
+                    {
+                      _tag: e._tag,
+                      path: e.path,
+                      expression: e.expression,
+                      unit: e.unit,
+                      toBase: e.toBase,
+                      factors: e.factors,
+                      filter
+                    } as ComputedProjectionIrExpression
+                  ]
                 case "relation-collect":
                   return [
                     key,

package/src/Store/Cosmos/query.ts

@@ -4,7 +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 type { ComputedProjectionIrExpression, ComputedProjectionMathIrExpression } from "../../Model/query.js"
 import { isRelationCheck } from "../codeFilter.js"
 import type { SupportedValues } from "../service.js"
 
@@ -295,6 +295,23 @@ export function buildWhereCosmosQuery3(
     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)}`
       : ""
@@ -319,6 +336,21 @@ export function buildWhereCosmosQuery3(
         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) {

package/src/Store/Memory.ts

@@ -6,7 +6,7 @@ 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 type { ComputedProjectionIrExpression, ComputedProjectionMathIrExpression } 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"
@@ -37,7 +37,11 @@ const emptyValueFor = (tag: ComputedProjectionIrExpression["_tag"]) => {
     case "relation-count":
     case "relation-distinct-count":
     case "relation-sum":
+    case "relation-sum-expr":
+    case "relation-sum-expr-normalized":
       return 0
+    case "relation-sum-expr-by":
+      return [] as unknown[]
     case "relation-any":
       return false
     case "relation-every":
@@ -63,6 +67,18 @@ const computeProjectionValue = (
   const matches = filter.length === 0
     ? (_value: unknown) => true
     : (value: unknown) => codeFilter3_(filter, value)
+  const evalExpr = (value: unknown, expression: ComputedProjectionMathIrExpression): number => {
+    switch (expression._tag) {
+      case "field": {
+        const v = get(value, expression.field)
+        return typeof v === "number" ? v : Number(v) || 0
+      }
+      case "mul":
+        return evalExpr(value, expression.left) * evalExpr(value, expression.right)
+      default:
+        return assertUnreachable(expression)
+    }
+  }
   switch (computed._tag) {
     case "relation-count":
       return relation.reduce<number>((acc, value) => matches(value) ? acc + 1 : acc, 0)
@@ -83,6 +99,29 @@ const computeProjectionValue = (
         const v = get(value, computed.field)
         return acc + (typeof v === "number" ? v : Number(v) || 0)
       }, 0)
+    case "relation-sum-expr":
+      return relation.reduce<number>((acc, value) => {
+        if (!matches(value)) return acc
+        return acc + evalExpr(value, computed.expression)
+      }, 0)
+    case "relation-sum-expr-by": {
+      const totals = new Map<unknown, number>()
+      for (const value of relation) {
+        if (!matches(value)) continue
+        const unit = get(value, computed.unit)
+        const current = totals.get(unit) ?? 0
+        totals.set(unit, current + evalExpr(value, computed.expression))
+      }
+      return [...totals.entries()].map(([unit, total]) => ({ unit, total }))
+    }
+    case "relation-sum-expr-normalized":
+      return relation.reduce<number>((acc, value) => {
+        if (!matches(value)) return acc
+        const unit = get(value, computed.unit)
+        const factor = unit === computed.toBase ? 1 : computed.factors[String(unit)]
+        if (factor === undefined || !Number.isFinite(factor)) return acc
+        return acc + evalExpr(value, computed.expression) * factor
+      }, 0)
     case "relation-collect": {
       const out: unknown[] = []
       const seen = computed.distinct ? new Set<unknown>() : undefined

package/src/Store/SQL/query.ts

@@ -3,7 +3,7 @@ import { Effect, type NonEmptyReadonlyArray } from "effect-app"
 import { assertUnreachable } from "effect-app/utils"
 import { InfraLogger } from "../../logger.js"
 import type { FilterR, FilterResult } from "../../Model/filter/filterApi.js"
-import type { ComputedProjectionIrExpression } from "../../Model/query.js"
+import type { ComputedProjectionIrExpression, ComputedProjectionMathIrExpression } from "../../Model/query.js"
 import { isRelationCheck } from "../codeFilter.js"
 
 export interface SQLDialect {
@@ -148,6 +148,8 @@ const dottedToJsonPath = (path: string) =>
     .filter((p) => p !== "-1")
     .join(".")
 
+const sqlStringLiteral = (value: string) => `'${value.replaceAll("'", "''")}'`
+
 export function buildWhereSQLQuery(
   dialect: SQLDialect,
   idKey: PropertyKey,
@@ -165,7 +167,8 @@ export function buildWhereSQLQuery(
   >,
   order?: NonEmptyReadonlyArray<{ key: string; direction: "ASC" | "DESC" }>,
   skip?: number,
-  limit?: number
+  limit?: number,
+  namespace?: string
 ) {
   const params: unknown[] = []
   let paramIndex = 1
@@ -391,6 +394,23 @@ export function buildWhereSQLQuery(
     const relationPath = dottedToJsonPath(computed.path)
     const relationAlias = `_${computed.path}`
     const relationFrom = dialect.jsonEachFrom(relationPath, relationAlias)
+    const toNumber = (expr: string) =>
+      dialect.jsonColumnType === "JSON" ? `CAST(${expr} AS REAL)` : `(${expr})::numeric`
+    const compileExpr = (expression: ComputedProjectionMathIrExpression): string => {
+      switch (expression._tag) {
+        case "field":
+          return toNumber(dialect.jsonExtractElement(relationAlias, expression.field))
+        case "mul":
+          return `(${compileExpr(expression.left)} * ${compileExpr(expression.right)})`
+        default:
+          return assertUnreachable(expression)
+      }
+    }
+    const factorCaseExpr = (unitExpr: string, toBase: string, factors: Readonly<Record<string, number>>) => {
+      const entries = Object.entries(factors).filter(([, factor]) => Number.isFinite(factor))
+      const cases = entries.map(([unit, factor]) => ` WHEN ${sqlStringLiteral(unit)} THEN ${factor}`).join("")
+      return `CASE ${unitExpr} WHEN ${sqlStringLiteral(toBase)} THEN 1${cases} ELSE NULL END`
+    }
     const whereClause = () =>
       computed.filter.length > 0
         ? ` WHERE ${print(computed.filter, computed.path, false)}`
@@ -417,10 +437,25 @@ export function buildWhereSQLQuery(
       }
       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}"`
+        return `(SELECT COALESCE(SUM(${toNumber(fieldExtract)}), 0) FROM ${relationFrom}${whereClause()}) AS "${key}"`
+      }
+      case "relation-sum-expr": {
+        const expression = compileExpr(computed.expression)
+        return `(SELECT COALESCE(SUM(${expression}), 0) FROM ${relationFrom}${whereClause()}) AS "${key}"`
+      }
+      case "relation-sum-expr-by": {
+        const expression = compileExpr(computed.expression)
+        const unitExpr = dialect.jsonExtractElement(relationAlias, computed.unit)
+        if (dialect.jsonColumnType === "JSON") {
+          return `(SELECT COALESCE(json_group_array(json_object('unit', __unit, 'total', __total)), json_array()) FROM (SELECT ${unitExpr} AS __unit, COALESCE(SUM(${expression}), 0) AS __total FROM ${relationFrom}${whereClause()} GROUP BY ${unitExpr})) AS "${key}"`
+        }
+        return `(SELECT COALESCE(jsonb_agg(jsonb_build_object('unit', __unit, 'total', __total)), '[]'::jsonb) FROM (SELECT ${unitExpr} AS __unit, COALESCE(SUM(${expression}), 0) AS __total FROM ${relationFrom}${whereClause()} GROUP BY ${unitExpr}) __grouped) AS "${key}"`
+      }
+      case "relation-sum-expr-normalized": {
+        const expression = compileExpr(computed.expression)
+        const unitExpr = dialect.jsonExtractElement(relationAlias, computed.unit)
+        const factorExpr = factorCaseExpr(unitExpr, computed.toBase, computed.factors)
+        return `(SELECT COALESCE(SUM((${expression}) * (${factorExpr})), 0) FROM ${relationFrom}${whereClause()}) AS "${key}"`
       }
       case "relation-collect": {
         const fieldExtract = dialect.jsonExtractElement(relationAlias, computed.field)
@@ -455,8 +490,22 @@ export function buildWhereSQLQuery(
     return fields.join(", ")
   }
 
-  const whereClause = filter.length
-    ? `WHERE ${print([{ t: "where-scope", result: filter, relation: "some" }], null, false)}`
+  // Order matters: projection params must be emitted BEFORE user-filter
+  // params so positional `?` placeholders in SQLite match `params[]` order.
+  const selectExpr = getSelectExpr()
+
+  const namespaceClause = namespace !== undefined
+    ? `_namespace = ${addParam(namespace)}`
+    : ""
+  const userWhere = filter.length
+    ? print([{ t: "where-scope", result: filter, relation: "some" }], null, false)
+    : ""
+  const whereClause = namespaceClause && userWhere
+    ? `WHERE ${namespaceClause} AND ${userWhere}`
+    : namespaceClause
+    ? `WHERE ${namespaceClause}`
+    : userWhere
+    ? `WHERE ${userWhere}`
     : ""
 
   const orderClause = order
@@ -467,7 +516,7 @@ export function buildWhereSQLQuery(
     ? `LIMIT ${addParam(limit ?? 999999)} OFFSET ${addParam(skip ?? 0)}`
     : ""
 
-  const sql = `SELECT ${getSelectExpr()} FROM "${tableName}" ${whereClause} ${orderClause} ${limitClause}`.trim()
+  const sql = `SELECT ${selectExpr} FROM "${tableName}" ${whereClause} ${orderClause} ${limitClause}`.trim()
 
   return { sql, params }
 }

package/src/Store/SQL.ts

@@ -229,7 +229,7 @@ function makeSQLStoreInt(system: DbSystem, dialect: SQLDialect, jsonColumnType:
                 .flatMap((ns) =>
                   Effect
                     .sync(() => {
-                      const q = buildWhereSQLQuery(
+                      return buildWhereSQLQuery(
                         dialect,
                         idKey,
                         filter ? [{ t: "where-scope", result: filter, relation: "some" }] : [],
@@ -252,29 +252,9 @@ function makeSQLStoreInt(system: DbSystem, dialect: SQLDialect, jsonColumnType:
                         f
                           .skip,
                         f
-                          .limit
+                          .limit,
+                        ns
                       )
-                      const hasWhere = q
-                        .sql
-                        .includes("WHERE")
-                      const nsSql = hasWhere
-                        ? q
-                          .sql
-                          .replace("WHERE", `WHERE _namespace = ? AND`)
-                        : q
-                          .sql
-                          .replace(
-                            `FROM "${tableName}"`,
-                            `FROM "${tableName}" WHERE _namespace = ?`
-                          )
-                      return {
-                        sql: nsSql,
-                        params: [
-                          ns,
-                          ...q
-                            .params
-                        ]
-                      }
                     })
                     .pipe(
                       Effect

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,EAA2C,MAAM,YAAY,CAAA;AASjI,eAAO,MAAM,EAAE,6CAWb,CAAA"}
+{"version":3,"file":"rawQuery.test.d.ts","sourceRoot":"","sources":["../rawQuery.test.ts"],"names":[],"mappings":"AAEA,OAAO,EAA+C,cAAc,EAA2C,MAAM,YAAY,CAAA;AAUjI,eAAO,MAAM,EAAE,6CAWb,CAAA"}

package/test/query.test.ts

@@ -6,7 +6,7 @@ import { Context, Effect, flow, Layer, Option, pipe, S, Struct } from "effect-ap
 import { inspect } from "util"
 import { expect, expectTypeOf, it } from "vitest"
 import { setupRequestContextFromCurrent } from "../src/api/setupRequest.js"
-import { and, computed, count, make, one, or, order, page, project, projectComputed, type QueryEnd, type QueryProjection, type QueryWhere, relation, toFilter, where } from "../src/Model/query.js"
+import { and, computed, count, expr, make, one, or, order, page, project, projectComputed, type QueryEnd, type QueryProjection, type QueryWhere, relation, toFilter, where } from "../src/Model/query.js"
 import { makeRepo } from "../src/Model/Repository.js"
 import { RepositoryRegistryLive } from "../src/Model/Repository/Registry.js"
 import { memFilter, MemoryStoreLive } from "../src/Store/Memory.js"
@@ -730,6 +730,61 @@ it("projectComputed.collect / collectDistinct emit relation-collect IR", () => {
   expect((distinct as { distinct: boolean } | undefined)?.distinct).toBe(true)
 })
 
+it("projectComputed.sumExpr emits relation-sum-expr IR", () => {
+  const baseSchema = S.Struct({
+    id: S.String,
+    items: S.Array(S.Struct({
+      weight: S.Number,
+      tradeUnit: S.Struct({ amount: S.Number, unit: S.String })
+    }))
+  })
+  const query = make<S.Codec.Encoded<typeof baseSchema>>().pipe(
+    projectComputed(
+      S.Struct({ total: S.Number }),
+      computed({
+        total: relation<S.Codec.Encoded<typeof baseSchema>>("items").sumExpr(
+          expr.mul(expr.field("weight"), expr.field("tradeUnit.amount"))
+        )
+      })
+    )
+  )
+  const interpreted = toFilter(query, baseSchema)
+  const ir = interpreted.computed?.["total"]
+  expect(ir?._tag).toBe("relation-sum-expr")
+  expect((ir as { expression: unknown } | undefined)?.expression).toEqual({
+    _tag: "mul",
+    left: { _tag: "field", field: "weight" },
+    right: { _tag: "field", field: "tradeUnit.amount" }
+  })
+})
+
+it("projectComputed.sumExprBy emits relation-sum-expr-by IR", () => {
+  const baseSchema = S.Struct({
+    id: S.String,
+    items: S.Array(S.Struct({
+      weight: S.Number,
+      tradeUnit: S.Struct({ amount: S.Number, unit: S.String })
+    }))
+  })
+  const query = make<S.Codec.Encoded<typeof baseSchema>>().pipe(
+    projectComputed(
+      S.Struct({
+        totals: S.Array(S.Struct({ unit: S.String, total: S.Number }))
+      }),
+      computed({
+        totals: relation<S.Codec.Encoded<typeof baseSchema>>("items").sumExprBy(
+          expr.mul(expr.field("weight"), expr.field("tradeUnit.amount")),
+          { unit: "tradeUnit.unit" }
+        )
+      })
+    )
+  )
+  const interpreted = toFilter(query, baseSchema)
+  const ir = interpreted.computed?.["totals"]
+  expect(ir?._tag).toBe("relation-sum-expr-by")
+  expect((ir as { unit: string } | undefined)?.unit).toBe("tradeUnit.unit")
+})
+
 it(
   "doesn't mess when refining fields",
   () =>
@@ -1584,6 +1639,57 @@ it("memFilter: computed projection with multi-statement relation filter", () =>
   ])
 })
 
+it("memFilter: relation-sum-expr / sum-expr-by / sum-expr-normalized", () => {
+  const schema = S.Struct({
+    id: S.String,
+    items: S.Array(S.Struct({
+      weight: S.Finite,
+      tradeUnit: S.Struct({ amount: S.Finite, unit: S.String })
+    }))
+  })
+  type Row = S.Codec.Encoded<typeof schema>
+  const rows: Row[] = [
+    {
+      id: "r1",
+      items: [
+        { weight: 2, tradeUnit: { amount: 5, unit: "kg" } },
+        { weight: 4, tradeUnit: { amount: 1000, unit: "g" } },
+        { weight: 3, tradeUnit: { amount: 1, unit: "kg" } }
+      ]
+    },
+    { id: "r2", items: [] }
+  ]
+  const weighted = expr.mul(expr.field("weight"), expr.field("tradeUnit.amount"))
+  const q = make<Row>().pipe(
+    projectComputed(
+      S.Struct({
+        id: S.String,
+        totalRaw: S.Finite,
+        totalsByUnit: S.Array(S.Struct({ unit: S.String, total: S.Finite })),
+        totalKg: S.Finite
+      }),
+      computed({
+        totalRaw: relation<Row>("items").sumExpr(weighted, where("weight", "gte", 0)),
+        totalsByUnit: relation<Row>("items").sumExprBy(weighted, { unit: "tradeUnit.unit" }, where("weight", "gte", 0)),
+        totalKg: relation<Row>("items").sumExprNormalized(weighted, {
+          unit: "tradeUnit.unit",
+          toBase: "kg",
+          factors: { g: 0.001 }
+        }, where("weight", "gte", 0))
+      })
+    )
+  )
+  expect(memFilter(toFilter(q, schema))(rows)).toEqual([
+    {
+      id: "r1",
+      totalRaw: 4013,
+      totalsByUnit: [{ unit: "kg", total: 13 }, { unit: "g", total: 4000 }],
+      totalKg: 17
+    },
+    { id: "r2", totalRaw: 0, totalsByUnit: [], totalKg: 0 }
+  ])
+})
+
 it("memFilter: computed projection combined with root where filter", () => {
   const q = make<ComputedBase>().pipe(
     where("id", "neq", "r3"),
@@ -1680,8 +1786,7 @@ const cfRows: CFRow[] = [
   { id: "4", tag: "y", qty: 30, desc: "World cup", tags: [], nested: { kind: "k2", v: 0 } }
 ]
 
-const runCF = (q: any) =>
-  (memFilter(toFilter(q))(cfRows) as unknown as readonly CFRow[]).map((_) => _.id)
+const runCF = (q: any) => (memFilter(toFilter(q))(cfRows) as unknown as readonly CFRow[]).map((_) => _.id)
 
 it("codeFilter: where + and chain", () => {
   const q = make<CFRow>().pipe(