@effect-app/infra 4.0.0-beta.225 → 4.0.0-beta.227

package/src/Model/query/dsl.ts

@@ -179,6 +179,10 @@ export type ComputedProjectionExpression =
     readonly distinct: boolean
     readonly operation?: ComputedProjectionOperation
   }
+  | {
+    readonly _tag: "relation-length"
+    readonly path: string
+  }
 
 export type ComputedProjectionMap = Readonly<Record<string, ComputedProjectionExpression>>
 export type Q<TFieldValues extends FieldValues> =
@@ -473,6 +477,10 @@ export const project: {
 export const relation = <TFieldValues extends FieldValues>(
   path: FieldPath<TFieldValues>
 ) => ({
+  length: (): ComputedProjectionExpression => ({
+    _tag: "relation-length",
+    path: path as string
+  }),
   count: (operation?: ComputedProjectionOperation): ComputedProjectionExpression =>
     operation
       ? {

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

@@ -88,6 +88,10 @@ export type ComputedProjectionIrExpression =
     readonly distinct: boolean
     readonly filter: readonly FilterResult[]
   }
+  | {
+    readonly _tag: "relation-length"
+    readonly path: string
+  }
 
 type Result<TFieldValues extends FieldValues, A = TFieldValues, R = never> = {
   filter: FilterResult[]
@@ -230,7 +234,8 @@ const interpret = <
           ? Object.fromEntries(
             Object.entries(v.computed).map(([key, expression]) => {
               const e = expression
-              const filter = e.operation ? interpret(e.operation(make())).filter.map(applyPath(e.path)) : []
+              const op = "operation" in e ? e.operation : undefined
+              const filter = op ? interpret(op(make())).filter.map(applyPath(e.path)) : []
               switch (e._tag) {
                 case "relation-count":
                 case "relation-any":
@@ -293,6 +298,8 @@ const interpret = <
                       filter
                     } as ComputedProjectionIrExpression
                   ]
+                case "relation-length":
+                  return [key, { _tag: e._tag, path: e.path } as ComputedProjectionIrExpression]
               }
             })
           )

package/src/Store/Cosmos/query.ts

@@ -289,7 +289,9 @@ export function buildWhereCosmosQuery3(
           : [_]
       )
   const computedFilters = select
-    ? select.flatMap((_) => typeof _ === "object" && "computed" in _ ? getValues(_.computed.filter) : [])
+    ? select.flatMap((_) =>
+      typeof _ === "object" && "computed" in _ && "filter" in _.computed ? getValues(_.computed.filter) : []
+    )
     : []
   const values = [...computedFilters, ...getValues(filter)]
 
@@ -314,9 +316,11 @@ export function buildWhereCosmosQuery3(
         `IIF(${unitExpr} = ${JSON.stringify(toBase)}, 1, 0)`
       )
     }
-    const where = computed.filter.length > 0
-      ? ` WHERE ${print(computed.filter, relationPath, false)}`
-      : ""
+    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}`
@@ -325,10 +329,8 @@ export function buildWhereCosmosQuery3(
       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}`
+        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}`)
@@ -360,6 +362,8 @@ export function buildWhereCosmosQuery3(
         }
         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}`)

package/src/Store/Memory.ts

@@ -60,6 +60,8 @@ const emptyValueFor = (tag: ComputedProjectionIrExpression["_tag"]) => {
       return [] as unknown[]
     case "relation-collect-fields":
       return [] as unknown[]
+    case "relation-length":
+      return 0
     default:
       return assertUnreachable(tag)
   }
@@ -73,6 +75,9 @@ const computeProjectionValue = (
   if (!Array.isArray(relation)) {
     return emptyValueFor(computed._tag)
   }
+  if (computed._tag === "relation-length") {
+    return relation.length
+  }
   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).

package/src/Store/SQL/query.ts

