@effect-app/infra 2.78.8 → 2.80.0

package/src/api/routing/middleware/DynamicMiddleware.ts

@@ -1,12 +1,14 @@
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
 /* eslint-disable @typescript-eslint/no-unsafe-return */
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { Context, Effect, Layer, type NonEmptyReadonlyArray, Option, type Request, type S, type Scope } from "effect-app"
+import { Rpc, RpcMiddleware } from "@effect/rpc"
+import { type SuccessValue, type TagClass } from "@effect/rpc/RpcMiddleware"
+import { Console, Context, Effect, Layer, type NonEmptyReadonlyArray, type Request, type S, type Schema, type Scope, Unify } from "effect-app"
 import type { GetEffectContext, RPCContextMap } from "effect-app/client/req"
-import { type HttpRouter } from "effect-app/http"
+import { type HttpHeaders } from "effect-app/http"
+import { type TagUnify, type TagUnifyIgnore } from "effect/Context"
 import type * as EffectRequest from "effect/Request"
 import { type ContextTagWithDefault, type LayerUtils } from "../../layerUtils.js"
-import { type ContextProviderId, type ContextProviderShape } from "./ContextProvider.js"
 import { type ContextWithLayer, implementMiddleware } from "./dynamic-middleware.js"
 import { type GenericMiddlewareMaker, genericMiddlewareMaker } from "./generic-middleware.js"
 
@@ -71,7 +73,7 @@ export type RPCHandlerFactory<
 ) => Effect.Effect<
   Request.Request.Success<Req>,
   Request.Request.Error<Req> | RequestContextMapErrors<RequestContextMap>,
-  | HttpRouter.HttpRouter.Provided // because of the context provider and the middleware (Middleware)
+  | Scope.Scope // because of the context provider and the middleware (Middleware)
   | Exclude<
     // the middleware will remove from HandlerR the dynamic context
     // & S.Schema<Req, any, never> is useless here but useful when creating the middleware
@@ -91,16 +93,8 @@ type RequestContextMapProvider<RequestContextMap extends Record<string, RPCConte
 
 export interface MiddlewareMake<
   RequestContextMap extends Record<string, RPCContextMap.Any>, // what services will the middleware provide dynamically to the next, or raise errors.
-  //
-  // ContextProvider is a service that builds additional context for each request.
-  ContextProviderA, // what the context provider provides
-  ContextProviderR extends HttpRouter.HttpRouter.Provided, // what the context provider requires
-  MakeContextProviderE, // what the context provider construction can fail with
-  MakeContextProviderR, // what the context provider construction requires
   DynamicMiddlewareProviders extends RequestContextMapProvider<RequestContextMap>, // how to resolve the dynamic middleware
-  GenericMiddlewareProviders extends ReadonlyArray<
-    ContextTagWithDefault.Base<GenericMiddlewareMaker>
-  >,
+  GenericMiddlewareProviders extends NonEmptyReadonlyArray<GenericMiddlewareMaker>,
   MakeMiddlewareE, // what the middleware construction can fail with
   MakeMiddlewareR, // what the middleware requires to be constructed
   MiddlewareDependencies extends NonEmptyReadonlyArray<Layer.Layer.Any> // layers provided for the middleware to be constructed
@@ -109,25 +103,30 @@ export interface MiddlewareMake<
   dynamicMiddlewares: DynamicMiddlewareProviders
   /** generic middlewares are those which follow the (next) => (input, headers) => pattern */
   genericMiddlewares: GenericMiddlewareProviders
-  /** static context providers */
-  contextProvider?: ContextTagWithDefault<
-    ContextProviderId,
-    ContextProviderShape<ContextProviderA, ContextProviderR>,
-    MakeContextProviderE,
-    MakeContextProviderR
-  >
 
   /* dependencies for the main middleware running just before the next is called */
   dependencies?: MiddlewareDependencies
   // this actually builds "the middleware", i.e. returns the augmented next factory when yielded...
   execute?: (
     maker: (
-      // MiddlewareR is set to ContextProviderA | HttpRouter.HttpRouter.Provided because that's what, at most
+      // MiddlewareR is set to GenericMiddlewareProviders | Scope.Scope because that's what, at most
       // a middleware can additionally require to get executed
-      cb: MakeRPCHandlerFactory<RequestContextMap, ContextProviderA | HttpRouter.HttpRouter.Provided>
-    ) => MakeRPCHandlerFactory<RequestContextMap, ContextProviderA | HttpRouter.HttpRouter.Provided>
+      cb: MakeRPCHandlerFactory<
+        RequestContextMap,
+        | GenericMiddlewareMaker.Provided<GenericMiddlewareProviders[number]>
+        | Scope.Scope
+      >
+    ) => MakeRPCHandlerFactory<
+      RequestContextMap,
+      | GenericMiddlewareMaker.Provided<GenericMiddlewareProviders[number]>
+      | Scope.Scope
+    >
   ) => Effect<
