@effect-app/infra 4.0.0-beta.22 → 4.0.0-beta.221

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 * as S from "effect-app/Schema"
 import { LogLevels } from "effect-app/utils"
+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 { setupRequestContextFromCurrent } from "../src/api/setupRequest.js"
-import { and, or, project, where, whereEvery, whereSome } from "../src/Model/query.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 { 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,41 @@ describe("multi-level", () => {
       .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 +421,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 +697,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
 

package/test/repository-ext.test.ts

@@ -0,0 +1,62 @@
+import { describe, expect, it } from "@effect/vitest"
+import * as Effect from "effect-app/Effect"
+import * as Layer from "effect-app/Layer"
+import * as S from "effect-app/Schema"
+import { setupRequestContextFromCurrent } from "../src/api/setupRequest.js"
+import { makeRepo } from "../src/Model/Repository.js"
+import { RepositoryRegistryLive } from "../src/Model/Repository/Registry.js"
+import { MemoryStoreLive } from "../src/Store/Memory.js"
+
+class BatchItem extends S.Class<BatchItem>("BatchItem")({
+  id: S.String,
+  label: S.String
+}) {}
+
+const TestStoreLive = Layer.merge(MemoryStoreLive, RepositoryRegistryLive)
+
+describe("repository ext save/remove batching", () => {
+  it.effect("supports save batching overload", () =>
+    Effect
+      .gen(function*() {
+        const repo = yield* makeRepo("BatchItem", BatchItem, {})
+        const items = [
+          new BatchItem({ id: "1", label: "one" }),
+          new BatchItem({ id: "2", label: "two" }),
+          new BatchItem({ id: "3", label: "three" }),
+          new BatchItem({ id: "4", label: "four" })
+        ] as const
+
+        yield* repo.save(items, { batch: 2 })
+
+        const all = yield* repo.all
+        expect(all).toHaveLength(4)
+        expect(all.map((_) => _.id).toSorted()).toEqual(["1", "2", "3", "4"])
+      })
+      .pipe(
+        setupRequestContextFromCurrent(),
+        Effect.provide(TestStoreLive)
+      ))
+
+  it.effect("supports remove batching overload", () =>
+    Effect
+      .gen(function*() {
+        const repo = yield* makeRepo("BatchItem", BatchItem, {})
+        const items = [
+          new BatchItem({ id: "1", label: "one" }),
+          new BatchItem({ id: "2", label: "two" }),
+          new BatchItem({ id: "3", label: "three" }),
+          new BatchItem({ id: "4", label: "four" })
+        ] as const
+
+        yield* repo.save(items)
+        yield* repo.remove([items[0], items[1], items[2]], { batch: true })
+
+        const all = yield* repo.all
+        expect(all).toHaveLength(1)
+        expect(all[0]?.id).toBe("4")
+      })
+      .pipe(
+        setupRequestContextFromCurrent(),
+        Effect.provide(TestStoreLive)
+      ))
+})

package/test/requires.test.ts

@@ -1,10 +1,14 @@
 import { describe, expect, expectTypeOf, it } from "@effect/vitest"
-import { Effect, Layer, Result, S, ServiceMap } from "effect-app"
 import { NotLoggedInError, UnauthorizedError } from "effect-app/client"
+import * as Context from "effect-app/Context"
+import * as Effect from "effect-app/Effect"
 import { HttpHeaders } from "effect-app/http"
+import * as Layer from "effect-app/Layer"
 import * as RpcX from "effect-app/rpc"
 import { MiddlewareMaker } from "effect-app/rpc"
+import * as S from "effect-app/Schema"
 import type { unhandled } from "effect-app/Types"
+import * as Result from "effect/Result"
 import { Rpc } from "effect/unstable/rpc"
 import { type SuccessValue } from "effect/unstable/rpc/RpcMiddleware"
 import { AllowAnonymous, AllowAnonymousLive, RequestContextMap, RequireRoles, RequireRolesLive, Some, SomeElseMiddleware, SomeElseMiddlewareLive, SomeMiddleware, SomeMiddlewareLive, SomeService, Test, TestLive } from "./fixtures.js"
@@ -63,11 +67,12 @@ const testSuite = (_mw: typeof middleware3) =>
       "works",
       Effect.fn(function*() {
         const defaultOpts = {
+          client: null as any, // TODO?
           headers: HttpHeaders.fromRecordUnsafe({}),
           payload: { _tag: "Test" },
           clientId: 0,
           requestId: "test-id" as any,
-          rpc: { ...TestRpc, annotations: ServiceMap.make(_mw.requestContext, {}) }
+          rpc: { ...TestRpc, annotations: Context.make(_mw.requestContext, {}) }
         }
         const next = Effect.void as unknown as Effect.Effect<SuccessValue, unhandled, never>
         const layer = _mw.layer.pipe(
@@ -89,7 +94,7 @@ const testSuite = (_mw: typeof middleware3) =>
                 headers: HttpHeaders.fromRecordUnsafe({ "x-user": "test-user", "x-is-manager": "true" }),
                 rpc: {
                   ...defaultOpts.rpc,
-                  annotations: ServiceMap.make(_mw.requestContext, { requireRoles: ["manager"] })
+                  annotations: Context.make(_mw.requestContext, { requireRoles: ["manager"] })
                 }
               })
             )
@@ -127,7 +132,7 @@ const testSuite = (_mw: typeof middleware3) =>
                 Object.assign({ ...defaultOpts }, {
                   rpc: {
                     ...defaultOpts.rpc,
-                    annotations: ServiceMap.make(_mw.requestContext, { requireRoles: ["manager"] })
+                    annotations: Context.make(_mw.requestContext, { requireRoles: ["manager"] })
                   }
                 })
               )
@@ -153,7 +158,7 @@ const testSuite = (_mw: typeof middleware3) =>
                   {
                     rpc: {
                       ...defaultOpts.rpc,
-                      annotations: ServiceMap.make(_mw.requestContext, { requireRoles: ["manager"] })
+                      annotations: Context.make(_mw.requestContext, { requireRoles: ["manager"] })
                     }
                   }
                 )