@effect-app/infra 4.0.0-beta.31 → 4.0.0-beta.310

package/test/rawQuery.test.ts

@@ -1,11 +1,25 @@
+import { SqliteClient } from "@effect/sql-sqlite-node"
 import { describe, expect, it } from "@effect/vitest"
-import { Array, Config, Effect, flow, Layer, ManagedRuntime, Redacted, References, Result, S, ServiceMap } from "effect-app"
+import * as Array from "effect-app/Array"
+import * as Config from "effect-app/Config"
+import * as Context from "effect-app/Context"
+import * as Effect from "effect-app/Effect"
+import * as Layer from "effect-app/Layer"
+import { and, computed, or, project, projectComputed, relation, where, whereEvery, whereSome } from "effect-app/Model/query"
+import { makeRepo } from "effect-app/Model/Repository/makeRepo"
+import { RepositoryRegistryLive } from "effect-app/Model/Repository/Registry"
+import * as S from "effect-app/Schema"
+import { setupRequestContextFromCurrent } from "effect-app/setupRequest"
 import { LogLevels } from "effect-app/utils"
-import { setupRequestContextFromCurrent } from "../src/api/setupRequest.js"
-import { and, or, project, where, whereEvery, whereSome } from "../src/Model/query.js"
-import { makeRepo } from "../src/Model/Repository/makeRepo.js"
+import { flow } from "effect/Function"
+import * as ManagedRuntime from "effect/ManagedRuntime"
+import * as Redacted from "effect/Redacted"
+import * as References from "effect/References"
+import * as Result from "effect/Result"
+import * as Struct from "effect/Struct"
 import { CosmosStoreLayer } from "../src/Store/Cosmos.js"
 import { MemoryStoreLive } from "../src/Store/Memory.js"