-    MakeRPCHandlerFactory<RequestContextMap, ContextProviderA | HttpRouter.HttpRouter.Provided>,
+    MakeRPCHandlerFactory<
+      RequestContextMap,
+      | GenericMiddlewareMaker.Provided<GenericMiddlewareProviders[number]>
+      | Scope.Scope
+    >,
     MakeMiddlewareE,
     MakeMiddlewareR | Scope // ...that's why MakeMiddlewareR is here
   >
@@ -137,7 +136,7 @@ export interface MiddlewareMakerId {
   _tag: "MiddlewareMaker"
 }
 
-export type Middleware<
+export type RouterMiddleware<
   RequestContextMap extends Record<string, RPCContextMap.Any>, // what services will the middlware provide dynamically to the next, or raise errors.
   MakeMiddlewareE, // what the middleware construction can fail with
   MakeMiddlewareR, // what the middlware requires to be constructed
@@ -145,11 +144,11 @@ export type Middleware<
 > = ContextTagWithDefault<
   MiddlewareMakerId,
   {
+    _tag: "MiddlewareMaker"
     effect: RPCHandlerFactory<RequestContextMap, ContextProviderA>
   },
   MakeMiddlewareE,
-  MakeMiddlewareR,
-  "MiddlewareMaker"
+  MakeMiddlewareR
 >
 
 export type RequestContextMapErrors<RequestContextMap extends Record<string, RPCContextMap.Any>> = S.Schema.Type<
@@ -164,25 +163,13 @@ export const makeMiddleware =
   >() =>
   <
     RequestContextProviders extends RequestContextMapProvider<RequestContextMap>, // how to resolve the dynamic middleware
-    GenericMiddlewareProviders extends ReadonlyArray<
-      ContextTagWithDefault.Base<GenericMiddlewareMaker>
-    >,
+    GenericMiddlewareProviders extends NonEmptyReadonlyArray<GenericMiddlewareMaker>,
     MiddlewareDependencies extends NonEmptyReadonlyArray<Layer.Layer.Any>, // layers provided for the middlware to be constructed
