@effect-app/infra 4.0.0-beta.24 → 4.0.0-beta.241

package/src/adapters/ServiceBus.ts

@@ -1,67 +1,69 @@
 /* eslint-disable @typescript-eslint/prefer-promise-reject-errors */
 import { type OperationOptionsBase, type ProcessErrorArgs, ServiceBusClient, type ServiceBusMessage, type ServiceBusMessageBatch, type ServiceBusReceivedMessage, type ServiceBusReceiver } from "@azure/service-bus"
-import { Cause, Effect, Exit, FiberSet, Layer, type Scope, ServiceMap } from "effect-app"
+import * as Context from "effect-app/Context"
+import * as Effect from "effect-app/Effect"
+import * as Layer from "effect-app/Layer"
+import * as Cause from "effect/Cause"
+import * as Exit from "effect/Exit"
+import * as FiberSet from "effect/FiberSet"
+import type * as Scope from "effect/Scope"
 import { InfraLogger } from "../logger.js"
 
-const withSpanAndLog = (name: string) => <A, E, R>(self: Effect.Effect<A, E, R>) =>
+const logged = (name: string) => <A, E, R>(self: Effect.Effect<A, E, R>) =>
   Effect.logInfo(name).pipe(
     Effect.andThen(self),
     Effect.tap(Effect.logInfo(name + " done")),
-    Effect.withLogSpan(name),
-    Effect.withSpan(name)
+    Effect.withLogSpan(name)
   )
 
 function makeClient(url: string) {
   return Effect.acquireRelease(
-    Effect.sync(() => new ServiceBusClient(url)).pipe(withSpanAndLog("ServiceBus.client.create")),
-    (client) => Effect.promise(() => client.close()).pipe(withSpanAndLog("ServiceBus.client.close"))
+    Effect.sync(() => new ServiceBusClient(url)).pipe(logged("ServiceBus.client.create")),
+    (client) => Effect.promise(() => client.close()).pipe(logged("ServiceBus.client.close"))
   )
 }
 
 export class ServiceBusClientTag
-  extends ServiceMap.Opaque<ServiceBusClientTag, ServiceBusClient>()("@services/Client", { make: makeClient })
+  extends Context.Opaque<ServiceBusClientTag, ServiceBusClient>()("@services/Client", { make: makeClient })
 {
   static readonly layer = (url: string) => this.toLayer(this.make(url))
 }
 