@@ -412,9 +412,10 @@ export function buildWhereSQLQuery(
       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 filter = "filter" in computed ? computed.filter : []
     const whereClause = () =>
-      computed.filter.length > 0
-        ? ` WHERE ${print(computed.filter, computed.path, false)}`
+      filter.length > 0
+        ? ` WHERE ${print(filter, computed.path, false)}`
         : ""
     const boolExpr = (sqlExpr: string) =>
       dialect.jsonColumnType === "JSON"
@@ -428,9 +429,9 @@ export function buildWhereSQLQuery(
       case "relation-every":
         // ∀x.P(x) ≡ ¬∃x.¬P(x). When no filter, no element exists that violates ⊤ → true.
         return boolExpr(
-          computed.filter.length === 0
+          filter.length === 0
             ? `1=1`
-            : `NOT EXISTS(SELECT 1 FROM ${relationFrom} WHERE NOT (${print(computed.filter, computed.path, false)}))`
+            : `NOT EXISTS(SELECT 1 FROM ${relationFrom} WHERE NOT (${print(filter, computed.path, false)}))`
         )
       case "relation-distinct-count": {
         const fieldExtract = dialect.jsonExtractElement(relationAlias, computed.field)
@@ -470,6 +471,10 @@ export function buildWhereSQLQuery(
         const aggArg = computed.distinct ? `DISTINCT ${fieldExtract}` : fieldExtract
         return `(SELECT COALESCE(jsonb_agg(${aggArg}), '[]'::jsonb) FROM ${relationFrom}${whereClause()}) AS "${key}"`
       }
+      case "relation-length": {
+        const arrPath = dottedToJsonPath(computed.path)
+        return `${dialect.arrayLength(arrPath)} AS "${key}"`
+      }
       case "relation-collect-fields": {
         const branches = computed.fields.map((field) => {
           const fieldExtract = dialect.jsonExtractElement(relationAlias, field)

package/test/cosmos-query.test.ts

@@ -0,0 +1,95 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import * as S from "effect-app/Schema"
+import { describe, expect, it } from "vitest"
+import { and, computed, make, projectComputed, relation, toFilter, where } from "../src/Model/query.js"
+import { buildWhereCosmosQuery3 } from "../src/Store/Cosmos/query.js"
+
+class Order extends S.Class<Order>("Order")({
+  id: S.String,
+  packages: S.Array(S.Struct({ id: S.String, weight: S.Finite }))
+}) {}
+
+type OrderEnc = S.Codec.Encoded<typeof Order>
+
+// Length projection via `relation(...).length()` should emit a scalar
+// ARRAY_LENGTH expression rather than pulling (or reshaping) the array.
+describe("cosmos query projection: array length", () => {
+  it("projects packages length via ARRAY_LENGTH", () => {
+    const q = make<OrderEnc>().pipe(
+      projectComputed(
+        S.Struct({ id: S.String, packageCount: S.NonNegativeInt }),
+        computed({ packageCount: relation<OrderEnc>("packages").length() })
+      )
+    )
+
+    const ir = toFilter(q as any, Order as any)
+
+    const result = buildWhereCosmosQuery3(
+      "id",
+      ir.filter ?? [],
+      "Orders",
+      {},
+      ir.select as any
+    )
+
+    expect(result.query).toMatch(/ARRAY_LENGTH\(f(?:\.packages|\["packages"\])\)/)
+    expect(result.query).toContain("AS packageCount")
+    // Must not pull the full array nor reshape via subquery
+    expect(result.query).not.toMatch(/ARRAY\s*\(\s*SELECT[^)]*FROM\s+t\s+in\s+f[\.\["]/i)
+    expect(result.query).not.toMatch(/SELECT VALUE COUNT/)
+  })
+})
+
+// Regression: `relation-every` previously walked its filter twice (once for the
+// shared `where` variable, once for the NOT-EXISTS branch), double-bumping the
+// shared `i` counter and shifting every subsequent @v index against the bound
+// params array. Verify each filter element binds exactly one parameter and that
+// @v indices in the emitted SQL line up with the bindings.
+describe("cosmos query projection: relation-every parameter binding", () => {
+  class Item extends S.Class<Item>("Item")({
+    state: S.Struct({ _tag: S.Literals(["initial", "picking", "picked", "packed"]) })
+  }) {}
+  class DN extends S.Class<DN>("DN")({
+    id: S.String,
+    state: S.Struct({
+      _tag: S.Literals(["initial", "valid", "packed", "closed"]),
+      at: S.String
+    }),
+    items: S.Array(Item)
+  }) {}
+  type DNEnc = S.Codec.Encoded<typeof DN>
+
+  it("binds @v indices contiguously across every + main filter", () => {
+    const q = make<DNEnc>().pipe(
+      where("state.at", "gte", "2026-05-01T00:00:00.000Z"),
+      and("state._tag", "neq", "closed"),
+      projectComputed(
+        S.Struct({
+          id: S.String,
+          allItemsPicked: S.Boolean,
+          allItemsPacked: S.Boolean
+        }),
+        computed({
+          allItemsPicked: relation<DNEnc>("items").every(where("state._tag", "picked")),
+          allItemsPacked: relation<DNEnc>("items").every(where("state._tag", "packed"))
+        })
+      )
+    )
+
+    const ir = toFilter(q as any, DN as any)
+    const result = buildWhereCosmosQuery3("id", ir.filter ?? [], "DN", {}, ir.select as any)
+
+    // Each filter element binds exactly one parameter: 2 every filters + 2 main filter = 4.
+    expect(result.parameters).toHaveLength(4)
+    expect(result.parameters.map((_) => _.value)).toEqual([
+      "picked",
+      "packed",
+      "2026-05-01T00:00:00.000Z",
+      "closed"
+    ])
+
+    // SQL must reference exactly @v0..@v3 in order, no gaps, no overruns.
+    const refs = [...result.query.matchAll(/@v\d+/g)].map((m) => m[0])
+    expect(refs).toEqual(["@v0", "@v1", "@v2", "@v3"])
+  })
+})

package/test/dist/cosmos-query.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cosmos-query.test.d.ts","sourceRoot":"","sources":["../cosmos-query.test.ts"],"names":[],"mappings":""}

package/test/query.test.ts

@@ -614,7 +614,7 @@ it("projectComputed sets computed IR and forces project mode", () => {
   ])
   expect(interpreted.computed?.["pickedCount"]?._tag).toBe("relation-count")
   expect(interpreted.computed?.["pickedCount"]?.path).toBe("items")
-  expect(interpreted.computed?.["pickedCount"]?.filter).toEqual([
+  expect((interpreted.computed?.["pickedCount"] as { filter: unknown } | undefined)?.filter).toEqual([
     { t: "where", path: "items.-1.state._tag", op: "eq", value: "Picked" }
   ])
 })
@@ -662,7 +662,7 @@ it("projectComputed.every emits relation-every IR", () => {
   const interpreted = toFilter(query, baseSchema)
   expect(interpreted.computed?.["allPicked"]?._tag).toBe("relation-every")
   expect(interpreted.computed?.["allPicked"]?.path).toBe("items")
-  expect(interpreted.computed?.["allPicked"]?.filter).toEqual([
+  expect((interpreted.computed?.["allPicked"] as { filter: unknown } | undefined)?.filter).toEqual([
     { t: "where", path: "items.-1.state._tag", op: "eq", value: "Picked" }
   ])
 })
@@ -687,7 +687,7 @@ it("projectComputed.distinctCount emits relation-distinct-count IR with field",
   const ir = interpreted.computed?.["positionCount"]
   expect(ir?._tag).toBe("relation-distinct-count")
   expect((ir as { field: string } | undefined)?.field).toBe("rowId")
-  expect(ir?.filter).toEqual([
+  expect((ir as { filter: unknown } | undefined)?.filter).toEqual([
     { t: "where", path: "items.-1.state._tag", op: "neq", value: "cancelled" }
   ])
 })
@@ -707,7 +707,7 @@ it("projectComputed.sum emits relation-sum IR with field", () => {
   const ir = interpreted.computed?.["totalWeight"]
   expect(ir?._tag).toBe("relation-sum")
   expect((ir as { field: string } | undefined)?.field).toBe("weight")
-  expect(ir?.filter).toEqual([])
+  expect((ir as { filter: unknown } | undefined)?.filter).toEqual([])
 })
 
 it("projectComputed.collect / collectDistinct emit relation-collect IR", () => {

package/test/rawQuery.test.ts

@@ -369,6 +369,32 @@ describe("multi-level", () => {
       .pipe(Effect.provide(SomethingRepo.Test), rt.runPromise))
 })
 
+describe("array length projection", () => {
+  const test = Effect
+    .gen(function*() {
+      const repo = yield* SomethingRepo
+      const result = yield* repo.query(
+        projectComputed(
+          S.Struct({ id: S.String, itemCount: S.NonNegativeInt }),
+          computed({ itemCount: relation<S.Codec.Encoded<typeof Something>>("items").length() })
+        )
+      )
+      expect(result).toStrictEqual([
+        { id: "1", itemCount: 2 },
+        { id: "2", itemCount: 2 }
+      ])
+    })
+    .pipe(setupRequestContextFromCurrent())
+
+  it.skipIf(!process.env["STORAGE_URL"])("works well in CosmosDB", () =>
+    test
+      .pipe(Effect.provide(SomethingRepo.TestCosmos), rt.runPromise))
+
+  it("works well in Memory", () =>
+    test
+      .pipe(Effect.provide(SomethingRepo.Test), rt.runPromise))
+})
+
 describe("computed projections", () => {
   const test = Effect
     .gen(function*() {