@effect-app/infra 4.0.0-beta.12 → 4.0.0-beta.121

package/test/query.test.ts

@@ -1,17 +1,21 @@
 /* eslint-disable unused-imports/no-unused-vars */
 /* eslint-disable @typescript-eslint/no-empty-object-type */
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { Effect, flow, Layer, Option, pipe, S, ServiceMap, Struct } from "effect-app"
+import { SchemaTransformation } from "effect"
+import { Context, Effect, flow, Layer, Option, pipe, S, Struct } from "effect-app"
 import { inspect } from "util"
 import { expect, expectTypeOf, it } from "vitest"
 import { setupRequestContextFromCurrent } from "../src/api/setupRequest.js"
 import { and, count, make, one, or, order, page, project, type QueryEnd, type QueryProjection, type QueryWhere, toFilter, where } from "../src/Model/query.js"
 import { makeRepo } from "../src/Model/Repository.js"
+import { RepositoryRegistryLive } from "../src/Model/Repository/Registry.js"
 import { memFilter, MemoryStoreLive } from "../src/Store/Memory.js"
 import { SomeService } from "./fixtures.js"
 
+const TestStoreLive = Layer.merge(MemoryStoreLive, RepositoryRegistryLive)
+
 const str = S.Struct({ _tag: S.Literal("string"), value: S.String })
