@effect-app/infra 2.87.2 → 2.88.0

package/dist/api/routing/middleware/middleware-api.js

@@ -2,57 +2,66 @@ import { Rpc } from "@effect/rpc";
 import { Context, Effect, Layer } from "effect-app";
 import { genericMiddlewareMaker } from "./generic-middleware.js";
 import { makeRpcEffect } from "./RouterMiddleware.js";
-// TODO: don't expect service when it's wrap/never
-// perhaps RequestContextMap should be an object, instead of an interface, so that we don't need to provide anything here
-export const contextMap = () => (a, service) => ({
-    key: a,
-    settings: { service }
+// adapter used when setting the dynamic prop on a middleware implementation
+export const contextMap = (rcm, key) => ({
+    key,
+    settings: { service: rcm[key]["service"] }
 });
-export const makeMiddleware = () => {
+export const makeMiddleware = (rcm) => {
     let allMiddleware = [];
     const it = {
         middleware: (...middlewares) => {
             for (const mw of middlewares) {
+                // recall that we run middlewares in reverse order
                 allMiddleware = [mw, ...allMiddleware];
             }
-            // TODO: support dynamic and generic intertwined. treat them as one
-            return Object.assign(makeMiddlewareBasic(...allMiddleware), it);
+            return allMiddleware.filter((m) => !!m.dynamic).length !== Object.keys(rcm).length
+                // for sure, until all the dynamic middlewares are provided it's non sensical to call makeMiddlewareBasic
+                ? it
+                // actually, we don't know yet if MiddlewareR is never, but we can't easily check it at runtime
+                : Object.assign(makeMiddlewareBasic(rcm, ...allMiddleware), it);
         }
     };
     return it;
 };
-export const makeMiddlewareBasic = 
+//
+export const MiddlewareMakerTag = "MiddlewareMaker";
+export const buildMiddlewareMaker = (eff) => ({
+    _tag: MiddlewareMakerTag,
+    effect: eff
+});
+const makeMiddlewareBasic = 
 // by setting RequestContextMap beforehand, execute contextual typing does not fuck up itself to anys
-(...make) => {
-    const MiddlewareMaker = Context.GenericTag("MiddlewareMaker");
+(_rcm, ...make) => {
+    const MiddlewareMaker = Context.GenericTag(MiddlewareMakerTag);
+    // reverse middlewares and wrap one after the other
     const middlewares = genericMiddlewareMaker(...make);
     const l = Layer.scoped(MiddlewareMaker, middlewares
         .effect
-        .pipe(Effect.map((generic) => ({
-        _tag: "MiddlewareMaker",
-        effect: makeRpcEffect()((schema, next, moduleName) => {
-            return (payload, headers) => Effect
-                .gen(function* () {
-                const basic = {
-                    config: schema.config ?? {},
-                    payload,
-                    headers,
-                    clientId: 0, // TODO: get the clientId from the request context
-                    rpc: {
-                        ...Rpc.fromTaggedRequest(schema),
-                        key: `${moduleName}.${payload._tag}`,
-                        _tag: `${moduleName}.${payload._tag}`
-                    }
-                };
-                return yield* generic({
-                    ...basic,
-                    next: next(payload, headers)
-                });
-            }); // why?
-        })
-    }))));
+        .pipe(Effect.map((generic) => (buildMiddlewareMaker(makeRpcEffect()((schema, handler, moduleName) => {
+        return (payload, headers) => Effect
+            .gen(function* () {
+            // will be propagated to all the wrapped middlewares
+            const basic = {
+                config: schema.config ?? {},
+                payload,
+                headers,
+                clientId: 0, // TODO: get the clientId from the request context
+                rpc: {
+                    ...Rpc.fromTaggedRequest(schema),
+                    key: `${moduleName}.${payload._tag}`,
+                    _tag: `${moduleName}.${payload._tag}`
+                }
+            };
+            return yield* generic({
+                ...basic,
+                next: handler(payload, headers)
+            });
+        }); // why? because: Type 'SuccessValue' is not assignable to type 'Success<Req>' :P
+    }))))));
     const middlewareLayer = l
         .pipe(Layer.provide(middlewares.dependencies));
+    // add to the tag a default implementation
     return Object.assign(MiddlewareMaker, { Default: middlewareLayer });
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/api/routing/middleware/middleware.d.ts

@@ -10,20 +10,20 @@ declare const RequestCacheMiddleware_base: import("./RpcMiddleware.js").TagClass
 };
 export declare class RequestCacheMiddleware extends RequestCacheMiddleware_base {
 }
-declare const ConfigureInterruptibility_base: import("./RpcMiddleware.js").TagClass<ConfigureInterruptibility, "ConfigureInterruptibility", {
+declare const ConfigureInterruptibilityMiddleware_base: import("./RpcMiddleware.js").TagClass<ConfigureInterruptibilityMiddleware, "ConfigureInterruptibilityMiddleware", {
     readonly wrap: true;
 }> & {
-    Default: Layer.Layer<ConfigureInterruptibility, never, never>;
+    Default: Layer.Layer<ConfigureInterruptibilityMiddleware, never, never>;
 };
-export declare class ConfigureInterruptibility extends ConfigureInterruptibility_base {
+export declare class ConfigureInterruptibilityMiddleware extends ConfigureInterruptibilityMiddleware_base {
 }
-declare const MiddlewareLogger_base: import("./RpcMiddleware.js").TagClass<MiddlewareLogger, "MiddlewareLogger", {
+declare const LoggerMiddleware_base: import("./RpcMiddleware.js").TagClass<LoggerMiddleware, "LoggerMiddleware", {
     readonly wrap: true;
 }> & {
-    Default: Layer.Layer<MiddlewareLogger, never, never>;
+    Default: Layer.Layer<LoggerMiddleware, never, never>;
 };
-export declare class MiddlewareLogger extends MiddlewareLogger_base {
+export declare class LoggerMiddleware extends LoggerMiddleware_base {
 }
-export declare const DefaultGenericMiddlewares: readonly [typeof RequestCacheMiddleware, typeof ConfigureInterruptibility, typeof MiddlewareLogger];
+export declare const DefaultGenericMiddlewares: readonly [typeof RequestCacheMiddleware, typeof ConfigureInterruptibilityMiddleware, typeof LoggerMiddleware];
 export {};
 //# sourceMappingURL=middleware.d.ts.map

package/dist/api/routing/middleware/middleware.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"middleware.d.ts","sourceRoot":"","sources":["../../../../src/api/routing/middleware/middleware.ts"],"names":[],"mappings":"AACA,OAAO,EAAS,OAAO,EAAoB,KAAK,EAAwB,MAAM,YAAY,CAAA;AAS1F,eAAO,MAAM,kBAAkB,kCAM9B,CAAA;;AAED,qBAAa,OAAQ,SAAQ,YAAsE;CAAG;;;;;;AAEtG,qBAAa,sBAAuB,SAAQ,2BAE1C;CACD;;;;;;AAED,qBAAa,yBACX,SAAQ,8BAON;CAEH;;;;;;AAED,qBAAa,gBAAiB,SAAQ,qBA0DpC;CACD;AAED,eAAO,MAAM,yBAAyB,qGAI5B,CAAA"}
+{"version":3,"file":"middleware.d.ts","sourceRoot":"","sources":["../../../../src/api/routing/middleware/middleware.ts"],"names":[],"mappings":"AACA,OAAO,EAAS,OAAO,EAAoB,KAAK,EAAwB,MAAM,YAAY,CAAA;AAS1F,eAAO,MAAM,kBAAkB,kCAM9B,CAAA;;AAED,qBAAa,OAAQ,SAAQ,YAAsE;CAAG;;;;;;AAEtG,qBAAa,sBAAuB,SAAQ,2BAE1C;CACD;;;;;;AAED,qBAAa,mCACX,SAAQ,wCAON;CAEH;;;;;;AAED,qBAAa,gBAAiB,SAAQ,qBA0DpC;CACD;AAED,eAAO,MAAM,yBAAyB,+GAI5B,CAAA"}

package/dist/api/routing/middleware/middleware.js

@@ -13,13 +13,13 @@ export class RequestCacheMiddleware extends Tag()("RequestCacheMiddleware", { wr
     effect: Effect.succeed(({ next }) => next.pipe(Effect.provide(RequestCacheLayers)))
 }) {
 }
-export class ConfigureInterruptibility extends Tag()("ConfigureInterruptibility", { wrap: true })({
+export class ConfigureInterruptibilityMiddleware extends Tag()("ConfigureInterruptibilityMiddleware", { wrap: true })({
     effect: Effect.succeed(({ next }) => 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 MiddlewareLogger extends Tag()("MiddlewareLogger", { wrap: true })({
+export class LoggerMiddleware extends Tag()("LoggerMiddleware", { wrap: true })({
     effect: Effect.gen(function* () {
         const devMode = yield* DevMode;
         return ({ headers, next, payload, rpc }) => Effect
@@ -74,7 +74,7 @@ export class MiddlewareLogger extends Tag()("MiddlewareLogger", { wrap: true })(
 }
 export const DefaultGenericMiddlewares = [
     RequestCacheMiddleware,
-    ConfigureInterruptibility,
-    MiddlewareLogger
+    ConfigureInterruptibilityMiddleware,
+    LoggerMiddleware
 ];
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect-app/infra",
-  "version": "2.87.2",
+  "version": "2.88.0",
   "license": "MIT",
   "type": "module",
   "dependencies": {
@@ -13,7 +13,7 @@
     "proper-lockfile": "^4.1.2",
     "pure-rand": "7.0.1",
     "query-string": "^9.2.2",
-    "effect-app": "2.52.0"
+    "effect-app": "2.52.1"
   },
   "devDependencies": {
     "@azure/cosmos": "^4.5.0",

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

@@ -5,42 +5,10 @@ import { type Effect, type Request, type S, type Scope } from "effect-app"
 import type { GetEffectContext, RPCContextMap } from "effect-app/client/req"
 import type * as EffectRequest from "effect/Request"
 import { type ContextTagWithDefault } from "../../layerUtils.js"
-import { type ContextWithLayer } from "./dynamic-middleware.js"
+import { type MiddlewareMaker, type MiddlewareMakerId } from "./middleware-api.js"
 
 // module:
 //
-export type MakeRPCHandlerFactory<
-  RequestContextMap extends Record<string, RPCContextMap.Any>,
-  MiddlewareR
-> = <
-  T extends {
-    config?: Partial<Record<keyof RequestContextMap, any>>
-  },
-  Req extends S.TaggedRequest.All,
-  HandlerR
->(
-  schema: T & S.Schema<Req, any, never>,
-  next: (
-    request: Req,
-    headers: any
-  ) => Effect.Effect<
-    EffectRequest.Request.Success<Req>,
-    EffectRequest.Request.Error<Req>,
-    // dynamic middlewares removes the dynamic context from HandlerR
-    Exclude<HandlerR, GetEffectContext<RequestContextMap, (T & S.Schema<Req, any, never>)["config"]>>
-  >,
-  moduleName: string
-) => (
-  req: Req,
-  headers: any
-) => Effect.Effect<
-  Request.Request.Success<Req>,
-  Request.Request.Error<Req> | RequestContextMapErrors<RequestContextMap>,
-  // the middleware will remove from HandlerR the dynamic context, but will also add some requirements
-  | MiddlewareR
-  // & S.Schema<Req, any, never> is useless here but useful when creating the middleware
-  | Exclude<HandlerR, GetEffectContext<RequestContextMap, (T & S.Schema<Req, any, never>)["config"]>>
->
 
 export type RPCHandlerFactory<
   RequestContextMap extends Record<string, RPCContextMap.Any>,
@@ -53,7 +21,7 @@ export type RPCHandlerFactory<
   HandlerR
 >(
   schema: T & S.Schema<Req, any, never>,
-  next: (
+  handler: (
     request: Req,
     headers: any
   ) => Effect.Effect<
@@ -67,29 +35,17 @@ export type RPCHandlerFactory<
   headers: any
 ) => Effect.Effect<
   Request.Request.Success<Req>,
-  Request.Request.Error<Req> | RequestContextMapErrors<RequestContextMap>,
-  | Scope.Scope // because of the context provider and the middleware (Middleware)
+  | Request.Request.Error<Req>
+  | RequestContextMapErrors<RequestContextMap>,
+  | Scope.Scope // the context provider may require Scope to run
   | Exclude<
     // the middleware will remove from HandlerR the dynamic context
-    // & S.Schema<Req, any, never> is useless here but useful when creating the middleware
     Exclude<HandlerR, GetEffectContext<RequestContextMap, (T & S.Schema<Req, any, never>)["config"]>>,
-    // the context provider provides additional stuff both to the middleware and the next
+    // the context provider provides additional stuff both to the middleware and the handler
     ContextProviderA
   >
 >
 
-export type RequestContextMapProvider<RequestContextMap extends Record<string, RPCContextMap.Any>> = {
-  [K in keyof RequestContextMap]: ContextWithLayer.Base<
-    { [K in keyof RequestContextMap]?: RequestContextMap[K]["contextActivation"] },
-    RequestContextMap[K]["service"],
-    S.Schema.Type<RequestContextMap[K]["error"]>
-  >
-}
-
-export interface MiddlewareMakerId {
-  _tag: "MiddlewareMaker"
-}
-
 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
@@ -97,10 +53,7 @@ export type RouterMiddleware<
   ContextProviderA // what the context provider provides
 > = ContextTagWithDefault<
   MiddlewareMakerId,
-  {
-    _tag: "MiddlewareMaker"
-    effect: RPCHandlerFactory<RequestContextMap, ContextProviderA>
-  },
+  MiddlewareMaker<RPCHandlerFactory<RequestContextMap, ContextProviderA>>,
   MakeMiddlewareE,
   MakeMiddlewareR
 >
@@ -114,36 +67,5 @@ export function makeRpcEffect<
   RequestContextMap extends Record<string, RPCContextMap.Any>,
   ContextProviderA
 >() {
-  return (
-    cb: <
-      T extends {
-        config?: Partial<Record<keyof RequestContextMap, any>>
-      },
-      Req extends S.TaggedRequest.All,
-      HandlerR
-    >(
-      schema: T & S.Schema<Req, any, never>,
-      next: (
-        request: Req,
-        headers: any
-      ) => Effect.Effect<
-        EffectRequest.Request.Success<Req>,
-        EffectRequest.Request.Error<Req>,
-        HandlerR
-      >,
-      moduleName: string
-    ) => (
-      req: Req,
-      headers: any
-    ) => Effect.Effect<
-      Request.Request.Success<Req>,
-      Request.Request.Error<Req> | RequestContextMapErrors<RequestContextMap>,
-      | 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"]>>,
-        ContextProviderA
-      >
-    >
-  ) => cb
+  return (cb: RPCHandlerFactory<RequestContextMap, ContextProviderA>) => cb
 }

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

@@ -4,12 +4,12 @@
 import { type Rpc, RpcMiddleware } from "@effect/rpc"
 import { type SuccessValue, type TypeId } from "@effect/rpc/RpcMiddleware"
 import { type Context, type Effect, Layer, type NonEmptyReadonlyArray, type Option, type S, type Schema, type Scope, Unify } from "effect-app"
-import type { AnyService, ContextRepr, RPCContextMap } from "effect-app/client/req"
+import type { AnyService, ContextTagArray, RPCContextMap } from "effect-app/client/req"
 import { type HttpHeaders } from "effect-app/http"
 import { type TagUnify, type TagUnifyIgnore } from "effect/Context"
 import { type LayerUtils } from "../../layerUtils.js"
 
-// updated to support Scope.Scope
+// updated to support Scope.Scope and Requires
 export interface RpcMiddleware<Provides, E, Requires> {
   (options: {
     readonly clientId: number
@@ -47,7 +47,7 @@ export type DependsOn = {
   readonly dependsOn: NonEmptyReadonlyArray<AnyDynamic> | undefined
 }
 
-type RpcOptionsDynamic<Key extends string, A extends RPCContextMap.Any> = RpcOptionsOriginal & {
+interface RpcOptionsDynamic<Key extends string, A extends RPCContextMap.Any> extends RpcOptionsOriginal {
   readonly dynamic: RpcDynamic<Key, A>
   readonly dependsOn?: NonEmptyReadonlyArray<AnyDynamic> | undefined
 }
@@ -86,8 +86,8 @@ export interface RpcMiddlewareDynamicNormal<A, E, R, Config> {
 export interface TagClassAny extends Context.Tag<any, any> {
   readonly [TypeId]: TypeId
   readonly optional: boolean
-  readonly provides?: Context.Tag<any, any> | ContextRepr | undefined
-  readonly requires?: Context.Tag<any, any> | ContextRepr | undefined
+  readonly provides?: Context.Tag<any, any> | ContextTagArray | undefined
+  readonly requires?: Context.Tag<any, any> | ContextTagArray | undefined
   readonly failure: Schema.Schema.All
   readonly requiredForClient: boolean
   readonly wrap: boolean
@@ -105,9 +105,9 @@ export declare namespace TagClass {
     readonly optional?: false
   } ? Context.Tag.Identifier<Options["provides"]>
     : Options extends {
-      readonly provides: ContextRepr
+      readonly provides: ContextTagArray
       readonly optional?: false
-    } ? ContextRepr.Identifier<Options["provides"]>
+    } ? ContextTagArray.Identifier<Options["provides"]>
     : never
 
   /**
@@ -118,8 +118,8 @@ export declare namespace TagClass {
     readonly requires: Context.Tag<any, any>
   } ? Context.Tag.Identifier<Options["requires"]>
     : Options extends {
-      readonly requires: ContextRepr
-    } ? ContextRepr.Identifier<Options["requires"]>
+      readonly requires: ContextTagArray
+    } ? ContextTagArray.Identifier<Options["requires"]>
     : never
 
   /**
@@ -130,7 +130,8 @@ export declare namespace TagClass {
     ? Context.Tag.Service<Options["provides"]>
     : Options extends { readonly dynamic: RpcDynamic<any, infer A> }
       ? Options extends { wrap: true } ? void : AnyService.Bla<A["service"]>
-    : Options extends { readonly provides: ContextRepr } ? Context.Context<ContextRepr.Identifier<Options["provides"]>>
+    : Options extends { readonly provides: ContextTagArray }
+      ? Context.Context<ContextTagArray.Identifier<Options["provides"]>>
     : void
 
   /**
@@ -191,10 +192,10 @@ export declare namespace TagClass {
     readonly optional: Optional<Options>
     readonly failure: FailureSchema<Options>
     readonly provides: Options extends { readonly provides: Context.Tag<any, any> } ? Options["provides"]
-      : Options extends { readonly provides: ContextRepr } ? Options["provides"]
+      : Options extends { readonly provides: ContextTagArray } ? Options["provides"]
       : undefined
     readonly requires: Options extends { readonly requires: Context.Tag<any, any> } ? Options["requires"]
-      : Options extends { readonly requires: ContextRepr } ? Options["requires"]
+      : Options extends { readonly requires: ContextTagArray } ? Options["requires"]
       : undefined
     readonly dynamic: Options extends RpcOptionsDynamic<any, any> ? Options["dynamic"]
       : undefined

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

@@ -1,47 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { type ContextTagWithDefault } from "../../layerUtils.js"
-import { type RpcMiddlewareDynamicNormal, type RpcMiddlewareDynamicWrap } from "./RpcMiddleware.js"
-
-export type RpcMiddlewareDynamic<A, E, R, Config> = [A] extends [void] ? RpcMiddlewareDynamicWrap<E, R, Config>
-  : RpcMiddlewareDynamicNormal<A, E, R, Config>
-
-export type ContextWithLayer<
-  Config,
-  Service,
-  Error,
-  Dependencies,
-  Id,
-  LayerE,
-  LayerR
-> =
-  & (
-    | ContextTagWithDefault<
-      Id,
-      // todo
-      RpcMiddlewareDynamic<Service, Error, any, Config>,
-      LayerE,
-      LayerR
-    >
-    | ContextTagWithDefault<
-      Id,
-      // todo
-      RpcMiddlewareDynamic<Service, Error, never, Config>,
-      LayerE,
-      LayerR
-    >
-  )
-  & {
-    dependsOn?: Dependencies
-  }
-
-export namespace ContextWithLayer {
-  export type Base<Config, Service, Error> = ContextWithLayer<
-    Config,
-    Service,
-    Error,
-    any,
-    any,
-    any,
-    any
-  >
-}

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

@@ -2,36 +2,40 @@
 import { type Rpc, type RpcMiddleware } from "@effect/rpc"
 import { type SuccessValue } from "@effect/rpc/RpcMiddleware"
 import { type Array, Context, Effect, type Layer, type NonEmptyReadonlyArray, Option, type Scope } from "effect-app"
-import { type ContextRepr } from "effect-app/client"
+import { type ContextTagArray } from "effect-app/client"
 import { type HttpHeaders } from "effect-app/http"
 import { InfraLogger } from "../../../logger.js"
 import { type TagClassAny } from "./RpcMiddleware.js"
 
+// Effect rpc middleware does not support changing payload or headers, but we do..
+
+// it's like an Effect/rpc wrap middleware, but with fixed R to Scope.Scope
 export interface GenericMiddlewareOptions<E> {
-  // Effect rpc middleware does not support changing payload or headers, but we do..
-  readonly next: Effect.Effect<SuccessValue, E, Scope.Scope>
-  readonly payload: unknown
-  readonly headers: HttpHeaders.Headers
   readonly clientId: number
   readonly rpc: Rpc.AnyWithProps
+  readonly payload: unknown
+  readonly headers: HttpHeaders.Headers
+  readonly next: Effect.Effect<SuccessValue, E, Scope.Scope>
 }
 
 export type GenericMiddlewareMaker = TagClassAny & { Default: Layer.Layer.Any } // todo; and Layer..
 
 export namespace GenericMiddlewareMaker {
   export type ApplyServices<A extends TagClassAny, R> = Exclude<R, Provided<A>> | Required<A>
+
   export type ApplyManyServices<A extends NonEmptyReadonlyArray<TagClassAny>, R> =
     | Exclude<R, { [K in keyof A]: Provided<A[K]> }[number]>
     | { [K in keyof A]: Required<A[K]> }[number]
+
   export type Provided<T> = T extends TagClassAny
     ? T extends { provides: Context.Tag<any, any> } ? Context.Tag.Identifier<T["provides"]>
-    : T extends { provides: ContextRepr } ? ContextRepr.Identifier<T["provides"]>
+    : T extends { provides: ContextTagArray } ? ContextTagArray.Identifier<T["provides"]>
     : never
     : never
 
   export type Required<T> = T extends TagClassAny
     ? T extends { requires: Context.Tag<any, any> } ? Context.Tag.Identifier<T["requires"]>
-    : T extends { requires: ContextRepr } ? ContextRepr.Identifier<T["requires"]>
+    : T extends { requires: ContextTagArray } ? ContextTagArray.Identifier<T["requires"]>
     : never
     : never
 }
@@ -42,26 +46,41 @@ export const genericMiddlewareMaker = <
   dependencies: { [K in keyof T]: T[K]["Default"] }
   effect: Effect.Effect<RpcMiddleware.RpcMiddlewareWrap<any, any>>
 } => {
-  // we want to run them in reverse order
+  // we want to run them in reverse order because latter middlewares will provide context to former ones
   middlewares = middlewares.toReversed() as any
+
   return {
     dependencies: middlewares.map((_) => _.Default),
     effect: Effect.gen(function*() {
       const context = yield* Effect.context()
+
+      // returns a Effect/RpcMiddlewareWrap with Scope in requirements
       return <E>(
         options: GenericMiddlewareOptions<E>
       ) => {
+        // we start with the actual handler
         let handler = options.next
-        // copied from RpcMiddleare
+
+        // inspired from Effect/RpcMiddleware
         for (const tag of middlewares) {
           if (tag.wrap) {
+            // use the tag to get the middleware from context
             const middleware = Context.unsafeGet(context, tag)
+
+            // wrap the current handler, allowing the middleware to run before and after it
             handler = InfraLogger.logDebug("Applying middleware wrap " + tag.key).pipe(
               Effect.zipRight(middleware({ ...options, next: handler }))
             ) as any
           } else if (tag.optional) {
+            // use the tag to get the middleware from context
+            // if the middleware fails to run, we will ignore the error
             const middleware = Context.unsafeGet(context, tag) as RpcMiddleware.RpcMiddleware<any, any>
+
             const previous = handler
+
+            // set the previous handler to run after the middleware
+            // if the middleware is not present, we just return the previous handler
+            // otherwise the middleware will provide some context to be provided to the previous handler
             handler = InfraLogger.logDebug("Applying middleware optional " + tag.key).pipe(
               Effect.zipRight(Effect.matchEffect(middleware(options), {
                 onFailure: () => previous,
@@ -74,24 +93,35 @@ export const genericMiddlewareMaker = <
               }))
             )
           } else if (tag.dynamic) {
+            // use the tag to get the middleware from context
             const middleware = Context.unsafeGet(context, tag) as RpcMiddleware.RpcMiddleware<any, any>
+
             const previous = handler
+
+            // set the previous handler to run after the middleware
+            // we do expect the middleware to be present, but the context might not be available
+            // if it is, we provide it to the previous handler
             handler = InfraLogger.logDebug("Applying middleware dynamic " + tag.key, tag.dynamic).pipe(
               Effect.zipRight(
                 middleware(options).pipe(
-                  Effect.flatMap((value) =>
-                    Option.isSome(value)
-                      ? Context.isContext(value.value)
-                        ? Effect.provide(previous, value.value)
-                        : Effect.provideService(previous, tag.dynamic!.settings.service!, /* TODO */ value.value)
+                  Effect.flatMap((o) =>
+                    Option.isSome(o)
+                      ? Context.isContext(o.value)
+                        ? Effect.provide(previous, o.value)
+                        : Effect.provideService(previous, tag.dynamic!.settings.service!, /* TODO */ o.value)
                       : previous
                   )
                 )
               )
             )
           } else {
+            // use the tag to get the middleware from context
             const middleware = Context.unsafeGet(context, tag) as RpcMiddleware.RpcMiddleware<any, any>
+
             const previous = handler
+
+            // set the previous handler to run after the middleware
+            // we do expect both the middleware and the context to be present
             handler = InfraLogger.logDebug("Applying middleware " + tag.key).pipe(
               Effect.zipRight(
                 tag.provides !== undefined
@@ -107,6 +137,7 @@ export const genericMiddlewareMaker = <
             )
           }
         }
+
         return handler
       }
     })