@effect-app/infra 2.94.0 → 3.0.0

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

@@ -1,15 +1,56 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { type RpcMiddleware } from "@effect/rpc"
 import { Context, Effect, type Layer, type NonEmptyReadonlyArray, Option, type S, type Scope } from "effect-app"
-import { type ContextTagArray } from "effect-app/client"
+import { type ContextTagArray, type GetContextConfig, type RPCContextMap } from "effect-app/client"
+import { type Tag } from "effect/Context"
+import { type Simplify } from "effect/Types"
 import { InfraLogger } from "../../../logger.js"
+import { type MakeTags, type MiddlewareMakerId } from "./middleware-api.js"
 import { type RpcMiddlewareWrap, type TagClassAny } from "./RpcMiddleware.js"
 
 // Effect rpc middleware does not support changing payload or headers, but we do..
 
-export type MiddlewareMaker = TagClassAny & { Default: Layer.Layer.Any } // todo; and Layer..
+export interface MiddlewareMaker<
+  RequestContextMap extends Record<string, RPCContextMap.Any>,
+  MiddlewareProviders extends ReadonlyArray<MiddlewareMaker.Any>
+> extends
+  RpcMiddleware.TagClass<
+    MiddlewareMakerId,
+    "MiddlewareMaker",
+    Simplify<
+      & { readonly wrap: true }
+      & (Exclude<
+        MiddlewareMaker.ManyRequired<MiddlewareProviders>,
+        MiddlewareMaker.ManyProvided<MiddlewareProviders>
+      > extends never ? {} : {
+        readonly requires: MakeTags<
+          Exclude<
+            MiddlewareMaker.ManyRequired<MiddlewareProviders>,
+            MiddlewareMaker.ManyProvided<MiddlewareProviders>
+          >
+        >
+      })
+      & (MiddlewareMaker.ManyErrors<MiddlewareProviders> extends never ? {}
+        : {
+          readonly failure: S.Schema<MiddlewareMaker.ManyErrors<MiddlewareProviders>>
+        })
+      & (MiddlewareMaker.ManyProvided<MiddlewareProviders> extends never ? {}
+        : { readonly provides: MakeTags<MiddlewareMaker.ManyProvided<MiddlewareProviders>> })
+    >
+  >
+{
+  readonly layer: Layer.Layer<MiddlewareMakerId, never, Tag.Identifier<MiddlewareProviders[number]>>
+  readonly requestContext: RequestContextTag<RequestContextMap>
+  readonly requestContextMap: RequestContextMap
+}
+
+export interface RequestContextTag<RequestContextMap extends Record<string, RPCContextMap.Any>>
+  extends Context.Tag<"RequestContextConfig", GetContextConfig<RequestContextMap>>
+{}
 
 export namespace MiddlewareMaker {
+  export type Any = TagClassAny
+
   export type ApplyServices<A extends TagClassAny, R> = Exclude<R, Provided<A>> | Required<A>
 
   export type ApplyManyServices<A extends NonEmptyReadonlyArray<TagClassAny>, R> =
@@ -44,120 +85,114 @@ export namespace MiddlewareMaker {
 }
 
 export const middlewareMaker = <
-  MiddlewareProviders extends ReadonlyArray<MiddlewareMaker>
->(middlewares: MiddlewareProviders): {
-  dependencies: { [K in keyof MiddlewareProviders]: MiddlewareProviders[K]["Default"] }
-  effect: Effect.Effect<
-    RpcMiddlewareWrap<
-      MiddlewareMaker.ManyProvided<MiddlewareProviders>,
-      MiddlewareMaker.ManyErrors<MiddlewareProviders>,
-      Exclude<
-        MiddlewareMaker.ManyRequired<MiddlewareProviders>,
-        MiddlewareMaker.ManyProvided<MiddlewareProviders>
-      > extends never ? never
-        : Exclude<MiddlewareMaker.ManyRequired<MiddlewareProviders>, MiddlewareMaker.ManyProvided<MiddlewareProviders>>
-    >
+  MiddlewareProviders extends ReadonlyArray<MiddlewareMaker.Any>
+>(middlewares: MiddlewareProviders): Effect.Effect<
+  RpcMiddlewareWrap<
+    MiddlewareMaker.ManyProvided<MiddlewareProviders>,
+    MiddlewareMaker.ManyErrors<MiddlewareProviders>,
+    Exclude<
+      MiddlewareMaker.ManyRequired<MiddlewareProviders>,
+      MiddlewareMaker.ManyProvided<MiddlewareProviders>
+    > extends never ? never
+      : Exclude<MiddlewareMaker.ManyRequired<MiddlewareProviders>, MiddlewareMaker.ManyProvided<MiddlewareProviders>>
   >
-} => {
+> => {
   // 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 (
-        options: Parameters<
-          RpcMiddlewareWrap<
-            MiddlewareMaker.ManyProvided<MiddlewareProviders>,
-            never,
-            Scope.Scope
-          >
-        >[0]
-      ) => {
-        // we start with the actual handler
-        let handler = options.next
-
-        // 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,
-                onSuccess: tag.provides !== undefined
-                  ? (value) =>
+  return Effect.gen(function*() {
+    const context = yield* Effect.context()
+
+    // returns a Effect/RpcMiddlewareWrap with Scope in requirements
+    return (
+      options: Parameters<
+        RpcMiddlewareWrap<
+          MiddlewareMaker.ManyProvided<MiddlewareProviders>,
+          never,
+          Scope.Scope
+        >
+      >[0]
+    ) => {
+      // we start with the actual handler
+      let handler = options.next
+
+      // 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,
+              onSuccess: tag.provides !== undefined
+                ? (value) =>
+                  Context.isContext(value)
+                    ? Effect.provide(previous, value)
+                    : Effect.provideService(previous, tag.provides as any, value)
+                : (_) => previous
+            }))
+          )
+        } 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((o) =>
+                  Option.isSome(o)
+                    ? Context.isContext(o.value)
+                      ? Effect.provide(previous, o.value)
+                      : Effect.provideService(previous, tag.dynamic!.settings.service!, /* TODO */ o.value)
+                    : previous
+                )
+              )
+            )
+          ) as any
+        } 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
+                ? middleware(options).pipe(
+                  Effect.flatMap((value) =>
                     Context.isContext(value)
                       ? Effect.provide(previous, value)
                       : Effect.provideService(previous, tag.provides as any, value)
-                  : (_) => previous
-              }))
-            )
-          } 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((o) =>
-                    Option.isSome(o)
-                      ? Context.isContext(o.value)
-                        ? Effect.provide(previous, o.value)
-                        : Effect.provideService(previous, tag.dynamic!.settings.service!, /* TODO */ o.value)
-                      : previous
                   )
                 )