-const num = S.Struct({ _tag: S.Literal("number"), value: S.Number })
+const num = S.Struct({ _tag: S.Literal("number"), value: S.Finite })
 const someUnion = S.Union([str, num])
 
 export class Something extends S.Class<Something>("Something")({
@@ -19,7 +23,7 @@ export class Something extends S.Class<Something>("Something")({
   displayName: S.NonEmptyString255,
   name: S.NullOr(S.NonEmptyString255).withDefault,
   n: S.Date.withDefault,
-  union: someUnion.pipe(S.withDefaultConstructor(() => ({ _tag: "string" as const, value: "hi" })))
+  union: someUnion.pipe(S.withConstructorDefault(Effect.succeed({ _tag: "string" as const, value: "hi" })))
 }) {}
 export declare namespace Something {
   // eslint-disable-next-line @typescript-eslint/no-empty-object-type
@@ -90,8 +94,8 @@ it("works", () => {
 
   const processed = memFilter(interpreted)(items.map((_) =>
     S.encodeUnknownSync(S.Struct({
-      ...Something.omit("displayName"),
-      displayName: S.Literal("Verona", "Riley")
+      ...Struct.omit(Something.fields, ["displayName"]),
+      displayName: S.Literals(["Verona", "Riley"])
     }))(_)
   ))
 
@@ -99,7 +103,7 @@ it("works", () => {
 })
 
 // @effect-diagnostics-next-line missingEffectServiceDependency:off
-class SomethingRepo extends ServiceMap.Service<SomethingRepo>()("SomethingRepo", {
+class SomethingRepo extends Context.Service<SomethingRepo>()("SomethingRepo", {
   make: Effect.gen(function*() {
     return yield* makeRepo("Something", Something, {})
   })
@@ -112,7 +116,7 @@ class SomethingRepo extends ServiceMap.Service<SomethingRepo>()("SomethingRepo",
       })
     )
     .pipe(
-      Layer.provide(MemoryStoreLive)
+      Layer.provide(TestStoreLive)
     )
 }
 
@@ -156,8 +160,6 @@ it("works with repo", () =>
 
       expectTypeOf(smtArr).toEqualTypeOf<readonly Something[]>()
 
-      console.log(" $$$$$$")
-      console.log(Struct.pick(["id", "displayName"]))
       expect(q1).toEqual(items.slice(0, 2).toReversed().map(Struct.pick(["id", "displayName"])))
       expect(q2).toEqual(items.slice(0, 2).toReversed().map(Struct.pick(["displayName"])))
     })
@@ -281,7 +283,7 @@ it(
         expect(result).toEqual([])
         expect(result2).toEqual([])
       })
-      .pipe(Effect.provide(MemoryStoreLive), setupRequestContextFromCurrent(), Effect.runPromise)
+      .pipe(Effect.provide(TestStoreLive), setupRequestContextFromCurrent(), Effect.runPromise)
 )
 
 it(
@@ -467,7 +469,7 @@ it(
 
         expect([]).toEqual([])
       })
-      .pipe(Effect.provide(MemoryStoreLive), setupRequestContextFromCurrent(), Effect.runPromise)
+      .pipe(Effect.provide(TestStoreLive), setupRequestContextFromCurrent(), Effect.runPromise)
 )
 
 it(
@@ -510,7 +512,7 @@ it(
 
         expect([]).toEqual([])
       })
-      .pipe(Effect.provide(MemoryStoreLive), setupRequestContextFromCurrent(), Effect.runPromise)
+      .pipe(Effect.provide(TestStoreLive), setupRequestContextFromCurrent(), Effect.runPromise)
 )
 
 it(
@@ -521,8 +523,8 @@ it(
         const schema = S.Struct({
           id: S.String,
           createdAt: S.Date.pipe(
-            S.withDecodingDefault(() => new Date().toISOString()),
-            S.withConstructorDefault(() => Option.some(new Date()))
+            S.withDecodingDefault(Effect.sync(() => new Date().toISOString())),
+            S.withConstructorDefault(Effect.sync(() => new Date()))
           )
         })
         const repo = yield* makeRepo(
@@ -534,8 +536,8 @@ it(
         const outputSchema = S.Struct({
           id: S.Literal("123"),
           createdAt: S.Date.pipe(
-            S.withDecodingDefault(() => new Date().toISOString()),
-            S.withConstructorDefault(() => Option.some(new Date()))
+            S.withDecodingDefault(Effect.sync(() => new Date().toISOString())),
+            S.withConstructorDefault(Effect.sync(() => new Date()))
           )
         })
 
@@ -543,7 +545,34 @@ it(
 
         expect(result).toEqual([])
       })
-      .pipe(Effect.provide(MemoryStoreLive), setupRequestContextFromCurrent(), Effect.runPromise)
+      .pipe(Effect.provide(TestStoreLive), setupRequestContextFromCurrent(), Effect.runPromise)
+)
+
+it(
+  "project with encodeKeys in projection maps encoded keys",
+  () =>
+    Effect
+      .gen(function*() {
+        const schema = S.Struct({
+          id: S.String,
+          a: S.Number
+        })
+
+        const repo = yield* makeRepo(
+          "test",
+          schema,
+          {
+            makeInitial: Effect.sync(() => [{ id: "1", a: 1 }])
+          }
+        )
+
+        const outputSchema = S.Struct({ b: S.Number }).pipe(S.encodeKeys({ b: "a" }))
+
+        const result = yield* repo.query(project(outputSchema))
+
+        expect(result).toStrictEqual([{ b: 1 }])
+      })
+      .pipe(Effect.provide(TestStoreLive), setupRequestContextFromCurrent(), Effect.runPromise)
 )
 
 it(
@@ -553,7 +582,7 @@ it(
       .gen(function*() {
         const schema = S.Struct({
           id: S.String,
-          literals: S.Literal("a", "b", "c")
+          literals: S.Literals(["a", "b", "c"])
         })
 
         type Schema = typeof schema.Type
@@ -573,7 +602,7 @@ it(
 
         expect(result).toEqual([])
       })
-      .pipe(Effect.provide(MemoryStoreLive), setupRequestContextFromCurrent(), Effect.runPromise)
+      .pipe(Effect.provide(TestStoreLive), setupRequestContextFromCurrent(), Effect.runPromise)
 )
 
 it(
@@ -583,7 +612,7 @@ it(
       .gen(function*() {
         const schema = S.Struct({
           id: S.String,
-          literals: S.Union([S.Literal("a", "b", "c"), S.Null])
+          literals: S.Union([S.Literals(["a", "b", "c"]), S.Null])
         })
 
         type Schema = typeof schema.Type
@@ -617,7 +646,7 @@ it(
 
         expect(result).toEqual([])
       })
-      .pipe(Effect.provide(MemoryStoreLive), setupRequestContextFromCurrent(), Effect.runPromise)
+      .pipe(Effect.provide(TestStoreLive), setupRequestContextFromCurrent(), Effect.runPromise)
 )
 
 it(
@@ -661,7 +690,7 @@ it(
 
         expect(result).toEqual([])
       })
-      .pipe(Effect.provide(MemoryStoreLive), setupRequestContextFromCurrent(), Effect.runPromise)
+      .pipe(Effect.provide(TestStoreLive), setupRequestContextFromCurrent(), Effect.runPromise)
 )
 
 it("remove null from one constituent of a tagged union", () =>
@@ -674,7 +703,7 @@ it("remove null from one constituent of a tagged union", () =>
 
       class BB extends S.Class<BB>("BB")({
         id: S.Literal("BB"),
-        b: S.NullOr(S.Number)
+        b: S.NullOr(S.Finite)
       }) {}
 
       type Union = AA | BB
@@ -710,7 +739,7 @@ it("remove null from one constituent of a tagged union", () =>
         })[]
       >()
     })
-    .pipe(Effect.provide(MemoryStoreLive), setupRequestContextFromCurrent(), Effect.runPromise))
+    .pipe(Effect.provide(TestStoreLive), setupRequestContextFromCurrent(), Effect.runPromise))
 
 it("refine 3", () =>
   Effect
@@ -748,7 +777,7 @@ it("refine 3", () =>
       const resQuer1 = yield* repo.query(where("id", "AA"))
       expectTypeOf(resQuer1).toEqualTypeOf<readonly AA[]>()
     })
-    .pipe(Effect.provide(MemoryStoreLive), setupRequestContextFromCurrent(), Effect.runPromise))
+    .pipe(Effect.provide(TestStoreLive), setupRequestContextFromCurrent(), Effect.runPromise))
 
 it("my test", () =>
   Effect
@@ -766,7 +795,7 @@ it("my test", () =>
       )
       expectTypeOf(resQuer1).toEqualTypeOf<readonly AA[]>()
     })