+import { SQLiteStoreLayer } from "../src/Store/SQL.js"
 
 export const rt = ManagedRuntime.make(Layer.mergeAll(
   Layer.effect(
@@ -24,7 +38,7 @@ class Something extends S.Class<Something>("Something")({
   id: S.String,
   name: S.String,
   description: S.String,
-  items: S.Array(S.Struct({ id: S.String, value: S.Number, description: S.String }))
+  items: S.Array(S.Struct({ id: S.String, value: S.Finite, description: S.String }))
 }) {}
 
 const items = [
@@ -49,7 +63,7 @@ const items = [
 ]
 
 // @effect-diagnostics-next-line missingEffectServiceDependency:off
-class SomethingRepo extends ServiceMap.Service<SomethingRepo>()(
+class SomethingRepo extends Context.Service<SomethingRepo>()(
   "SomethingRepo",
   {
     make: Effect.gen(function*() {
@@ -76,28 +90,31 @@ class SomethingRepo extends ServiceMap.Service<SomethingRepo>()(
   static readonly Test = this
     .layer
     .pipe(
-      Layer.provide(MemoryStoreLive)
+      Layer.provide(Layer.merge(MemoryStoreLive, RepositoryRegistryLive))
     )
 
   static readonly TestCosmos = this
     .layer
     .pipe(
       Layer.provide(
-        Effect.gen(function*() {
-          const url = yield* Config.redacted("STORAGE_URL").pipe(
-            Config.withDefault(
-              Redacted.make(
-                // the emulator doesn't implement array projections :/ so you need an actual cloud instance!
-                "AccountEndpoint=http://localhost:8081/;AccountKey=C2y6yDjf5/R+ob0N8A7Cgv30VRDJIWEHLM+4QDU5DE2nQ9nDuVTqobD4b8mGGyPMbIZnqyMsEcaGQy67XIw/Jw=="
+        Effect
+          .gen(function*() {
+            const url = yield* Config.redacted("STORAGE_URL").pipe(
+              Config.withDefault(
+                Redacted.make(
+                  // the emulator doesn't implement array projections :/ so you need an actual cloud instance!
+                  "AccountEndpoint=http://localhost:8081/;AccountKey=C2y6yDjf5/R+ob0N8A7Cgv30VRDJIWEHLM+4QDU5DE2nQ9nDuVTqobD4b8mGGyPMbIZnqyMsEcaGQy67XIw/Jw=="
+                )
               )
             )
-          )
-          return CosmosStoreLayer({
-            dbName: "test",
-            prefix: "",
-            url
+            return CosmosStoreLayer({
+              dbName: "test",
+              prefix: "",
+              url
+            })
+              .pipe(Layer.merge(RepositoryRegistryLive))
           })
-        }).pipe(Layer.unwrap)
+          .pipe(Layer.unwrap)
       )
     )
 }
@@ -107,7 +124,7 @@ describe("select first-level array fields", () => {
     .gen(function*() {
       const repo = yield* SomethingRepo
 
-      const projected = S.Struct({ name: S.String, items: S.Array(S.Struct({ id: S.String, value: S.Number })) })
+      const projected = S.Struct({ name: S.String, items: S.Array(S.Struct({ id: S.String, value: S.Finite })) })
 
       // ok crazy lol, "value" is a reserved word in CosmosDB, so we have to use t["value"] as a field name instead of t.value
       const items = yield* repo.queryRaw(projected, {
@@ -159,7 +176,7 @@ describe("select first-level array fields", () => {
       .pipe(Effect.provide(SomethingRepo.Test), rt.runPromise))
 })
 
-const projected = S.Struct({ name: S.String, items: S.Array(S.Struct({ id: S.String, value: S.Number })) })
+const projected = S.Struct({ name: S.String, items: S.Array(S.Struct({ id: S.String, value: S.Finite })) })
 
 const expected = [
   {
@@ -352,6 +369,67 @@ 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*() {
+      const repo = yield* SomethingRepo
+      const output = S.Struct({
+        id: S.String,
+        pickedCount: S.NonNegativeInt,
+        hasPicked: S.Boolean
+      })
+      const pickedFilter = where("value", "gt", 20)
+      const items = yield* repo.query(
+        projectComputed(
+          output,
+          computed({
+            pickedCount: relation<S.Codec.Encoded<typeof Something>>("items").count(pickedFilter),
+            hasPicked: relation<S.Codec.Encoded<typeof Something>>("items").any(pickedFilter)
+          })
+        )
+      )
+      expect(items).toStrictEqual([
+        { id: "1", pickedCount: 0, hasPicked: false },
+        { id: "2", pickedCount: 2, hasPicked: true }
+      ])
+    })
+    .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))
+})
+
 // FUTURE: we need something like this instead:
 /*
   const subQuery = <T extends FieldValues>() => <TKey extends keyof T>(key: TKey, type: "some" | "every" = "some") => make<T[TKey][number]>() // todo: mark that this is sub query on field "items"
@@ -369,6 +447,246 @@ describe("multi-level", () => {
     ))
     */
 
+// Mimic scanner MultiPick/EasyLife AllPickList shape:
+// - parent has tagged-state with `at` timestamp
+// - items is NonEmptyArray with state._tag + articleId/articleGTIN
+// - controller filters `state.at gte X` and `state._tag neq closed`
+//   then projectComputed with: count, any(initial/picking/packed),
+//   every(picked/packed), collectDistinct(articleId)
+const itemStateSchema = S.Union([
+  S.TaggedStruct("initial", { at: S.String }),
+  S.TaggedStruct("picking", { at: S.String }),
+  S.TaggedStruct("picked", { at: S.String }),
+  S.TaggedStruct("packed", { at: S.String })
+])
+
+class ArticleLineItem extends S.Class<ArticleLineItem>("ArticleLineItem")({
+  articleId: S.String,
+  articleGTIN: S.String,
+  state: itemStateSchema
+}) {}
+
+const stOrderState = S.Union([
+  S.TaggedStruct("initial", { at: S.String }),
+  S.TaggedStruct("packed", { at: S.String }),
+  S.TaggedStruct("closed", { at: S.String })
+])
+
+class Order extends S.Class<Order>("Order")({
+  id: S.String,
+  state: stOrderState,
+  items: S.NonEmptyArray(ArticleLineItem)
+}) {}
+
+const orderItems = [
+  new Order({
+    id: "o-open-1",
+    state: { _tag: "initial", at: "2026-05-08T08:00:00Z" },
+    items: [
+      new ArticleLineItem({
+        articleId: "A1",
+        articleGTIN: "G1",
+        state: { _tag: "picking", at: "2026-05-08T08:01:00Z" }
+      }),
+      new ArticleLineItem({
+        articleId: "A1",
+        articleGTIN: "G1",
+        state: { _tag: "picked", at: "2026-05-08T08:02:00Z" }
+      }),
+      new ArticleLineItem({
+        articleId: "A2",
+        articleGTIN: "G2",
+        state: { _tag: "initial", at: "2026-05-08T08:00:00Z" }
+      })
+    ]
+  }),
+  new Order({
+    id: "o-allpicked-2",
+    state: { _tag: "packed", at: "2026-05-07T10:00:00Z" },
+    items: [
+      new ArticleLineItem({
+        articleId: "B1",
+        articleGTIN: "GB1",
+        state: { _tag: "picked", at: "2026-05-07T09:50:00Z" }
+      }),
+      new ArticleLineItem({
+        articleId: "B2",
+        articleGTIN: "GB2",
+        state: { _tag: "picked", at: "2026-05-07T09:55:00Z" }
+      })
+    ]
+  }),
+  new Order({
+    id: "o-closed-3",
+    state: { _tag: "closed", at: "2026-05-04T10:00:00Z" },
+    items: [
+      new ArticleLineItem({
+        articleId: "C1",
+        articleGTIN: "GC1",
+        state: { _tag: "packed", at: "2026-05-04T09:00:00Z" }
+      })
+    ]
+  })
+]
+
+// @effect-diagnostics-next-line missingEffectServiceDependency:off
+class OrderRepo extends Context.Service<OrderRepo>()(
+  "OrderRepo",
+  {
+    make: Effect.gen(function*() {
+      const partitionKey = "orders-" + new Date().getTime()
+      return yield* makeRepo("Order", Order, { config: { partitionValue: () => partitionKey } })
+    })
+  }
+) {
+  static readonly layer = Layer
+    .effect(
+      OrderRepo,
+      Effect.gen(function*() {
+        const partitionKey = "orders-" + new Date().getTime()
+        const repo = OrderRepo.of(
+          yield* makeRepo("Order", Order, {
+            config: { partitionValue: () => partitionKey }
+          })
+        )
+        yield* repo.saveAndPublish(orderItems).pipe(setupRequestContextFromCurrent("init"))
+        return repo
+      })
+    )
+  static readonly Test = this
+    .layer
+    .pipe(Layer.provide(Layer.merge(MemoryStoreLive, RepositoryRegistryLive)))
+
+  static readonly TestSqlite = this
+    .layer
+    .pipe(
+      Layer.provide(
+        Layer.merge(
+          SQLiteStoreLayer({
+            url: Redacted.make("sqlite://"),
+            prefix: "test_",
+            dbName: "test"
+          }),
+          RepositoryRegistryLive
+        )
+      ),
+      Layer.provide(SqliteClient.layer({ filename: ":memory:" }))
+    )
+}
+
+describe("scanner-style AllPickList computed projections", () => {
+  const test = Effect
+    .gen(function*() {
+      const repo = yield* OrderRepo
+      type OrderEnc = S.Codec.Encoded<typeof Order>
+
+      const projection = S.Struct({
+        id: S.String,
+        state: stOrderState,
+        articleCount: S.NonNegativeInt,
+        hasInitialItem: S.Boolean,
+        hasPickingItem: S.Boolean,
+        hasPackedItem: S.Boolean,
+        allItemsPicked: S.Boolean,
+        allItemsPacked: S.Boolean,
+        articleIds: S.Array(S.String)
+      })
+
+      const result = yield* repo.query(
+        where("state.at", "gte", "2026-05-05T00:00:00Z"),
+        and("state._tag", "neq", "closed"),
+        projectComputed(
+          projection,
+          computed({
+            articleCount: relation<OrderEnc>("items").count(),
+            hasInitialItem: relation<OrderEnc>("items").any(where("state._tag", "initial")),
+            hasPickingItem: relation<OrderEnc>("items").any(where("state._tag", "picking")),
+            hasPackedItem: relation<OrderEnc>("items").any(where("state._tag", "packed")),
+            allItemsPicked: relation<OrderEnc>("items").every(where("state._tag", "picked")),
+            allItemsPacked: relation<OrderEnc>("items").every(where("state._tag", "packed")),
+            articleIds: relation<OrderEnc>("items").collectDistinct("articleId")
+          })
+        )
+      )
+
+      const byId = Object.fromEntries(result.map((r) => [r.id, r]))
+
+      expect(Object.keys(byId).sort()).toEqual(["o-allpicked-2", "o-open-1"])
+
+      const open = byId["o-open-1"]!
+      expect(open.articleCount).toBe(3)
+      expect(open.hasInitialItem).toBe(true)
+      expect(open.hasPickingItem).toBe(true)
+      expect(open.hasPackedItem).toBe(false)
+      expect(open.allItemsPicked).toBe(false)
+      expect(open.allItemsPacked).toBe(false)
+      expect([...open.articleIds].sort()).toEqual(["A1", "A2"])
+
+      const allp = byId["o-allpicked-2"]!
+      expect(allp.articleCount).toBe(2)
+      expect(allp.hasInitialItem).toBe(false)
+      expect(allp.hasPickingItem).toBe(false)
+      expect(allp.hasPackedItem).toBe(false)
+      expect(allp.allItemsPicked).toBe(true)
+      expect(allp.allItemsPacked).toBe(false)
+      expect([...allp.articleIds].sort()).toEqual(["B1", "B2"])
+    })
+    .pipe(setupRequestContextFromCurrent())
+
+  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))
+})
+
+// Same but mimics the FULL controller projection: includes `items` array
+// (NonEmptyArray) alongside the computed scalars. This tests the
+// memory-side select pipeline that combines subKeys (items) with
+// computedKeys in one Project node.
+describe("scanner-style AllPickList — items + computed combined", () => {
+  const test = Effect
+    .gen(function*() {
+      const repo = yield* OrderRepo
+      type OrderEnc = S.Codec.Encoded<typeof Order>
+
+      const projection = S.Struct({
+        id: S.String,
+        items: S.NonEmptyArray(ArticleLineItem.mapFields(Struct.pick(["articleId", "articleGTIN"]))),
+        articleCount: S.NonNegativeInt,
+        allItemsPicked: S.Boolean,
+        articleIds: S.Array(S.String)
+      })
+
+      const result = yield* repo.query(
+        where("state.at", "gte", "2026-05-05T00:00:00Z"),
+        and("state._tag", "neq", "closed"),
+        projectComputed(
+          projection,
+          computed({
+            articleCount: relation<OrderEnc>("items").count(),
+            allItemsPicked: relation<OrderEnc>("items").every(where("state._tag", "picked")),
+            articleIds: relation<OrderEnc>("items").collectDistinct("articleId")
+          })
+        )
+      )
+
+      expect(result.length).toBe(2)
+      const byId = Object.fromEntries(result.map((r) => [r.id, r]))
+      const open = byId["o-open-1"]!
+      expect(open.items.length).toBe(3)
+      expect(open.items[0]).toHaveProperty("articleId")
+      expect(open.items[0]).toHaveProperty("articleGTIN")
+      expect(open.allItemsPicked).toBe(false)
+      const allp = byId["o-allpicked-2"]!
+      expect(allp.items.length).toBe(2)
+      expect(allp.allItemsPicked).toBe(true)
+    })
+    .pipe(setupRequestContextFromCurrent())
+
+  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))
+})
+
 describe("removeByIds", () => {
   const test = Effect
     .gen(function*() {
@@ -405,7 +723,7 @@ describe("removeByIds", () => {
 
       yield* repo.saveAndPublish(items)
       const itemsAfterSave = yield* repo.all
-      yield* repo.removeById(...items.slice(0, 2).map((_) => _.id))
+      yield* repo.removeById([items[0]!.id, items[1]!.id])
 
       const items2 = yield* repo.all