-              )
-            ) as any
-          } 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
-                  ? middleware(options).pipe(
-                    Effect.flatMap((value) =>
-                      Context.isContext(value)
-                        ? Effect.provide(previous, value)
-                        : Effect.provideService(previous, tag.provides as any, value)
-                    )
-                  )
-                  : Effect.zipRight(middleware(options), previous)
-              )
-            ) as any
-          }
+                : Effect.zipRight(middleware(options), previous)
+            )
+          ) as any
         }
-        return handler
       }
-    })
-  } as any
+      return handler
+    }
+  }) as any
 }

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

@@ -1,10 +1,15 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
+import { Rpc, type RpcGroup, type RpcMiddleware, type RpcSchema } from "@effect/rpc"
 import { type AnyWithProps } from "@effect/rpc/Rpc"
-import { Context, type Effect, type NonEmptyArray, type NonEmptyReadonlyArray, S } from "effect-app"
-import { type GetContextConfig, type RPCContextMap } from "effect-app/client"
+import { type HandlersFrom } from "@effect/rpc/RpcGroup"
+import { Tag } from "@effect/rpc/RpcMiddleware"
+import { Context, type Effect, Layer, type NonEmptyArray, type NonEmptyReadonlyArray, S, type Schema, type Scope, type Stream } from "effect-app"
+import { type GetContextConfig, type GetEffectContext, type RPCContextMap } from "effect-app/client"
+import { typedValuesOf } from "effect-app/utils"
+import { type ReadonlyMailbox } from "effect/Mailbox"
 import { type TypeTestId } from "../../routing.js"