-    //
-    // ContextProvider is a service that builds additional context for each request.
-    ContextProviderA = never, // what the context provider provides
-    ContextProviderR extends HttpRouter.HttpRouter.Provided = never, // what the context provider requires
-    MakeContextProviderE = never, // what the context provider construction can fail with
-    MakeContextProviderR = never, // what the context provider construction requires
     MakeMiddlewareE = never, // what the middleware construction can fail with
     MakeMiddlewareR = never // what the middlware requires to be constructed
   >(
     make: MiddlewareMake<
       RequestContextMap,
-      ContextProviderA,
-      ContextProviderR,
-      MakeContextProviderE,
-      MakeContextProviderR,
       RequestContextProviders,
       GenericMiddlewareProviders,
       MakeMiddlewareE,
@@ -193,7 +180,10 @@ export const makeMiddleware =
     const MiddlewareMaker = Context.GenericTag<
       MiddlewareMakerId,
       {
-        effect: RPCHandlerFactory<RequestContextMap, ContextProviderA>
+        effect: RPCHandlerFactory<
+          RequestContextMap,
+          GenericMiddlewareMaker.Provided<GenericMiddlewareProviders[number]>
+        >
         _tag: "MiddlewareMaker"
       }
     >(
@@ -211,58 +201,67 @@ export const makeMiddleware =
           generic: middlewares.effect,
           middleware: make.execute
             ? make.execute((
-              cb: MakeRPCHandlerFactory<RequestContextMap, HttpRouter.HttpRouter.Provided | ContextProviderA>
+              cb: MakeRPCHandlerFactory<
+                RequestContextMap,
+                Scope.Scope | GenericMiddlewareMaker.Provided<GenericMiddlewareProviders[number]>
+              >
             ) => cb)
             : Effect.succeed<
-              MakeRPCHandlerFactory<RequestContextMap, ContextProviderA | HttpRouter.HttpRouter.Provided>
-            >((_schema, next) => (payload, headers) => next(payload, headers)),
-          contextProvider: make.contextProvider
-            ? make.contextProvider.pipe(Effect.map(Effect.map(Option.some)))
-            : Effect.succeed(Effect.succeed(Option.none())) // uses the middleware.contextProvider tag to get the context provider service
+              MakeRPCHandlerFactory<
+                RequestContextMap,
+                Scope.Scope | GenericMiddlewareMaker.Provided<GenericMiddlewareProviders[number]>
+              >
+            >((_schema, next) => (payload, headers) => next(payload, headers))
         })
         .pipe(
-          Effect.map(({ contextProvider, dynamicMiddlewares, generic, middleware }) => ({
+          Effect.map(({ dynamicMiddlewares, generic, middleware }) => ({
             _tag: "MiddlewareMaker" as const,
-            effect: makeRpcEffect<RequestContextMap, ContextProviderA>()(
+            effect: makeRpcEffect<
+              RequestContextMap,
+              GenericMiddlewareMaker.Provided<GenericMiddlewareProviders[number]>
+            >()(
               (schema, next, moduleName) => {
                 const h = middleware(schema, next as any, moduleName)
                 return (payload, headers) =>
-                  Effect.gen(function*() {
-                    return yield* generic({
-                      payload,
-                      headers,
-                      rpc: { _tag: `${moduleName}.${payload._tag}` }, // todo: make moduleName part of the tag on S.Req creation.
-                      next: Effect.gen(function*() {
-                        yield* Effect.annotateCurrentSpan(
-                          "request.name",
-                          moduleName ? `${moduleName}.${payload._tag}` : payload._tag
-                        )
+                  Effect
+                    .gen(function*() {
+                      const gen = generic({
+                        payload,
+                        headers,
+                        clientId: 0, // TODO: get the clientId from the request context
+                        rpc: {
+                          ...Rpc.fromTaggedRequest(schema as any),
+                          // middlewares ? // todo: get from actual middleware flow?
+                          annotations: Context.empty(), // TODO //Annotations(schema as any),
+                          // successSchema: schema.success ?? Schema.Void,
+                          // errorSchema: schema.failure ?? Schema.Never,
+                          payloadSchema: schema,
+                          _tag: `${moduleName}.${payload._tag}`,
+                          key: `${moduleName}.${payload._tag}` /* ? */
+                          // clientId: 0 as number /* ? */
+                        }, // todo: make moduleName part of the tag on S.Req creation.
+                        next:
+                          // the contextProvider is an Effect that builds the context for the request
+                          // the dynamicMiddlewares is an Effect that builds the dynamiuc context for the request
+                          dynamicMiddlewares(schema.config ?? {}, headers).pipe(
+                            Effect.flatMap((dynamicContext) => h(payload, headers).pipe(Effect.provide(dynamicContext)))
+                          ) as any
+                      })
+                      console.log({ gen })
 
-                        // the contextProvider is an Effect that builds the context for the request
-                        return yield* contextProvider.pipe(
-                          Effect.flatMap((contextProviderContext) =>
-                            // the dynamicMiddlewares is an Effect that builds the dynamiuc context for the request
-                            dynamicMiddlewares(schema.config ?? {}, headers).pipe(
-                              Effect.flatMap((dynamicContext) =>
-                                h(payload, headers).pipe(Effect.provide(dynamicContext))
-                              ),
-                              Effect.provide(Option.getOrElse(contextProviderContext, () => Context.empty()))
-                            )
-                          )
-                        )
-                      }) as any
+                      return yield* gen
                     })
-                  }) as any // why?
+                    .pipe(Effect.onExit(Console.log)) as any // why?
               }
             )
-          }))
+          })),
+          Effect.onExit(Console.log)
         )
     )
 
     const dependencies = [
       ...(make.dependencies ? make.dependencies : []),
       ...(dynamicMiddlewares.dependencies as any),
-      ...(make.contextProvider?.Default ? [make.contextProvider.Default] : []),
       ...middlewares.dependencies
     ]
     const middlewareLayer = l
@@ -271,14 +270,12 @@ export const makeMiddleware =
       ) as Layer.Layer<
         MiddlewareMakerId,
         | MakeMiddlewareE // what the middleware construction can fail with
-        | LayerUtils.GetLayersContext<typeof dynamicMiddlewares.dependencies>
-        | LayerUtils.GetLayersContext<typeof middlewares.dependencies> // what could go wrong when building the dynamic middleware provider
-        | MakeContextProviderE, // what could go wrong when building the context provider
+        | LayerUtils.GetLayersError<typeof dynamicMiddlewares.dependencies>
+        | LayerUtils.GetLayersError<typeof middlewares.dependencies>, // what could go wrong when building the dynamic middleware provider
         | LayerUtils.GetLayersContext<MiddlewareDependencies> // what's needed to build layers
         | LayerUtils.GetLayersContext<typeof middlewares.dependencies>
         | LayerUtils.GetLayersContext<typeof dynamicMiddlewares.dependencies> // what's needed to build dynamic middleware layers
         | Exclude<MakeMiddlewareR, LayerUtils.GetLayersSuccess<MiddlewareDependencies>> // what layers provides
-        | MakeContextProviderR // what's needed to build the contextProvider
       >
 
     return Object.assign(MiddlewareMaker, { Default: middlewareLayer })
@@ -313,7 +310,7 @@ function makeRpcEffect<
     ) => Effect.Effect<
       Request.Request.Success<Req>,
       Request.Request.Error<Req> | RequestContextMapErrors<RequestContextMap>,