-    .pipe(Effect.provide(MemoryStoreLive), setupRequestContextFromCurrent(), Effect.runPromise))
+    .pipe(Effect.provide(TestStoreLive), setupRequestContextFromCurrent(), Effect.runPromise))
 
 it("refine inner without imposing a projection", () =>
   Effect
@@ -810,7 +839,7 @@ it("refine inner without imposing a projection", () =>
         where("union._tag", "AA"),
         // But if I wanna the whole Data as output ignoring the inner refinement
         // I wanna be able to do so
-        project(S.Struct(Data.pick("union")))
+        project(Data.mapFields(Struct.pick(["union"])))
       )
 
       expectTypeOf(query2).toEqualTypeOf<
@@ -841,7 +870,7 @@ it("refine inner without imposing a projection", () =>
         }[]
       >()
     })
-    .pipe(Effect.provide(MemoryStoreLive), setupRequestContextFromCurrent(), Effect.runPromise))
+    .pipe(Effect.provide(TestStoreLive), setupRequestContextFromCurrent(), Effect.runPromise))
 
 it("does not allow string queries on arrays", () =>
   Effect
@@ -876,7 +905,7 @@ it("does not allow string queries on arrays", () =>
       expectTypeOf(good3).toEqualTypeOf<QueryWhere<Some, Some>>()
       expectTypeOf(good4).toEqualTypeOf<QueryWhere<Some, Some>>()
     })
-    .pipe(Effect.provide(MemoryStoreLive), setupRequestContextFromCurrent(), Effect.runPromise))
+    .pipe(Effect.provide(TestStoreLive), setupRequestContextFromCurrent(), Effect.runPromise))
 
 it("test array.length", () =>
   Effect
@@ -917,7 +946,7 @@ it("test array.length", () =>
         QueryWhere<Something, Something>
       >()
     })
-    .pipe(Effect.provide(MemoryStoreLive), setupRequestContextFromCurrent(), Effect.runPromise))
+    .pipe(Effect.provide(TestStoreLive), setupRequestContextFromCurrent(), Effect.runPromise))
 
 it("distribution over union", () =>
   Effect
@@ -941,7 +970,7 @@ it("distribution over union", () =>
         })[]
       >()
     })
