@effect-app/infra 4.0.0-beta.216 → 4.0.0-beta.218

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
@@ -43,6 +76,13 @@ export type ComputedProjectionIrExpression =
     readonly distinct: boolean
     readonly filter: readonly FilterResult[]
   }
+  | {
+    readonly _tag: "relation-collect-fields"
+    readonly path: string
+    readonly fields: readonly string[]
+    readonly distinct: boolean
+    readonly filter: readonly FilterResult[]
+  }
 
 type Result<TFieldValues extends FieldValues, A = TFieldValues, R = never> = {
   filter: FilterResult[]
@@ -197,6 +237,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,
@@ -208,6 +277,17 @@ const interpret = <
                       filter
                     } as ComputedProjectionIrExpression
                   ]
+                case "relation-collect-fields":
+                  return [
+                    key,
+                    {
+                      _tag: e._tag,
+                      path: e.path,
+                      fields: e.fields,
+                      distinct: e.distinct,
+                      filter
+                    } as ComputedProjectionIrExpression
+                  ]
               }
             })
           )

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) {
@@ -326,6 +358,18 @@ export function buildWhereCosmosQuery3(
         }
         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

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,13 +37,19 @@ 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":
       return true
     case "relation-collect":
       return [] as unknown[]
+    case "relation-collect-fields":
+      return [] as unknown[]
     default:
       return assertUnreachable(tag)
   }
@@ -63,6 +69,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 +101,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
@@ -97,6 +138,22 @@ const computeProjectionValue = (
       }
       return out
     }
+    case "relation-collect-fields": {
+      const out: unknown[] = []
+      const seen = computed.distinct ? new Set<unknown>() : undefined
+      for (const value of relation) {
+        if (!matches(value)) continue
+        for (const field of computed.fields) {
+          const v = get(value, field)
+          if (seen) {
+            if (seen.has(v)) continue
+            seen.add(v)
+          }
+          out.push(v)
+        }
+      }
+      return out
+    }
     default:
       return assertUnreachable(computed)
   }

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,
@@ -392,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)}`
@@ -418,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)
@@ -435,6 +469,23 @@ export function buildWhereSQLQuery(
         const aggArg = computed.distinct ? `DISTINCT ${fieldExtract}` : fieldExtract
         return `(SELECT COALESCE(jsonb_agg(${aggArg}), '[]'::jsonb) FROM ${relationFrom}${whereClause()}) AS "${key}"`
       }
+      case "relation-collect-fields": {
+        const branches = computed.fields.map((field) => {
+          const fieldExtract = dialect.jsonExtractElement(relationAlias, field)
+          return `SELECT ${fieldExtract} AS __v FROM ${relationFrom}${whereClause()}`
+        })
+        const unionQuery = branches.join(" UNION ALL ")
+        if (dialect.jsonColumnType === "JSON") {
+          if (computed.distinct) {
+            return `(SELECT COALESCE(json_group_array(__v), json_array()) FROM (SELECT DISTINCT __v FROM (${unionQuery}))) AS "${key}"`
+          }
+          return `(SELECT COALESCE(json_group_array(__v), json_array()) FROM (${unionQuery})) AS "${key}"`
+        }
+        if (computed.distinct) {
+          return `(SELECT COALESCE(jsonb_agg(__v), '[]'::jsonb) FROM (SELECT DISTINCT __v FROM (${unionQuery}) inner_q) outer_q) AS "${key}"`
+        }
+        return `(SELECT COALESCE(jsonb_agg(__v), '[]'::jsonb) FROM (${unionQuery}) t) 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,EAA2C,MAAM,YAAY,CAAA;AAWjI,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(

package/test/rawQuery.test.ts

@@ -1,3 +1,4 @@
+import { SqliteClient } from "@effect/sql-sqlite-node"
 import { describe, expect, it } from "@effect/vitest"
 import { Array, Config, Context, Effect, flow, Layer, ManagedRuntime, Redacted, References, Result, S, Struct } from "effect-app"
 import { LogLevels } from "effect-app/utils"
@@ -5,7 +6,6 @@ import { setupRequestContextFromCurrent } from "../src/api/setupRequest.js"
 import { and, computed, or, project, projectComputed, relation, where, whereEvery, whereSome } from "../src/Model/query.js"
 import { makeRepo } from "../src/Model/Repository/makeRepo.js"
 import { RepositoryRegistryLive } from "../src/Model/Repository/Registry.js"
-import { SqliteClient } from "@effect/sql-sqlite-node"
 import { CosmosStoreLayer } from "../src/Store/Cosmos.js"
 import { MemoryStoreLive } from "../src/Store/Memory.js"
 import { SQLiteStoreLayer } from "../src/Store/SQL.js"
@@ -596,11 +596,9 @@ describe("scanner-style AllPickList computed projections", () => {
     })
     .pipe(setupRequestContextFromCurrent())
 
-  it("works well in Memory", () =>
-    test.pipe(Effect.provide(OrderRepo.Test), rt.runPromise))
+  it("works well in Memory", () => test.pipe(Effect.provide(OrderRepo.Test), rt.runPromise))
 
-  it("works well in SQLite", () =>
-    test.pipe(Effect.provide(OrderRepo.TestSqlite), rt.runPromise))
+  it("works well in SQLite", () => test.pipe(Effect.provide(OrderRepo.TestSqlite), rt.runPromise))
 })
 
 // Same but mimics the FULL controller projection: includes `items` array
@@ -647,11 +645,9 @@ describe("scanner-style AllPickList — items + computed combined", () => {
     })
     .pipe(setupRequestContextFromCurrent())
 
-  it("works well in Memory", () =>
-    test.pipe(Effect.provide(OrderRepo.Test), rt.runPromise))
+  it("works well in Memory", () => test.pipe(Effect.provide(OrderRepo.Test), rt.runPromise))
 
-  it("works well in SQLite", () =>
-    test.pipe(Effect.provide(OrderRepo.TestSqlite), rt.runPromise))
+  it("works well in SQLite", () => test.pipe(Effect.provide(OrderRepo.TestSqlite), rt.runPromise))
 })
 
 describe("removeByIds", () => {