-      | HttpRouter.HttpRouter.Provided // the context provider may require HttpRouter.Provided to run
+      | Scope.Scope // the context provider may require Scope to run
       | Exclude<
         // it can also be removed from HandlerR
         Exclude<HandlerR, GetEffectContext<RequestContextMap, (T & S.Schema<Req, any, never>)["config"]>>,
@@ -322,3 +319,90 @@ function makeRpcEffect<
     >
   ) => cb
 }
+
+// updated to support Scope.Scope
+export interface RpcMiddleware<Provides, E> {
+  (options: {
+    readonly clientId: number
+    readonly rpc: Rpc.AnyWithProps
+    readonly payload: unknown
+    readonly headers: HttpHeaders.Headers
+  }): Effect.Effect<Provides, E, Scope.Scope>
+}
+export interface RpcMiddlewareWrap<Provides, E> {
+  (options: {
+    readonly clientId: number
+    readonly rpc: Rpc.AnyWithProps
+    readonly payload: unknown
+    readonly headers: HttpHeaders.Headers
+    readonly next: Effect.Effect<SuccessValue, E, Provides | Scope.Scope>
+  }): Effect.Effect<SuccessValue, E, Scope.Scope>
+}
+
+type RpcOptionsOriginal = {
+  readonly wrap?: boolean
+  readonly optional?: boolean
+  readonly failure?: Schema.Schema.All
+  readonly provides?: Context.Tag<any, any>
+  readonly requiredForClient?: boolean
+}
+
+export const Tag = <Self>() =>
+<
+  const Name extends string,
+  const Options extends RpcOptionsOriginal
+>(
+  id: Name,
+  options?: Options | undefined
+) =>
+<E, R, L extends NonEmptyReadonlyArray<Layer.Layer.Any>>(opts: {
+  effect: Effect.Effect<
+    TagClass.Wrap<Options> extends true ? RpcMiddlewareWrap<
+        TagClass.Provides<Options>,
+        TagClass.Failure<Options>
+      >
+      : RpcMiddleware<
+        TagClass.Service<Options>,
+        TagClass.FailureService<Options>
+      >,
+    E,
+    R
+  >
+  dependencies?: L
+}): RpcMiddleware.TagClass<Self, Name, Options> & {
+  Default: Layer.Layer<Self, E | LayerUtils.GetLayersError<L>, Exclude<R, LayerUtils.GetLayersSuccess<L>>>
+} =>
+  class extends RpcMiddleware.Tag<Self>()(id, options) {
+    static readonly Default = Layer.scoped(this, opts.effect as any).pipe(
+      Layer.provide([Layer.empty, ...opts.dependencies ?? []])
+    )
+    static override [Unify.typeSymbol]?: unknown
+    static override [Unify.unifySymbol]?: TagUnify<typeof this>
+    static override [Unify.ignoreSymbol]?: TagUnifyIgnore
+  } as any
+
+// export const Tag = <Self>() =>
+// <
+//   const Name extends string,
+//   const Options extends Omit<RpcOptionsOriginal, "wrap">
+// >(
+//   id: Name,
+//   options?: Options | undefined
+// ) =>
+//   OurTag<Self>()(id, { ...options, wrap: true } as Options & { wrap: true }) as <
+//     E,
+//     R,
+//     L extends NonEmptyReadonlyArray<Layer.Layer.Any>
+//   >(opts: {
+//     effect: Effect.Effect<
+//       RpcMiddlewareWrap<
+//         RpcMiddleware.TagClass.Provides<Options>,
+//         RpcMiddleware.TagClass.Failure<Options>
+//       >,
+//       E,
+//       R
+//     >
+//     dependencies?: L
+//   }) => RpcMiddleware.TagClass<Self, Name, Options> & {
+//     Default: Layer.Layer<Self, E | LayerUtils.GetLayersError<L>, Exclude<R, LayerUtils.GetLayersSuccess<L>>>
+//   }