-    .pipe(Effect.provide(MemoryStoreLive), setupRequestContextFromCurrent(), Effect.runPromise))
+    .pipe(Effect.provide(TestStoreLive), setupRequestContextFromCurrent(), Effect.runPromise))
 
 it("refine nested union", () =>
   Effect
@@ -982,7 +1011,154 @@ it("refine nested union", () =>
         }[]
       >()
     })
-    .pipe(Effect.provide(MemoryStoreLive), setupRequestContextFromCurrent(), Effect.runPromise))
+    .pipe(Effect.provide(TestStoreLive), setupRequestContextFromCurrent(), Effect.runPromise))
+
+it("find with transformed id", () =>
+  Effect
+    .gen(function*() {
+      const ConfiguratorId = S.NonEmptyString255
+
+      class PreconfigurationId extends S.Class<PreconfigurationId>("PreconfigurationId")({
+        configuratorId: ConfiguratorId,
+        label: S.NonEmptyString50
+      }) {}
+
+      const PreconfigurationIdFromString = S.NonEmptyString255.pipe(
+        S.decodeTo(
+          S.toType(PreconfigurationId),
+          SchemaTransformation.transformOrFail({
+            decode: Effect.fnUntraced(function*(value) {
+              const values = value.split("_")
+              const label = yield* S.SchemaParser.decodeUnknownEffect(S.NonEmptyString50)(values.pop())
+              const configuratorId = yield* S.SchemaParser.decodeUnknownEffect(ConfiguratorId)(values.join("_"))
+              return new PreconfigurationId({ configuratorId, label })
+            }),
+            encode: (id) => Effect.succeed(S.NonEmptyString255(`${id.configuratorId}_${id.label}`))
+          })
+        ),
+        S.revealCodec
+      )
+
+      const Preconfiguration = S.Struct({
+        id: PreconfigurationIdFromString,
+        name: S.String
+      })
+
+      const repo = yield* makeRepo("Preconfiguration", Preconfiguration, { idKey: "id" as const })
+
+      const id = new PreconfigurationId({
+        configuratorId: S.NonEmptyString255("myConfigurator"),
+        label: S.NonEmptyString50("myLabel")
+      })
+      const item = { id, name: "test preconfig" }
+
+      yield* repo.saveAndPublish([item])
+
+      const found = yield* repo.find(id)
+      expect(Option.isSome(found)).toBe(true)
+      expect(Option.getOrThrow(found).name).toBe("test preconfig")
+      expect(Option.getOrThrow(found).id).toEqual(id)
+
+      const notFound = yield* repo.find(
+        new PreconfigurationId({
+          configuratorId: S.NonEmptyString255("other"),
+          label: S.NonEmptyString50("nope")
+        })
+      )
+      expect(Option.isNone(notFound)).toBe(true)
+    })
+    .pipe(Effect.provide(TestStoreLive), setupRequestContextFromCurrent(), Effect.runPromise))
+
+it("find with transformed id in tagged union", () =>
+  Effect
+    .gen(function*() {
+      const ConfiguratorId = S.NonEmptyString255
+
+      class PreconfigurationId extends S.Class<PreconfigurationId>("PreconfigurationId")({
+        configuratorId: ConfiguratorId,
+        label: S.NonEmptyString50
+      }) {}
+
+      const PreconfigurationIdFromString = S.NonEmptyString255.pipe(
+        S.decodeTo(
+          S.toType(PreconfigurationId),
+          SchemaTransformation.transformOrFail({
+            decode: Effect.fnUntraced(function*(value) {
+              const values = value.split("_")
+              const label = yield* S.SchemaParser.decodeUnknownEffect(S.NonEmptyString50)(values.pop())
+              const configuratorId = yield* S.SchemaParser.decodeUnknownEffect(ConfiguratorId)(values.join("_"))
+              return new PreconfigurationId({ configuratorId, label })
+            }),
+            encode: (id) => Effect.succeed(S.NonEmptyString255(`${id.configuratorId}_${id.label}`))
+          })
+        ),
+        S.revealCodec
+      )
+
+      class Draft extends S.TaggedClass<Draft>()("Draft", {
+        id: PreconfigurationIdFromString,
+        name: S.String
+      }) {}
+
+      class Published extends S.TaggedClass<Published>()("Published", {
+        id: PreconfigurationIdFromString,
+        name: S.String,
+        publishedAt: S.String
+      }) {}
+
+      class Archived extends S.TaggedClass<Archived>()("Archived", {
+        id: PreconfigurationIdFromString,
+        name: S.String,
+        archivedAt: S.String
+      }) {}
+
+      const Preconfiguration = S.Union([Draft, Published, Archived])
+
+      const repo = yield* makeRepo("Preconfiguration", Preconfiguration, {})
+
+      const id1 = new PreconfigurationId({
+        configuratorId: S.NonEmptyString255("conf1"),
+        label: S.NonEmptyString50("draft1")
+      })
+      const id2 = new PreconfigurationId({
+        configuratorId: S.NonEmptyString255("conf2"),
+        label: S.NonEmptyString50("pub1")
+      })
+      const id3 = new PreconfigurationId({
+        configuratorId: S.NonEmptyString255("conf3"),
+        label: S.NonEmptyString50("arch1")
+      })
+
+      const draft = new Draft({ id: id1, name: "my draft" })
+      const published = new Published({ id: id2, name: "my published", publishedAt: "2024-01-01" })
+      const archived = new Archived({ id: id3, name: "my archived", archivedAt: "2024-06-01" })
+
+      yield* repo.saveAndPublish([draft, published, archived])
+
+      // find each by their PreconfigurationId instance
+      const foundDraft = yield* repo.find(id1)
+      expect(Option.isSome(foundDraft)).toBe(true)
+      expect(Option.getOrThrow(foundDraft)._tag).toBe("Draft")
+      expect(Option.getOrThrow(foundDraft).name).toBe("my draft")
+
+      const foundPublished = yield* repo.find(id2)
+      expect(Option.isSome(foundPublished)).toBe(true)
+      expect(Option.getOrThrow(foundPublished)._tag).toBe("Published")
+
+      const foundArchived = yield* repo.find(id3)
+      expect(Option.isSome(foundArchived)).toBe(true)
+      expect(Option.getOrThrow(foundArchived)._tag).toBe("Archived")
+
+      // not found
+      const notFound = yield* repo.find(
+        new PreconfigurationId({
+          configuratorId: S.NonEmptyString255("nope"),
+          label: S.NonEmptyString50("nope")
+        })
+      )
+      expect(Option.isNone(notFound)).toBe(true)
+    })
+    .pipe(Effect.provide(TestStoreLive), setupRequestContextFromCurrent(), Effect.runPromise))
 
 it("refine union with nested union", () =>
   Effect
@@ -1097,4 +1273,4 @@ it("refine union with nested union", () =>
         })[]
       >()
     })