-import { type MiddlewareMaker, middlewareMaker } from "./generic-middleware.js"
-import { type AnyDynamic, type RpcDynamic, Tag, type TagClassAny } from "./RpcMiddleware.js"
+import { type MiddlewareMaker, middlewareMaker, type RequestContextTag } from "./generic-middleware.js"
+import { type AnyDynamic, type RpcDynamic, type TagClassAny } from "./RpcMiddleware.js"
 
 /** Adapter used when setting the dynamic prop on a middleware implementation */
 export const contextMap = <
@@ -15,26 +20,27 @@ export const contextMap = <
   settings: { service: rcm[key]!["service"] } as RequestContextMap[Key]
 })
 
+const tag = Context.GenericTag("RequestContextConfig")
 /** Retrieves RequestContextConfig out of the RPC annotations */
 export const getConfig = <
   RequestContextMap extends Record<string, RPCContextMap.Any>
 >() =>
 (rpc: AnyWithProps): GetContextConfig<RequestContextMap> => {
-  return Context.unsafeGet(rpc.annotations, Context.GenericTag("RequestContextConfig"))
+  return Context.getOrElse(rpc.annotations, tag as any, () => ({}))
 }
 
 // the following implements sort of builder pattern
 // we support both sideways and upwards elimination of dependencies
 
 // it's for dynamic middlewares
