@effect-app/infra 4.0.0-beta.224 → 4.0.0-beta.226

package/src/Model/Repository/internal/internal.ts

@@ -277,7 +277,9 @@ export function makeRepoInternal<
             }
           )
 
-          const parseMany = Effect.fn("parseMany", { attributes: { "app.entity": name } })(
+          const parseMany = Effect.fn("parseMany", {
+            attributes: { "app.entity": name, "app.query.mode": "transform" }
+          })(
             function*(items: readonly PM[]) {
               const cm = yield* cms
               return yield* decodeMany(items.map((_) => mapReverse(_, cm.set))).pipe(Effect.orDie)
@@ -295,7 +297,9 @@ export function makeRepoInternal<
             }
             return dec
           }
-          const parseMany2 = Effect.fn("parseMany2", { attributes: { "app.entity": name } })(
+          const parseMany2 = Effect.fn("parseMany", {
+            attributes: { "app.entity": name, "app.query.mode": "transform" }
+          })(
             function*<A, R>(items: readonly PM[], schema: S.Codec<A, Encoded, R>) {
               const cm = yield* cms
               return yield* getDecodeMany(schema)(items.map((_) => mapReverse(_, cm.set))).pipe(Effect.orDie)
@@ -336,7 +340,15 @@ export function makeRepoInternal<
               ? filter(a)
                 // TODO: mapFrom but need to support per field and dependencies
                 .pipe(
-                  Effect.andThen(flow(S.decodeEffectConcurrently(S.Array(a.schema ?? schema)), provideRctx))
+                  Effect.andThen(
+                    flow(
+                      S.decodeEffectConcurrently(S.Array(a.schema ?? schema)),
+                      provideRctx,
+                      Effect.withSpan("parseMany", {
+                        attributes: { "app.entity": name, "app.query.mode": "project" }
+                      })
+                    )
+                  )
                 )
               : a.mode === "collect"
               ? filter(a)
@@ -345,7 +357,10 @@ export function makeRepoInternal<
                   Effect.flatMap(flow(
                     S.decodeEffectConcurrently(S.Array(a.schema)),
                     Effect.map(Array.getSomes),
-                    provideRctx
+                    provideRctx,
+                    Effect.withSpan("parseMany", {
+                      attributes: { "app.entity": name, "app.query.mode": "collect" }
+                    })
                   ))
                 )
               : Effect.flatMap(

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> =
@@ -397,7 +401,7 @@ export const count: {
  * persistence-model (PM) reverse-mapping is needed:
  *
  * - `"transform"` (default when `mode` omitted): goes through the repo's
- *   `parseMany`/`parseMany2` pipeline. The raw row is reverse-mapped via the
+ *   `parseMany` pipeline. The raw row is reverse-mapped via the
  *   etag/PM cache (re-injecting `_etag` and any PM-shape state) before
  *   decoding. Decode failures `orDie` (error channel = `never`). Use when
  *   the schema operates on the full PM shape (e.g. full-entity reads that
@@ -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,8 +316,9 @@ 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 : []
+    const where = filter.length > 0
+      ? ` WHERE ${print(filter, relationPath, false)}`
       : ""
     switch (computed._tag) {
       case "relation-count":
@@ -360,6 +363,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,41 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import * as S from "effect-app/Schema"
+import { describe, expect, it } from "vitest"
+import { computed, make, projectComputed, relation, toFilter } 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/)
+  })
+})

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/dist/date-query.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"date-query.test.d.ts","sourceRoot":"","sources":["../date-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*() {