-    .pipe(Effect.provide(MemoryStoreLive), setupRequestContextFromCurrent(), Effect.runPromise))
+    .pipe(Effect.provide(TestStoreLive), setupRequestContextFromCurrent(), Effect.runPromise))

package/test/rawQuery.test.ts

@@ -1,9 +1,10 @@
 import { describe, expect, it } from "@effect/vitest"
-import { Array, Config, Effect, flow, Layer, ManagedRuntime, Redacted, References, Result, S, ServiceMap } from "effect-app"
+import { Array, Config, Context, Effect, flow, Layer, ManagedRuntime, Redacted, References, Result, S } from "effect-app"
 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 { RepositoryRegistryLive } from "../src/Model/Repository/Registry.js"
 import { CosmosStoreLayer } from "../src/Store/Cosmos.js"
 import { MemoryStoreLive } from "../src/Store/Memory.js"
 
@@ -24,7 +25,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 +50,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 +77,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 +111,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 +163,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 = [
   {

package/test/requires.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, expectTypeOf, it } from "@effect/vitest"
-import { Effect, Layer, Result, S, ServiceMap } from "effect-app"
+import { Context, Effect, Layer, Result, S } from "effect-app"
 import { NotLoggedInError, UnauthorizedError } from "effect-app/client"
 import { HttpHeaders } from "effect-app/http"
 import * as RpcX from "effect-app/rpc"
@@ -63,11 +63,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 +90,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 +128,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 +154,7 @@ const testSuite = (_mw: typeof middleware3) =>
                   {
                     rpc: {
                       ...defaultOpts.rpc,
-                      annotations: ServiceMap.make(_mw.requestContext, { requireRoles: ["manager"] })
+                      annotations: Context.make(_mw.requestContext, { requireRoles: ["manager"] })
                     }
                   }
                 )