-type GetDependsOnKeys<MW extends MiddlewareMaker> = MW extends { dependsOn: NonEmptyReadonlyArray<TagClassAny> } ? {
+type GetDependsOnKeys<MW extends MiddlewareMaker.Any> = MW extends { dependsOn: NonEmptyReadonlyArray<TagClassAny> } ? {
     [K in keyof MW["dependsOn"]]: MW["dependsOn"][K] extends AnyDynamic ? MW["dependsOn"][K]["dynamic"]["key"]
       : never
   }[keyof MW["dependsOn"]]
   : never
 
 type FilterInDynamicMiddlewares<
-  MWs extends ReadonlyArray<MiddlewareMaker>,
+  MWs extends ReadonlyArray<MiddlewareMaker.Any>,
   RequestContextMap extends Record<string, RPCContextMap.Any>
 > = {
   [K in keyof MWs]: MWs[K] extends { dynamic: RpcDynamic<any, RequestContextMap[keyof RequestContextMap]> } ? MWs[K]
@@ -46,13 +52,13 @@ type RecursiveHandleMWsSideways<
   R extends {
     rcm: Record<string, RPCContextMap.Any>
     provided: keyof R["rcm"] // that's fine
-    middlewares: ReadonlyArray<MiddlewareMaker>
+    middlewares: ReadonlyArray<MiddlewareMaker.Any>
     dmp: any
     middlewareR: any
   }
 > = MWs extends [
-  infer F extends MiddlewareMaker,
-  ...infer Rest extends ReadonlyArray<MiddlewareMaker>
+  infer F extends MiddlewareMaker.Any,
+  ...infer Rest extends ReadonlyArray<MiddlewareMaker.Any>
 ] ? RecursiveHandleMWsSideways<Rest, {
     rcm: R["rcm"]
     // when one dynamic middleware depends on another, subtract the key to enforce the dependency to be provided after
@@ -76,11 +82,36 @@ type RecursiveHandleMWsSideways<
 export interface BuildingMiddleware<
   RequestContextMap extends Record<string, RPCContextMap.Any>,
   Provided extends keyof RequestContextMap,
-  Middlewares extends ReadonlyArray<MiddlewareMaker>,
+  Middlewares extends ReadonlyArray<MiddlewareMaker.Any>,
   DynamicMiddlewareProviders,
   out MiddlewareR extends { _tag: string } = never
 > {
-  middleware<MWs extends NonEmptyArray<MiddlewareMaker>>(
+  rpc: <
+    const Tag extends string,
+    Payload extends Schema.Schema.Any | Schema.Struct.Fields = typeof Schema.Void,
+    Success extends Schema.Schema.Any = typeof Schema.Void,
+    Error extends Schema.Schema.All = typeof Schema.Never,
+    const Stream extends boolean = false,
+    Config extends GetContextConfig<RequestContextMap> = {}
+  >(tag: Tag, options?: {
+    readonly payload?: Payload
+    readonly success?: Success
+    readonly error?: Error
+    readonly stream?: Stream
+    readonly config?: Config
+    readonly primaryKey?: [Payload] extends [Schema.Struct.Fields]
+      ? ((payload: Schema.Simplify<Schema.Struct.Type<NoInfer<Payload>>>) => string)
+      : never
+  }) =>
+    & Rpc.Rpc<
+      Tag,
+      Payload extends Schema.Struct.Fields ? Schema.Struct<Payload> : Payload,
+      Stream extends true ? RpcSchema.Stream<Success, Error> : Success,
+      Stream extends true ? typeof Schema.Never : Error
+    >
+    & { readonly config: Config }
+
+  middleware<MWs extends NonEmptyArray<MiddlewareMaker.Any>>(
     ...mw: MWs
   ): RecursiveHandleMWsSideways<MWs, {
     rcm: RequestContextMap
@@ -91,7 +122,7 @@ export interface BuildingMiddleware<
   }> extends infer Res extends {
     rcm: RequestContextMap
     provided: keyof RequestContextMap
-    middlewares: ReadonlyArray<MiddlewareMaker>
+    middlewares: ReadonlyArray<MiddlewareMaker.Any>
     dmp: any
     middlewareR: any
   } ? MiddlewaresBuilder<
@@ -113,7 +144,7 @@ export interface BuildingMiddleware<
 export type MiddlewaresBuilder<
   RequestContextMap extends Record<string, RPCContextMap.Any>,
   Provided extends keyof RequestContextMap = never,
-  Middlewares extends ReadonlyArray<MiddlewareMaker> = [],
+  Middlewares extends ReadonlyArray<MiddlewareMaker.Any> = [],
   DynamicMiddlewareProviders = unknown,
   MiddlewareR extends { _tag: string } = never
 > =
@@ -126,50 +157,20 @@ export type MiddlewaresBuilder<
   >
   & //  keyof Omit<RequestContextMap, Provided> extends never is true when all the dynamic middlewares are provided
   // MiddlewareR is never when all the required services from generic & dynamic middlewares are provided
-  (keyof Omit<RequestContextMap, Provided> extends never ? [MiddlewareR] extends [never] ? ReturnType<
-        typeof makeMiddlewareBasic<
-          RequestContextMap,
-          Middlewares
-        >
+  (keyof Omit<RequestContextMap, Provided> extends never ? [MiddlewareR] extends [never] ? MiddlewareMaker<
+        RequestContextMap,
+        Middlewares
       >
     : {}
     : {})
 
-export const makeMiddleware: <
-  RequestContextMap extends Record<string, RPCContextMap.Any>
->(rcm: RequestContextMap) => MiddlewaresBuilder<RequestContextMap> = (rcm) => {
-  let allMiddleware: MiddlewareMaker[] = []
-  const it = {
-    middleware: (...middlewares: any[]) => {
-      for (const mw of middlewares) {
-        // recall that we run middlewares in reverse order
-        allMiddleware = [mw, ...allMiddleware]
-      }
-      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<any, any>(rcm, ...allMiddleware), it)
-    }
-  }
-  return it as any
-}
-
-//
-export interface MiddlewareMakerId {
-  readonly _id: unique symbol
-}
-
-// TODO: actually end up with [Tag<A, A>, Tag<B, B>, ...]
-type MakeTags<A> = Context.Tag<A, A>
-
 const makeMiddlewareBasic =
   // by setting RequestContextMap beforehand, execute contextual typing does not fuck up itself to anys
   <
     RequestContextMap extends Record<string, RPCContextMap.Any>,
-    MiddlewareProviders extends ReadonlyArray<MiddlewareMaker>
+    MiddlewareProviders extends ReadonlyArray<MiddlewareMaker.Any>
   >(
-    _rcm: RequestContextMap,
+    rcm: RequestContextMap,
     ...make: MiddlewareProviders
   ) => {
     // reverse middlewares and wrap one after the other
@@ -201,26 +202,203 @@ const makeMiddlewareBasic =
         ],
       provides: (provides.length > 0
         ? provides
-        : undefined) as unknown as MiddlewareMaker.ManyProvided<MiddlewareProviders> extends never ? never : [
-          MakeTags<MiddlewareMaker.ManyProvided<MiddlewareProviders>>
-        ],
+        : undefined) as unknown as MiddlewareMaker.ManyProvided<MiddlewareProviders> extends never ? never
+          : MakeTags<MiddlewareMaker.ManyProvided<MiddlewareProviders>>,
       wrap: true
-    })(
-      middleware as {
-        dependencies: typeof middleware["dependencies"]
-        effect: Effect<
+    })
+
+    const layer = Layer
+      .scoped(
+        MiddlewareMaker,
+        middleware as Effect<
           any, // TODO: why ?
-          Effect.Error<typeof middleware["effect"]>,
-          Effect.Context<typeof middleware["effect"]>
+          Effect.Error<typeof middleware>,
+          Effect.Context<typeof middleware>
         >
-      }
-    )
+      )
 
     // add to the tag a default implementation
     return Object.assign(MiddlewareMaker, {
+      layer,
       // tag to be used to retrieve the RequestContextConfig from RPC annotations
       requestContext: Context.GenericTag<"RequestContextConfig", GetContextConfig<RequestContextMap>>(
         "RequestContextConfig"
-      )
+      ),
+      requestContextMap: rcm
     })
   }