package/src/api/routing/middleware/generic-middleware.ts

@@ -1,44 +1,80 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { type Array, Effect } from "effect-app"
-import { type HttpHeaders, type HttpRouter } from "effect-app/http"
-import { type ContextTagWithDefault } from "../../layerUtils.js"
+import { type Rpc, type RpcMiddleware } from "@effect/rpc"
+import { type SuccessValue, type TagClassAny } from "@effect/rpc/RpcMiddleware"
+import { type Array, Context, Effect, type Layer, type Scope } from "effect-app"
+import { type HttpHeaders } from "effect-app/http"
+import { InfraLogger } from "../../../logger.js"
 
-export interface GenericMiddlewareOptions<A, E> {
+export interface GenericMiddlewareOptions<E> {
   // Effect rpc middleware does not support changing payload or headers, but we do..
-  readonly next: Effect.Effect<A, E, HttpRouter.HttpRouter.Provided>
+  readonly next: Effect.Effect<SuccessValue, E, Scope.Scope>
   readonly payload: unknown
   readonly headers: HttpHeaders.Headers
-  // readonly clientId: number
-  readonly rpc: { _tag: string } // Rpc.AnyWithProps
+  readonly clientId: number
+  readonly rpc: Rpc.AnyWithProps
 }
 
-export type GenericMiddlewareMaker = <A, E>(
-  options: GenericMiddlewareOptions<A, E>
-) => Effect.Effect<A, E, HttpRouter.HttpRouter.Provided>
+export type GenericMiddlewareMaker = TagClassAny & { Default: Layer.Layer.Any } // todo; and Layer..
+
+export namespace GenericMiddlewareMaker {
+  export type Provided<T> = T extends TagClassAny
+    ? T extends { provides: Context.Tag<any, any> } ? Context.Tag.Identifier<T["provides"]> : never
+    : never
+}
 
 export const genericMiddleware = (i: GenericMiddlewareMaker) => i
 
 export const genericMiddlewareMaker = <
-  T extends Array<
-    ContextTagWithDefault.Base<GenericMiddlewareMaker>
-  >
+  T extends Array<GenericMiddlewareMaker>
 >(...middlewares: T): {
   dependencies: { [K in keyof T]: T[K]["Default"] }
-  effect: Effect.Effect<GenericMiddlewareMaker>
+  effect: Effect.Effect<RpcMiddleware.RpcMiddlewareWrap<any, any>>
 } => {
+  // we want to run them in reverse order
+  middlewares = middlewares.toReversed() as any
   return {
     dependencies: middlewares.map((_) => _.Default),
     effect: Effect.gen(function*() {
-      const middlewaresInstances = yield* Effect.all(middlewares)
+      const context = yield* Effect.context()
+      // const middlewares: readonly (RpcMiddlewareWrap<any, any> | RpcMiddleware.RpcMiddleware<any, any>)[] =
+      //   (yield* Effect.all(
+      //     middlewares
+      //   )) as any
 
-      return <A, E>(
-        options: GenericMiddlewareOptions<A, E>
+      return <E>(
+        options: GenericMiddlewareOptions<E>
       ) => {
-        let next = options.next
-        for (const middleware of (middlewaresInstances as any[]).toReversed()) {
-          next = middleware({ ...options, next })
+        let handler = options.next
+        // copied from RpcMiddleare
+        for (const tag of middlewares) {
+          if (tag.wrap) {
+            const middleware = Context.unsafeGet(context, tag)
+            handler = InfraLogger.logDebug("Applying middleware " + tag.key).pipe(
+              Effect.zipRight(middleware({ ...options, next: handler as any }))
+            ) as any
+          } else if (tag.optional) {
+            const middleware = Context.unsafeGet(context, tag) as RpcMiddleware.RpcMiddleware<any, any>
+            const previous = handler
+            handler = InfraLogger.logDebug("Applying middleware " + tag.key).pipe(
+              Effect.zipRight(Effect.matchEffect(middleware(options), {
+                onFailure: () => previous,
+                onSuccess: tag.provides !== undefined
+                  ? (value) => Effect.provideService(previous, tag.provides as any, value)
+                  : (_) => previous
+              }))
+            )
+          } else {
+            const middleware = Context.unsafeGet(context, tag) as RpcMiddleware.RpcMiddleware<any, any>
+            handler = InfraLogger.logDebug("Applying middleware " + tag.key).pipe(
+              Effect.zipRight(
+                tag.provides !== undefined
+                  ? Effect.provideServiceEffect(handler, tag.provides as any, middleware(options))
+                  : Effect.zipRight(middleware(options), handler)
+              )
+            )
+          }
         }
-        return next
+        return handler
       }
     })
   } as any

package/src/api/routing/middleware/middleware.ts

@@ -3,46 +3,38 @@ import { Cause, Context, Effect, ParseResult } from "effect-app"
 import { pretty } from "effect-app/utils"
 import { logError, reportError } from "../../../errorReporter.js"
 import { InfraLogger } from "../../../logger.js"
-import { genericMiddleware, RequestCacheLayers } from "../../routing.js"
+import { RequestCacheLayers, Tag } from "../../routing.js"
 
 const logRequestError = logError("Request")
 const reportRequestError = reportError("Request")
 
 export class DevMode extends Context.Reference<DevMode>()("DevMode", { defaultValue: () => false }) {}
-// Effect Rpc Middleware: Wrap
-export class RequestCacheMiddleware extends Effect.Service<RequestCacheMiddleware>()("RequestCacheMiddleware", {
-  effect: Effect.gen(function*() {
-    return genericMiddleware(Effect.fnUntraced(function*(options) {
-      return yield* options.next.pipe(Effect.provide(RequestCacheLayers))
-    }))
-  })
-}) {}
 
-// Effect Rpc Middleware: Wrap
-export class ConfigureInterruptibility extends Effect.Service<ConfigureInterruptibility>()(
-  "ConfigureInterruptibility",
-  {
-    effect: Effect.gen(function*() {
-      return genericMiddleware(Effect.fnUntraced(function*(options) {
-        return yield* options.next.pipe(
-          // TODO: make this depend on query/command, and consider if middleware also should be affected. right now it's not.
-          Effect.uninterruptible
-        )
-      }))
-    })
-  }
-) {}
+export class RequestCacheMiddleware extends Tag<RequestCacheMiddleware>()("RequestCacheMiddleware", { wrap: true })({
+  effect: Effect.succeed((options) => options.next.pipe(Effect.provide(RequestCacheLayers)))
+}) {
+}
 
-// Effect Rpc Middleware: Wrap
-export class MiddlewareLogger extends Effect.Service<MiddlewareLogger>()("MiddlewareLogger", {
-  effect: Effect.gen(function*() {
-    return genericMiddleware(Effect.fnUntraced(function*({ headers, next, payload, rpc }) {
-      const devMode = yield* DevMode
+export class ConfigureInterruptibility
+  extends Tag<ConfigureInterruptibility>()("ConfigureInterruptibility", { wrap: true })({
+    effect: Effect.succeed((options) =>
+      options.next.pipe(
+        // TODO: make this depend on query/command, and consider if middleware also should be affected. right now it's not.
+        Effect.uninterruptible
+      )
+    )
+  })
+{
+}
 
-      return yield* Effect
-        .annotateCurrentSpan(
-          "requestInput",
-          typeof payload === "object" && payload !== null
+export class MiddlewareLogger extends Tag<MiddlewareLogger>()("MiddlewareLogger", { wrap: true })({
+  effect: Effect.gen(function*() {
+    const devMode = yield* DevMode
+    return ({ headers, next, payload, rpc }) =>
+      Effect
+        .annotateCurrentSpan({
+          "request.name": rpc._tag,
+          "requestInput": typeof payload === "object" && payload !== null
             ? Object.entries(payload).reduce((prev, [key, value]: [string, unknown]) => {
               prev[key] = key === "password"
                 ? "<redacted>"
@@ -60,7 +52,7 @@ export class MiddlewareLogger extends Effect.Service<MiddlewareLogger>()("Middle
               return prev
             }, {} as Record<string, string | number | boolean>)
             : payload
-        )
+        })
         .pipe(
           // can't use andThen due to some being a function and effect
           Effect.zipRight(next),
@@ -92,9 +84,9 @@ export class MiddlewareLogger extends Effect.Service<MiddlewareLogger>()("Middle
           ),
           devMode ? (_) => _ : Effect.catchAllDefect(() => Effect.die("Internal Server Error"))
         )
-    }))
   })
-}) {}
+}) {
+}
 
 export const DefaultGenericMiddlewares = [
   RequestCacheMiddleware,

package/src/api/routing/middleware.ts

@@ -5,3 +5,5 @@ export * from "./middleware/DynamicMiddleware.js"
 export * from "./middleware/generic-middleware.js"
 export * from "./middleware/middleware.js"
 // codegen:end
+
+export * as Middleware from "./middleware.js"

package/src/api/routing.ts

@@ -4,14 +4,14 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { determineMethod, isCommand } from "@effect-app/infra/api/routing/utils"
 import { Rpc, RpcGroup, RpcServer } from "@effect/rpc"
-import { type Array, Duration, Effect, Layer, type NonEmptyReadonlyArray, Predicate, Request, S, Schedule, Schema } from "effect-app"
+import { type Array, Duration, Effect, Layer, type NonEmptyReadonlyArray, Predicate, Request, S, Schedule, Schema, type Scope } from "effect-app"
 import type { GetEffectContext, GetEffectError, RPCContextMap } from "effect-app/client/req"
 import { type HttpHeaders, HttpRouter } from "effect-app/http"
 import { typedKeysOf, typedValuesOf } from "effect-app/utils"
 import type { Contravariant } from "effect/Types"
 import { type YieldWrap } from "effect/Utils"
 import { type LayerUtils } from "./layerUtils.js"
-import { DevMode, type Middleware } from "./routing/middleware.js"
+import { DevMode, type RouterMiddleware } from "./routing/middleware.js"
 
 export * from "./routing/middleware.js"
 
@@ -123,7 +123,7 @@ type Match<
     RT,
     Exclude<
       Exclude<R2, GetEffectContext<RequestContextMap, Resource[Key]["config"]>>,
-      HttpRouter.HttpRouter.Provided
+      Scope.Scope
     >
   >
 
@@ -134,7 +134,7 @@ type Match<
     RT,
     Exclude<
       Exclude<R2, GetEffectContext<RequestContextMap, Resource[Key]["config"]>>,
-      HttpRouter.HttpRouter.Provided
+      Scope.Scope
     >
   >
 }
@@ -168,7 +168,7 @@ export const makeRouter = <
   MakeMiddlewareR,
   ContextProviderA
 >(
-  middleware: Middleware<
+  middleware: RouterMiddleware<
     RequestContextMap,
     MakeMiddlewareE,
     MakeMiddlewareR,
@@ -340,7 +340,7 @@ export const makeRouter = <
             | GetEffectContext<RequestContextMap, Resource[K]["config"]>
             | ContextProviderA
           >,
-          HttpRouter.HttpRouter.Provided
+          Scope.Scope
         >
       >
     } = (impl: Record<keyof RequestModules, any>) =>
@@ -405,8 +405,7 @@ export const makeRouter = <
                   handle(req, headers).pipe(
                     Effect.withSpan("Request." + meta.moduleName + "." + resource._tag, {
                       captureStackTrace: () => handler.stack
-                    }),
-                    Effect.provideService(DevMode, devMode)
+                    })
                   ),
                 meta.moduleName
               ),
@@ -469,7 +468,8 @@ export const makeRouter = <
           Layer.provide([
             ...dependencies ?? [],
             middleware.Default
-          ] as any) as any
+          ] as any) as any,
+          Layer.provide(Layer.succeed(DevMode, devMode))
         )
       ) as (Layer.Layer<
         Router,
@@ -751,7 +751,7 @@ export const makeRouter = <
         //   RPCRouteR<
         //     { [K in keyof Filter<Resource>]: Rpc.Rpc<Resource[K], Effect.Context<ReturnType<THandlers[K]["handler"]>>> }[keyof Filter<Resource>]
         //   >,
-        //   HttpRouter.HttpRouter.Provided
+        //   Scope.Scope
         // >
         routes: any