-function makeSender_(queueName: string) {
-  return Effect.gen(function*() {
-    const serviceBusClient = yield* ServiceBusClientTag
+const makeSender_ = Effect.fnUntraced(function*(queueName: string) {
+  const serviceBusClient = yield* ServiceBusClientTag
 
-    return yield* Effect.acquireRelease(
-      Effect.sync(() => serviceBusClient.createSender(queueName)).pipe(
-        withSpanAndLog(`ServiceBus.sender.create ${queueName}`)
-      ),
-      (sender) => Effect.promise(() => sender.close()).pipe(withSpanAndLog(`ServiceBus.sender.close ${queueName}`))
-    )
-  })
-}
-
-const makeSender = (name: string) =>
-  Effect.gen(function*() {
-    const sender = yield* makeSender_(name)
-    const sendMessages = Effect.fnUntraced(function*(
-      messages: ServiceBusMessage | ServiceBusMessage[] | ServiceBusMessageBatch,
-      options?: Omit<OperationOptionsBase, "abortSignal">
-    ) {
-      return yield* Effect.promise((abortSignal) => sender.sendMessages(messages, { ...options, abortSignal }))
-    })
+  return yield* Effect.acquireRelease(
+    Effect.sync(() => serviceBusClient.createSender(queueName)).pipe(
+      logged(`ServiceBus.sender.create ${queueName}`)
+    ),
+    (sender) => Effect.promise(() => sender.close()).pipe(logged(`ServiceBus.sender.close ${queueName}`))
+  )
+})
 
-    return { name, sendMessages }
+const makeSender = Effect.fnUntraced(function*(name: string) {
+  const sender = yield* makeSender_(name)
+  const sendMessages = Effect.fnUntraced(function*(
+    messages: ServiceBusMessage | ServiceBusMessage[] | ServiceBusMessageBatch,
+    options?: Omit<OperationOptionsBase, "abortSignal">
+  ) {
+    return yield* Effect.promise((abortSignal) => sender.sendMessages(messages, { ...options, abortSignal }))
   })
 
-export class Sender extends ServiceMap.Opaque<Sender, {
+  return { name, sendMessages }
+})
+
+export class Sender extends Context.Opaque<Sender, {
   name: string
   sendMessages: (
     messages: ServiceBusMessage | ServiceBusMessage[] | ServiceBusMessageBatch,
     options?: Omit<OperationOptionsBase, "abortSignal">
-  ) => Effect.Effect<void, never, never>
+  ) => Effect.Effect<void>
 }>()("Sender", { make: makeSender }) {
   static readonly layer = (name: string) => this.toLayer(this.make(name))
 }
 
 export const SenderTag = <Id>() => <Key extends string>(queueName: Key) => {
-  const tag = ServiceMap.Service<Id, Sender>(`ServiceBus.Sender.${queueName}`)
+  const tag = Context.Service<Id, Sender>(`ServiceBus.Sender.${queueName}`)
 
   return Object.assign(tag, {
     layer: Layer.effect(
@@ -71,99 +73,107 @@ export const SenderTag = <Id>() => <Key extends string>(queueName: Key) => {
   })
 }
 
-const makeReceiver = (name: string) =>
-  Effect.gen(function*() {
-    const serviceBusClient = yield* ServiceBusClientTag
-
-    const makeReceiver = Effect.fnUntraced(
-      function*(queueName: string, waitTillEmpty: Effect.Effect<void>, sessionId?: string) {
-        return yield* Effect.acquireRelease(
-          (sessionId
-            ? Effect.promise(() => serviceBusClient.acceptSession(queueName, sessionId))
-            : Effect.sync(() => serviceBusClient.createReceiver(queueName)))
-            .pipe(withSpanAndLog(`ServiceBus.receiver.create ${queueName}.${sessionId}`)),
-          (r) =>
-            waitTillEmpty.pipe(
-              withSpanAndLog(`ServiceBus.receiver.waitTillEmpty ${queueName}.${sessionId}`),
-              Effect.andThen(
-                Effect.promise(() => r.close()).pipe(
-                  withSpanAndLog(`ServiceBus.receiver.close ${queueName}.${sessionId}`)
-                )
-              ),
-              withSpanAndLog(`ServiceBus.receiver.release ${queueName}.${sessionId}`)
-            )
+const makeReceiver = Effect.fnUntraced(function*(name: string) {
+  const serviceBusClient = yield* ServiceBusClientTag
+
+  const makeReceiver = Effect.fnUntraced(
+    function*(queueName: string, waitTillEmpty: Effect.Effect<void>, sessionId?: string) {
+      const annotate = sessionId !== undefined
+        ? Effect.annotateLogs({ "messaging.session.id": sessionId })
+        : <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> => self
+      return yield* Effect.acquireRelease(
+        (sessionId
+          ? Effect.promise(() => serviceBusClient.acceptSession(queueName, sessionId))
+          : Effect.sync(() => serviceBusClient.createReceiver(queueName)))
+          .pipe(logged(`ServiceBus.receiver.create ${queueName}`), annotate),
+        (r) =>
+          waitTillEmpty.pipe(
+            logged(`ServiceBus.receiver.waitTillEmpty ${queueName}`),
+            Effect.andThen(
+              Effect.promise(() => r.close()).pipe(
+                logged(`ServiceBus.receiver.close ${queueName}`)
+              )
+            ),
+            logged(`ServiceBus.receiver.release ${queueName}`),
+            annotate
+          )
+      )
+    }
+  )
+
+  const make = (waitTillEmpty: Effect.Effect<void>) => makeReceiver(name, waitTillEmpty)
+
+  const makeSession = (sessionId: string, waitTillEmpty: Effect.Effect<void>) =>
+    makeReceiver(name, waitTillEmpty, sessionId)
+
+  return {
+    name,
+    make,
+    makeSession,
+    subscribe: Effect.fnUntraced(function*<RMsg, RErr>(hndlr: MessageHandlers<RMsg, RErr>, sessionId?: string) {
+      const fs = yield* FiberSet.make()
+      const fr = yield* FiberSet.runtime(fs)<RMsg | RErr>()
+      const wait = Effect
+        .gen(function*() {
+          if ((yield* FiberSet.size(fs)) > 0) {
+            yield* InfraLogger.logDebug("Waiting ServiceBusFiberSet to be empty: " + (yield* FiberSet.size(fs)))
+          }
+          while ((yield* FiberSet.size(fs)) > 0) yield* Effect.sleep("250 millis")
+        })
+      const r = yield* sessionId
+        ? makeSession(
+          sessionId,
+          wait
+        )
+        : make(wait)
+
+      const runEffect = <E>(effect: Effect.Effect<void, E, RMsg | RErr>) =>
+        new Promise<void>((resolve, reject) =>
+          fr(effect)
+            .addObserver((exit) => {
+              if (Exit.isSuccess(exit)) {
+                resolve(exit.value)
+              } else {
+                // disable @typescript-eslint/prefer-promise-reject-errors
+                reject(Cause.pretty(exit.cause))
+              }
+            })
         )
-      }
-    )
 
-    const make = (waitTillEmpty: Effect.Effect<void>) => makeReceiver(name, waitTillEmpty)
-
-    const makeSession = (sessionId: string, waitTillEmpty: Effect.Effect<void>) =>
-      makeReceiver(name, waitTillEmpty, sessionId)
-
-    return {
-      name,
-      make,
-      makeSession,
-      subscribe: Effect.fnUntraced(function*<RMsg, RErr>(hndlr: MessageHandlers<RMsg, RErr>, sessionId?: string) {
-        const fs = yield* FiberSet.make()
-        const fr = yield* FiberSet.runtime(fs)<RMsg | RErr>()
-        const wait = Effect
-          .gen(function*() {
-            if ((yield* FiberSet.size(fs)) > 0) {
-              yield* InfraLogger.logDebug("Waiting ServiceBusFiberSet to be empty: " + (yield* FiberSet.size(fs)))
-            }
-            while ((yield* FiberSet.size(fs)) > 0) yield* Effect.sleep("250 millis")
-          })
-        const r = yield* sessionId
-          ? makeSession(
-            sessionId,
-            wait
-          )
-          : make(wait)
-
-        const runEffect = <E>(effect: Effect.Effect<void, E, RMsg | RErr>) =>
-          new Promise<void>((resolve, reject) =>
-            fr(effect)
-              .addObserver((exit) => {
-                if (Exit.isSuccess(exit)) {
-                  resolve(exit.value)
-                } else {
-                  // disable @typescript-eslint/prefer-promise-reject-errors
-                  reject(Cause.pretty(exit.cause))
-                }
+      const annotate = sessionId !== undefined
+        ? Effect.annotateLogs({ "messaging.session.id": sessionId })
+        : <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> => self
+      yield* Effect.acquireRelease(
+        Effect
+          .sync(() => {
+            const s = r
+              .subscribe({
+                processError: (err) =>
+                  runEffect(
+                    hndlr
+                      .processError(err)
+                      .pipe(
+                        Effect.catchCause((cause) => Effect.logError("ServiceBus Error", cause)),
+                        annotate
+                      )
+                  ),
+                processMessage: (msg) => runEffect(hndlr.processMessage(msg).pipe(annotate))
+                // DO NOT CATCH ERRORS here as they should return to the queue!
               })
+            return { close: Effect.promise(() => s.close()) }
+          })
+          .pipe(logged("ServiceBus.subscription.create"), annotate),
+        (subscription) =>
+          subscription.close.pipe(
+            logged("ServiceBus.subscription.close"),
+            annotate
           )
+      ) as Effect.Effect<void, never, Scope.Scope> // wth is going on here
+    })
+  }
+})
 
-        yield* Effect.acquireRelease(
-          Effect
-            .sync(() => {
-              const s = r
-                .subscribe({
-                  processError: (err) =>
-                    runEffect(
-                      hndlr
-                        .processError(err)
-                        .pipe(
-                          Effect.catchCause((cause) => Effect.logError(`ServiceBus Error ${sessionId}`, cause))
-                        )
-                    ),
-                  processMessage: (msg) => runEffect(hndlr.processMessage(msg))
-                  // DO NOT CATCH ERRORS here as they should return to the queue!
-                })
-              return { close: Effect.promise(() => s.close()) }
-            })
-            .pipe(withSpanAndLog(`ServiceBus.subscription.create ${sessionId}`)),
-          (subscription) =>
-            subscription.close.pipe(
-              withSpanAndLog(`ServiceBus.subscription.close ${sessionId}`)
-            )
-        ) as Effect.Effect<void, never, Scope.Scope> // wth is going on here
-      })
-    }
-  })
-
-export class Receiver extends ServiceMap.Opaque<Receiver, {
+export class Receiver extends Context.Opaque<Receiver, {
   name: string
   make: (waitTillEmpty: Effect.Effect<void>) => Effect.Effect<ServiceBusReceiver, never, Scope.Scope>
   makeSession: (
@@ -180,7 +190,7 @@ export class Receiver extends ServiceMap.Opaque<Receiver, {
 }
 
 export const ReceiverTag = <Id>() => <Key extends string>(queueName: Key) => {
-  const tag = ServiceMap.Service<Id, Receiver>(`ServiceBus.Receiver.${queueName}`)
+  const tag = Context.Service<Id, Receiver>(`ServiceBus.Receiver.${queueName}`)
 
   return Object.assign(tag, {
     layer: Layer.effect(

package/src/adapters/cosmos-client.ts

@@ -1,16 +1,18 @@
 import { CosmosClient as ComosClient_ } from "@azure/cosmos"
-import { Effect, Layer, ServiceMap } from "effect-app"
+import * as Context from "effect-app/Context"
+import * as Effect from "effect-app/Effect"
+import * as Layer from "effect-app/Layer"
 
 const withClient = (url: string) => Effect.sync(() => new ComosClient_(url))
 
 export const makeCosmosClient = (url: string, dbName: string) =>
   Effect.map(withClient(url), (x) => ({ db: x.database(dbName) }))
 
-export class CosmosClient extends ServiceMap.Service<CosmosClient, {
+export class CosmosClient extends Context.Service<CosmosClient, {
   readonly db: ReturnType<InstanceType<typeof ComosClient_>["database"]>
 }>()("@services/CosmosClient") {}
 
-export const db = CosmosClient.asEffect().pipe(Effect.map((_) => _.db))
+export const db = CosmosClient.pipe(Effect.map((_) => _.db))
 
 export const CosmosClientLayer = (cosmosUrl: string, dbName: string) =>
   Layer.effect(CosmosClient, makeCosmosClient(cosmosUrl, dbName))

package/src/adapters/index.ts

@@ -0,0 +1,7 @@
+export * from "./cosmos-client.js"
+export * from "./logger.js"
+export * from "./memQueue.js"
+export * from "./mongo-client.js"
+export * from "./redis-client.js"
+export * from "./ServiceBus.js"
+export * from "./SQL.js"

package/src/adapters/memQueue.ts

@@ -1,5 +1,6 @@
-import { Effect, type Queue, ServiceMap } from "effect-app"
-import * as Q from "effect/Queue"
+import * as Context from "effect-app/Context"
+import * as Effect from "effect-app/Effect"
+import * as Queue from "effect/Queue"
 
 const make = Effect
   .gen(function*() {
@@ -9,13 +10,13 @@ const make = Effect
       getOrCreateQueue: Effect.fnUntraced(function*(k: string) {
         const q = store.get(k)
         if (q) return q
-        const newQ = yield* Q.unbounded<string>()
+        const newQ = yield* Queue.unbounded<string>()
         store.set(k, newQ)
         return newQ
       })
     }
   })
 
-export class MemQueue extends ServiceMap.Opaque<MemQueue>()("effect-app/MemQueue", { make }) {
+export class MemQueue extends Context.Opaque<MemQueue>()("effect-app/MemQueue", { make }) {
   static readonly Live = this.toLayer(this.make)
 }

package/src/adapters/mongo-client.ts

@@ -1,4 +1,6 @@
-import { Effect, Layer, ServiceMap } from "effect-app"
+import * as Context from "effect-app/Context"
+import * as Effect from "effect-app/Effect"
+import * as Layer from "effect-app/Layer"
 import { MongoClient as MongoClient_ } from "mongodb"
 
 // TODO: we should probably share a single client...
@@ -15,7 +17,7 @@ const withClient = (url: string) =>
 
 const makeMongoClient = (url: string, dbName?: string) => Effect.map(withClient(url), (x) => ({ db: x.db(dbName) }))
 
-export class MongoClient extends ServiceMap.Service<MongoClient, {
+export class MongoClient extends Context.Service<MongoClient, {
   readonly db: ReturnType<InstanceType<typeof MongoClient_>["db"]>
 }>()("@services/MongoClient") {}
 

package/src/adapters/redis-client.ts

@@ -1,4 +1,8 @@
-import { Data, Effect, Layer, Option, ServiceMap } from "effect-app"
+import * as Context from "effect-app/Context"
+import * as Effect from "effect-app/Effect"
+import * as Layer from "effect-app/Layer"
+import * as Option from "effect-app/Option"
+import * as Data from "effect/Data"
 import type { RedisClient as Client } from "redis"
 import Redlock from "redlock"
 
@@ -90,7 +94,7 @@ export const makeRedisClient = (makeClient: () => Client) =>
         .pipe(Effect.uninterruptible, Effect.orDie)
   )
 
-export class RedisClient extends ServiceMap.Service<RedisClient, {
+export class RedisClient extends Context.Service<RedisClient, {
   readonly client: Client
   readonly lock: Redlock
   readonly get: (key: string) => Effect.Effect<Option.Option<string>, ConnectionException>

package/src/api/ContextProvider.ts

@@ -1,9 +1,13 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { Effect, Layer, type NonEmptyReadonlyArray, pipe, type Scope, ServiceMap } from "effect-app"
+import type { NonEmptyReadonlyArray } from "effect-app/Array"
+import * as Context from "effect-app/Context"
+import * as Effect from "effect-app/Effect"
+import * as Layer from "effect-app/Layer"
+import { pipe } from "effect/Function"
+import type * as Scope from "effect/Scope"
 
 import { type HttpRouter } from "effect-app/http"
 import { type EffectGenUtils } from "effect-app/utils/gen"
-import { type Yieldable } from "effect/Effect"
 import { type ContextTagWithDefault, type GetContext, type LayerUtils, mergeContexts } from "./layerUtils.js"
 
 export interface ContextProviderId {
@@ -23,7 +27,7 @@ type TDepsArr<TDeps extends ReadonlyArray<any>> = {
   // E = never => the context provided cannot trigger errors
   // TODO: remove HttpLayerRouter.Provided - it's not even relevant outside of Http context, while ContextProviders are for anywhere. Only support Scope.Scope?
   //  _R extends HttpLayerRouter.Provided => the context provided can only have what HttpLayerRouter.Provided provides as requirements
-  ContextTagWithDefault.Base<Effect.Effect<ServiceMap.ServiceMap<infer _1>, never, infer _R>> // & { _tag: infer _2 }>
+  ContextTagWithDefault.Base<Effect.Effect<Context.Context<infer _1>, never, infer _R>> // & { _tag: infer _2 }>
     ? [_R] extends [HttpRouter.Provided] ? TDeps[K]
     : `HttpLayerRouter.Provided is the only requirement ${TDeps[K]["Service"][
       "_tag"
@@ -38,7 +42,7 @@ type TDepsArr<TDeps extends ReadonlyArray<any>> = {
       > // & { _tag: infer _3 }
     ) // [_YW] extends [never] if no yield* is used and just some context is returned
       ? [_YW] extends [never] ? TDeps[K]
-      : [_YW] extends [Yieldable<any, infer _2, never, infer _R>] ? [_R] extends [HttpRouter.Provided] ? TDeps[K]
+      : [_YW] extends [Effect.Effect<any, never, infer _R>] ? [_R] extends [HttpRouter.Provided] ? TDeps[K]
         : `HttpLayerRouter.Provided is the only requirement ${TDeps[K]["Service"][
           "_tag"
         ]}'s returned effect can have`
@@ -58,9 +62,9 @@ export const mergeContextProviders = <
     Effect.Effect<
       // we need to merge all contexts into one
       // v4: Service.Shape extracts the service value type (v3's Tag.Identifier)
-      ServiceMap.ServiceMap<GetContext<EffectGenUtils.Success<ServiceMap.Service.Shape<TDeps[number]>>>>,
+      Context.Context<GetContext<EffectGenUtils.Success<Context.Service.Shape<TDeps[number]>>>>,
       never,
-      EffectGenUtils.ServiceMap<ServiceMap.Service.Shape<TDeps[number]>>
+      EffectGenUtils.Context<Context.Service.Shape<TDeps[number]>>
     >,
     LayerUtils.GetLayersError<{ [K in keyof TDeps]: TDeps[K]["Default"] }>,
     LayerUtils.GetLayersSuccess<{ [K in keyof TDeps]: TDeps[K]["Default"] }>
@@ -78,14 +82,14 @@ export const mergeContextProviders = <
             handle: handle[Symbol.toStringTag] === "GeneratorFunction" ? Effect.fnUntraced(handle)() : handle
           }
         ))
-        // services are effects which return some ServiceMap.ServiceMap<...>
+        // services are effects which return some Context.Context<...>
         const context = yield* mergeContexts(services as any)
         return context
       })
   }) as any
 })
 
-// Effect Rpc Middleware: for single tag providing, we could use Provides, for providing ServiceMap or Layer (bad boy) we could use Wrap..
+// Effect Rpc Middleware: for single tag providing, we could use Provides, for providing Context or Layer (bad boy) we could use Wrap..
 export const ContextProvider = <
   ContextProviderA,
   MakeContextProviderE,
@@ -97,9 +101,8 @@ export const ContextProvider = <
     effect: Effect.Effect<
       | Effect.Effect<ContextProviderA, never, ContextProviderR>
       | (() => Generator<
-        Yieldable<any, any, never, ContextProviderR>,
-        ContextProviderA,
-        any
+        Effect.Effect<any, never, ContextProviderR>,
+        ContextProviderA
       >),
       MakeContextProviderE,
       MakeContextProviderR | Scope.Scope
@@ -107,7 +110,7 @@ export const ContextProvider = <
     dependencies?: Dependencies
   }
 ) => {
-  const ctx = ServiceMap.Service<
+  const ctx = Context.Service<
     ContextProviderId,
     Effect.Effect<ContextProviderA, never, ContextProviderR>
   >(
@@ -146,17 +149,17 @@ export const MergedContextProvider = <
     Effect.Effect<
       // we need to merge all contexts into one
       // v4: Service.Shape extracts the service value type (v3's Tag.Identifier)
-      ServiceMap.ServiceMap<GetContext<EffectGenUtils.Success<ServiceMap.Service.Shape<TDeps[number]>>>>,
+      Context.Context<GetContext<EffectGenUtils.Success<Context.Service.Shape<TDeps[number]>>>>,
       never,
-      EffectGenUtils.ServiceMap<ServiceMap.Service.Shape<TDeps[number]>>
+      EffectGenUtils.Context<Context.Service.Shape<TDeps[number]>>
     >,
     LayerUtils.GetLayersError<{ [K in keyof TDeps]: TDeps[K]["Default"] }>,
     // v4: Identifier here is correct — it's the nominal service identity for layer provide/exclude
     | Exclude<
-      ServiceMap.Service.Identifier<TDeps[number]>,
+      Context.Service.Identifier<TDeps[number]>,
       LayerUtils.GetLayersSuccess<{ [K in keyof TDeps]: TDeps[K]["Default"] }>
     >
     | LayerUtils.GetLayersContext<{ [K in keyof TDeps]: TDeps[K]["Default"] }>
   >
 
-export const EmptyContextProvider = ContextProvider({ effect: Effect.succeed(Effect.succeed(ServiceMap.empty())) })
+export const EmptyContextProvider = ContextProvider({ effect: Effect.succeed(Effect.succeed(Context.empty())) })

package/src/api/internal/RequestContextMiddleware.ts

@@ -1,8 +1,11 @@
-import { Effect } from "effect-app"
+import * as Effect from "effect-app/Effect"
 import { HttpMiddleware, HttpServerRequest, HttpServerResponse } from "effect-app/http"
+import * as Layer from "effect-app/Layer"
 import { NonEmptyString255 } from "effect-app/Schema"
-import { Locale, RequestContext } from "../../RequestContext.js"
-import { setupRequestContext } from "../setupRequest.js"
+import { Locale, LocaleRef, RequestContext, spanAttributes } from "../../RequestContext.js"
+import { ContextMapContainer } from "../../Store/ContextMapContainer.js"
+import { storeId } from "../../Store/Memory.js"
+import { provideOnRequestScope } from "../setupRequest.js"
 
 export const RequestContextMiddleware = (defaultLocale: Locale = "en") =>
   HttpMiddleware.make((app) =>
@@ -21,18 +24,33 @@ export const RequestContextMiddleware = (defaultLocale: Locale = "en") =>
       const namespace = NonEmptyString255((ns && (Array.isArray(ns) ? ns[0] : ns)) || "primary")
       const deviceId = req.headers["x-fe-device-id"]
 
-      const requestContext = new RequestContext({
+      const requestContext = RequestContext.make({
         span: {
           traceId: currentSpan.traceId,
           spanId: currentSpan.spanId,
           sampled: currentSpan.sampled
         },
-        name: NonEmptyString255(req.originalUrl), // set more detailed elsewhere
+        name: NonEmptyString255(`HTTP ${req.method} ${req.originalUrl.split("?")[0]}`), // set more detailed elsewhere
         locale,
         namespace,
         sourceId: deviceId ? NonEmptyString255(deviceId) : undefined
       })
-      const res = yield* setupRequestContext(app, requestContext)
+      yield* Effect.annotateCurrentSpan(spanAttributes(requestContext))
+      const layer = Layer.mergeAll(
+        ContextMapContainer.layer,
+        Layer.succeed(LocaleRef, requestContext.locale),
+        Layer.succeed(storeId, requestContext.namespace)
+      )
+      // Bind layer to the request scope so ContextMap's finalizer (clear()) runs only
+      // after the response body is fully drained — not when `app` returns its
+      // HttpServerResponse value. Streaming RPC responses keep producing chunks (and
+      // using ContextMap-cached etags) after `app` returns; a sub-scope from
+      // `Effect.provide(layer)` would close too early and wipe etags mid-stream,
+      // causing spurious OptimisticConcurrencyException on later writes.
+      const res = yield* app.pipe(
+        Effect.withLogSpan(requestContext.name),
+        provideOnRequestScope(layer)
+      )
 
       // TODO: how to set also on errors?
       return HttpServerResponse.setHeaders(res, {