+
+export const makeMiddleware = <
+  RequestContextMap extends Record<string, RPCContextMap.Any>
+>(rcm: RequestContextMap): MiddlewaresBuilder<RequestContextMap> => {
+  let allMiddleware: MiddlewareMaker.Any[] = []
+  const requestContext = Context.GenericTag<"RequestContextConfig", GetContextConfig<RequestContextMap>>(
+    "RequestContextConfig"
+  )
+  const it = {
+    // rpc with config
+    rpc: <
+      const Tag extends string,
+      Payload extends Schema.Schema.Any | Schema.Struct.Fields = typeof Schema.Void,
+      Success extends Schema.Schema.Any = typeof Schema.Void,
+      Error extends Schema.Schema.All = typeof Schema.Never,
+      const Stream extends boolean = false,
+      Config extends GetContextConfig<RequestContextMap> = {}
+    >(tag: Tag, options?: {
+      readonly payload?: Payload
+      readonly success?: Success
+      readonly error?: Error
+      readonly stream?: Stream
+      readonly config?: Config
+      readonly primaryKey?: [Payload] extends [Schema.Struct.Fields]
+        ? ((payload: Schema.Simplify<Schema.Struct.Type<NoInfer<Payload>>>) => string)
+        : never
+    }):
+      & Rpc.Rpc<
+        Tag,
+        Payload extends Schema.Struct.Fields ? Schema.Struct<Payload> : Payload,
+        // TODO: enhance `Error`. type based on middleware config.
+        Stream extends true ? RpcSchema.Stream<Success, Error> : Success,
+        Stream extends true ? typeof Schema.Never : Error
+      >
+      & { config: Config } =>
+    {
+      const config = options?.config ?? {} as Config
+
+      // based on the config, we must enhance (union) or set failures.
+      // TODO: we should only include errors that are relevant based on the middleware config.ks
+      const error = options?.error
+      const errors = typedValuesOf(rcm).map((_) => _.error).filter((_) => _ && _ !== S.Never) // TODO: only the errors relevant based on config
+      const newError = error ? S.Union(error, ...errors) : S.Union(...errors)
+
+      const rpc = Rpc.make(tag, { ...options, error: newError }) as any
+
+      return Object.assign(rpc.annotate(requestContext, config), { config })
+    },
+    middleware: (...middlewares: any[]) => {
+      for (const mw of middlewares) {
+        // recall that we run middlewares in reverse order
+        allMiddleware = [mw, ...allMiddleware]
+      }
+      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<any, any>(rcm, ...allMiddleware), it)
+    }
+  }
+  return it as any
+}
+
+// customised version of Rpc.AddMiddleware, so that we don't loose the `config`...
+// not needed if there's official support in Rpc.Rpc.
+export type AddMiddleware<R extends Rpc.Any, Middleware extends RpcMiddleware.TagClassAny> = R extends Rpc.Rpc<
+  infer _Tag,
+  infer _Payload,
+  infer _Success,
+  infer _Error,
+  infer _Middleware
+> ?
+    & Rpc.Rpc<
+      _Tag,
+      _Payload,
+      _Success,
+      _Error,
+      _Middleware | Middleware
+    >
+    & { readonly config: R extends { readonly config: infer _C } ? _C : never }
+  : never
+
+// alternatively consider group.serverMiddleware? hmmm
+export const middlewareGroup = <
+  RequestContextMap extends Record<string, RPCContextMap.Any>,
+  Middleware extends Context.Tag<MiddlewareMakerId, any> & RpcMiddleware.TagClassAny & {
+    readonly requestContext: RequestContextTag<RequestContextMap>
+    readonly requestContextMap: RequestContextMap
+  }
+>(
+  middleware: Middleware
+) =>
+<R extends Rpc.Any>(group: RpcGroup.RpcGroup<R>) => {
+  type RN = AddMiddleware<R, typeof middleware>
+  const middlewaredGroup = group.middleware(middleware) as unknown as RpcGroup.RpcGroup<RN>
+  const toLayerOriginal = middlewaredGroup.toLayer.bind(middlewaredGroup)
+  return Object.assign(middlewaredGroup, {
+    toLayerDynamic: <
+      Handlers extends HandlersFrom<RN>,
+      EX = never,
+      RX = never
+    >(
+      build:
+        | Handlers
+        | Effect.Effect<Handlers, EX, RX>
+    ): Layer.Layer<
+      Rpc.ToHandler<RN>,
+      EX,
+      | Exclude<RX, Scope>
+      | HandlersContext<RN, Handlers>
+    > => {
+      return toLayerOriginal(build as any) as any // ??
+    }
+  })
+}
+
+// customized versions to handle dynamically eliminated context.
+export type HandlersContext<Rpcs extends Rpc.Any, Handlers> = keyof Handlers extends infer K
+  ? K extends keyof Handlers & string ? HandlerContext<Rpcs, K, Handlers[K]> : never
+  : never
+
+export type HandlerContext<Rpcs extends Rpc.Any, K extends Rpcs["_tag"], Handler> = [Rpc.IsStream<Rpcs, K>] extends
+  [true] ? Handler extends (...args: any) =>
+    | Stream.Stream<infer _A, infer _E, infer _R>
+    | Rpc.Fork<Stream.Stream<infer _A, infer _E, infer _R>>
+    | Effect.Effect<
+      ReadonlyMailbox<infer _A, infer _E>,
+      infer _EX,
+      infer _R
+    >
+    | Rpc.Fork<
+      Effect.Effect<
+        ReadonlyMailbox<infer _A, infer _E>,
+        infer _EX,
+        infer _R
+      >
+    > ? Exclude<ExcludeProvides<_R, Rpcs, K>, Scope>
+  : never
+  : Handler extends (
+    ...args: any
+  ) => Effect.Effect<infer _A, infer _E, infer _R> | Rpc.Fork<Effect.Effect<infer _A, infer _E, infer _R>>
+    ? ExcludeProvides<_R, Rpcs, K>
+  : never
+
+// new
+export type ExtractDynamicallyProvides<R extends Rpc.Any, Tag extends string> = R extends
+  Rpc.Rpc<Tag, infer _Payload, infer _Success, infer _Error, infer _Middleware> ? _Middleware extends {
+    readonly requestContextMap: infer _RC
+  } ? _RC extends Record<string, RPCContextMap.Any> // ? GetEffectContext<_RC, { allowAnonymous: false }>
+      ? R extends { readonly config: infer _C } ? GetEffectContext<_RC, _C>
+      : GetEffectContext<_RC, {}>
+    : never
+  : never
+  : never
+
+export type ExtractProvides<R extends Rpc.Any, Tag extends string> = R extends
+  Rpc.Rpc<Tag, infer _Payload, infer _Success, infer _Error, infer _Middleware> ? _Middleware extends {
+    readonly provides: Context.Tag<infer _I, infer _S>
+  } ? _I
+  : never
+  : never
+
+export type ExcludeProvides<Env, R extends Rpc.Any, Tag extends string> = Exclude<
+  Env,
+  // customisation is down here.
+  ExtractProvides<R, Tag> | ExtractDynamicallyProvides<R, Tag>
+>
+
+//
+export interface MiddlewareMakerId {
+  readonly _id: unique symbol
+}
+
+// TODO: actually end up with [Tag<A, A>, Tag<B, B>, ...] once `provides: []` is implemented
+export type MakeTags<A> = Context.Tag<A, A>