@effect-app/infra 4.0.0-beta.99 → 4.0.1

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, Context } 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(
@@ -76,7 +90,7 @@ class SomethingRepo extends Context.Service<SomethingRepo>()(
   static readonly Test = this
     .layer
     .pipe(
-      Layer.provide(MemoryStoreLive)
+      Layer.provide(Layer.merge(MemoryStoreLive, RepositoryRegistryLive))
     )
 
   static readonly TestCosmos = this
@@ -85,7 +99,7 @@ class SomethingRepo extends Context.Service<SomethingRepo>()(
       Layer.provide(
         Effect
           .gen(function*() {
-            const url = yield* Config.redacted("STORAGE_URL").pipe(
+            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!
@@ -98,6 +112,7 @@ class SomethingRepo extends Context.Service<SomethingRepo>()(
               prefix: "",
               url
             })
+              .pipe(Layer.merge(RepositoryRegistryLive))
           })
           .pipe(Layer.unwrap)
       )
@@ -354,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"
@@ -371,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*() {
@@ -407,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
 
@@ -424,3 +740,112 @@ describe("removeByIds", () => {
     test
       .pipe(Effect.provide(SomethingRepo.Test), rt.runPromise))
 })
+
+describe("queryRaw reads stored JSON, not Encoded", () => {
+  class Dated extends S.Class<Dated>("Dated")({
+    id: S.String,
+    at: S.Date,
+    name: S.String
+  }) {}
+
+  const dated = new Dated({
+    id: "d1",
+    at: new Date("2024-06-01T00:00:00.000Z"),
+    name: "one"
+  })
+
+  // @effect-diagnostics-next-line missingEffectServiceDependency:off
+  class DatedRepo extends Context.Service<DatedRepo>()(
+    "DatedRepo",
+    {
+      make: Effect.gen(function*() {
+        return yield* makeRepo("Dated", Dated, { config: { partitionValue: () => "dated-" + new Date().getTime() } })
+      })
+    }
+  ) {
+    static readonly layer = Layer
+      .effect(
+        DatedRepo,
+        Effect.gen(function*() {
+          const repo = DatedRepo.of(
+            yield* makeRepo("Dated", Dated, { config: { partitionValue: () => "dated-" + new Date().getTime() } })
+          )
+          yield* repo.saveAndPublish([dated]).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:" }))
+      )
+    static readonly TestCosmos = this
+      .layer
+      .pipe(
+        Layer.provide(
+          Effect
+            .gen(function*() {
+              const url = yield* Config.Redacted("STORAGE_URL").pipe(
+                Config.withDefault(
+                  Redacted.make(
+                    "AccountEndpoint=http://localhost:8081/;AccountKey=C2y6yDjf5/R+ob0N8A7Cgv30VRDJIWEHLM+4QDU5DE2nQ9nDuVTqobD4b8mGGyPMbIZnqyMsEcaGQy67XIw/Jw=="
+                  )
+                )
+              )
+              return CosmosStoreLayer({
+                dbName: "test",
+                prefix: "",
+                url
+              })
+                .pipe(Layer.merge(RepositoryRegistryLive))
+            })
+            .pipe(Layer.unwrap)
+        )
+      )
+  }
+
+  const test = Effect
+    .gen(function*() {
+      const repo = yield* DatedRepo
+      const rows = yield* repo.queryRaw(S.Unknown, {
+        cosmos: ({ name }) => ({
+          query: `SELECT c.id, c AS raw FROM ${name} c`,
+          parameters: []
+        }),
+        memory: (items) => items.map((row) => ({ id: String(row.id), raw: row }))
+      })
+      expect(rows).toEqual([{
+        id: "d1",
+        raw: expect.objectContaining({
+          id: "d1",
+          at: "2024-06-01T00:00:00.000Z",
+          name: "one"
+        })
+      }])
+      const loaded = yield* repo.all
+      expect(loaded[0]!.at).toEqual(dated.at)
+    })
+    .pipe(setupRequestContextFromCurrent())
+
+  it.skipIf(!process.env["STORAGE_URL"])(
+    "works well in CosmosDB",
+    () => test.pipe(Effect.provide(DatedRepo.TestCosmos), rt.runPromise)
+  )
+
+  it("works well in Memory", () => test.pipe(Effect.provide(DatedRepo.Test), rt.runPromise))
+
+  it("works well in SQLite", () => test.pipe(Effect.provide(DatedRepo.TestSqlite), rt.runPromise))
+})