package/test/rpc-multi-middleware.test.ts

@@ -1,14 +1,14 @@
 import { NodeHttpServer } from "@effect/platform-node"
 import { expect, expectTypeOf, it } from "@effect/vitest"
-import { Console, Effect, Layer, Result } from "effect"
-import { S } from "effect-app"
+import { Console, Effect, Layer, Ref, Result } from "effect"
+import { Context, S } from "effect-app"
 import { NotLoggedInError } from "effect-app/client"
 import { HttpRouter } from "effect-app/http"
 import { DefaultGenericMiddlewares } from "effect-app/middleware"
 import { MiddlewareMaker } from "effect-app/rpc"
 import { middlewareGroup } from "effect-app/rpc/MiddlewareMaker"
 import { FetchHttpClient } from "effect/unstable/http"
-import { RpcClient, RpcGroup, RpcSerialization, RpcServer, RpcTest } from "effect/unstable/rpc"
+import { Rpc, RpcClient, RpcGroup, RpcSerialization, RpcServer, RpcTest } from "effect/unstable/rpc"
 import { createServer } from "http"
 import { DefaultGenericMiddlewaresLive } from "../src/api/routing.js"
 import { AllowAnonymous, AllowAnonymousLive, RequestContextMap, RequireRoles, RequireRolesLive, Some, SomeElseMiddleware, SomeElseMiddlewareLive, SomeMiddleware, SomeMiddlewareLive, SomeService, Test, TestLive, UserProfile } from "./fixtures.js"
@@ -136,3 +136,72 @@ it.live(
     Effect.provide(RpcTestLayer)
   )
 )
+
+// Per-request service isolation test
+
+class PerRequestCounter extends Context.Service<PerRequestCounter>()(
+  "PerRequestCounter",
+  { make: Effect.sync(() => ({ a: 0 })) }
+) {
+  static Default = Layer.effect(this, this.make)
+}
+
+class GlobalCounter extends Context.Service<GlobalCounter, {
+  readonly ref: Ref.Ref<number>
+}>()("GlobalCounter") {}
+
+const CounterRpcs = RpcGroup.make(
+  Rpc.make("incrementA", {
+    success: S.Number
+  }),
+  Rpc.make("incrementB", {
+    success: S.Number
+  })
+)
+
+const counterImpl = CounterRpcs
+  .toLayer({
+    incrementA: Effect.fn(function*() {
+      const counter = yield* PerRequestCounter
+      counter.a++
+      const global = yield* GlobalCounter
+      yield* Ref.update(global.ref, (n) => n + 1)
+      return counter.a
+    }, Effect.provide(PerRequestCounter.Default)),
+    incrementB: Effect.fn(function*() {
+      const counter = yield* PerRequestCounter
+      counter.a++
+      const global = yield* GlobalCounter
+      yield* Ref.update(global.ref, (n) => n + 1)
+      return counter.a
+    }, Effect.provide(PerRequestCounter.Default))
+  })
+
+const GlobalCounterLive = Layer.effect(
+  GlobalCounter,
+  Ref.make(0).pipe(Effect.map((ref) => ({ ref })))
+)
+
+const CounterTestLayer = counterImpl.pipe(Layer.provideMerge(GlobalCounterLive))
+
+it.live(
+  "per-request service isolation with shared global counter",
+  Effect.fnUntraced(
+    function*() {
+      const client = yield* RpcTest.makeClient(CounterRpcs)
+      const global = yield* GlobalCounter
+
+      const r1 = yield* client.incrementA()
+      const r2 = yield* client.incrementB()
+
+      // per-request counter is fresh each time → both return 1
+      expect(r1).toBe(1)
+      expect(r2).toBe(1)
+
+      // global counter is shared across requests → accumulates to 2
+      const globalCount = yield* Ref.get(global.ref)
+      expect(globalCount).toBe(2)
+    },
+    Effect.provide(CounterTestLayer)
+  )
+)