@effect-app/infra 2.86.0 → 2.87.1

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

@@ -0,0 +1,287 @@
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-unsafe-return */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+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 HttpHeaders } from "effect-app/http"
+import { type TagUnify, type TagUnifyIgnore } from "effect/Context"
+import { type LayerUtils } from "../../layerUtils.js"
+
+// updated to support Scope.Scope
+export interface RpcMiddleware<Provides, E, Requires> {
+  (options: {
+    readonly clientId: number
+    readonly rpc: Rpc.AnyWithProps
+    readonly payload: unknown
+    readonly headers: HttpHeaders.Headers
+  }): Effect.Effect<Provides, E, Scope.Scope | Requires>
+}
+export interface RpcMiddlewareWrap<Provides, E, Requires> {
+  (options: {
+    readonly clientId: number
+    readonly rpc: Rpc.AnyWithProps
+    readonly payload: unknown
+    readonly headers: HttpHeaders.Headers
+    readonly next: Effect.Effect<SuccessValue, E, Provides | Scope.Scope | Requires>
+  }): Effect.Effect<SuccessValue, E, Scope.Scope | Requires>
+}
+
+type RpcOptionsOriginal = {
+  readonly wrap?: boolean
+  readonly optional?: boolean
+  readonly failure?: Schema.Schema.All
+  readonly provides?: AnyService
+  readonly requiredForClient?: boolean
+}
+
+export type RpcDynamic<Key extends string, A extends RPCContextMap.Any> = {
+  key: Key
+  settings: A
+}
+
+export type AnyDynamic = { dynamic: RpcDynamic<any, any> }
+
+export type DependsOn = {
+  readonly dependsOn: NonEmptyReadonlyArray<AnyDynamic> | undefined
+}
+
+type RpcOptionsDynamic<Key extends string, A extends RPCContextMap.Any> = RpcOptionsOriginal & {
+  readonly dynamic: RpcDynamic<Key, A>
+  readonly dependsOn?: NonEmptyReadonlyArray<AnyDynamic> | undefined
+}
+
+export type Dynamic<Options> = Options extends RpcOptionsDynamic<any, any> ? true : false
+
+export interface RpcMiddlewareDynamicWrap<E, R, Config> {
+  (options: {
+    readonly next: Effect.Effect<SuccessValue, E, Scope.Scope | R>
+    readonly config: Config // todo
+    readonly clientId: number
+    readonly rpc: Rpc.AnyWithProps
+    readonly payload: unknown
+    readonly headers: HttpHeaders.Headers
+  }): Effect.Effect<
+    SuccessValue,
+    E,
+    Scope.Scope | R
+  >
+}
+
+export interface RpcMiddlewareDynamicNormal<A, E, R, Config> {
+  (options: {
+    readonly config: Config // todo
+    readonly clientId: number
+    readonly rpc: Rpc.AnyWithProps
+    readonly payload: unknown
+    readonly headers: HttpHeaders.Headers
+  }): Effect.Effect<
+    Option.Option<A>,
+    E,
+    Scope.Scope | R
+  >
+}
+
+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 failure: Schema.Schema.All
+  readonly requiredForClient: boolean
+  readonly wrap: boolean
+  readonly dynamic?: RpcDynamic<any, any> | undefined
+  readonly dependsOn?: NonEmptyReadonlyArray<AnyDynamic> | undefined
+}
+
+export declare namespace TagClass {
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export type Provides<Options> = Options extends {
+    readonly provides: Context.Tag<any, any>
+    readonly optional?: false
+  } ? Context.Tag.Identifier<Options["provides"]>
+    : Options extends {
+      readonly provides: ContextRepr
+      readonly optional?: false
+    } ? ContextRepr.Identifier<Options["provides"]>
+    : never
+
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export type Requires<Options> = Options extends {
+    readonly requires: Context.Tag<any, any>
+  } ? Context.Tag.Identifier<Options["requires"]>
+    : Options extends {
+      readonly requires: ContextRepr
+    } ? ContextRepr.Identifier<Options["requires"]>
+    : never
+
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export type Service<Options> = Options extends { readonly provides: Context.Tag<any, any> }
+    ? 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"]>>
+    : void
+
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export type FailureSchema<Options> = Options extends
+    { readonly failure: Schema.Schema.All; readonly optional?: false } ? Options["failure"]
+    : Options extends { readonly dynamic: RpcDynamic<any, infer A> } ? A["error"]
+    : typeof Schema.Never
+
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export type Failure<Options> = Options extends
+    { readonly failure: Schema.Schema<infer _A, infer _I, infer _R>; readonly optional?: false } ? _A
+    : Options extends { readonly dynamic: RpcDynamic<any, infer A> } ? S.Schema.Type<A["error"]>
+    : never
+
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export type FailureContext<Options> = Schema.Schema.Context<FailureSchema<Options>>
+
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export type FailureService<Options> = Optional<Options> extends true ? unknown : Failure<Options>
+
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export type Optional<Options> = Options extends { readonly optional: true } ? true : false
+
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export type RequiredForClient<Options> = Options extends { readonly requiredForClient: true } ? true : false
+
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export type Wrap<Options> = Options extends { readonly wrap: true } ? true : false
+
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export interface Base<Self, Name extends string, Options, Service> extends Context.Tag<Self, Service> {
+    new(_: never): Context.TagClassShape<Name, Service>
+    readonly [TypeId]: TypeId
+    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"]
+      : undefined
+    readonly requires: Options extends { readonly requires: Context.Tag<any, any> } ? Options["requires"]
+      : Options extends { readonly requires: ContextRepr } ? Options["requires"]
+      : undefined
+    readonly dynamic: Options extends RpcOptionsDynamic<any, any> ? Options["dynamic"]
+      : undefined
+    readonly dependsOn: Options extends DependsOn ? Options["dependsOn"] : undefined
+    readonly requiredForClient: RequiredForClient<Options>
+    readonly wrap: Wrap<Options>
+  }
+}
+
+export interface TagClass<
+  Self,
+  Name extends string,
+  Options
+> extends
+  TagClass.Base<
+    Self,
+    Name,
+    Options,
+    Options extends RpcOptionsDynamic<any, any> ? TagClass.Wrap<Options> extends true ? RpcMiddlewareDynamicWrap<
+          TagClass.FailureService<Options>,
+          TagClass.Requires<Options>,
+          { [K in Options["dynamic"]["key"]]?: Options["dynamic"]["settings"]["contextActivation"] }
+        >
+      : RpcMiddlewareDynamicNormal<
+        TagClass.Service<Options>,
+        TagClass.FailureService<Options>,
+        TagClass.Requires<Options>,
+        { [K in Options["dynamic"]["key"]]?: Options["dynamic"]["settings"]["contextActivation"] }
+      >
+      : TagClass.Wrap<Options> extends true ? RpcMiddlewareWrap<
+          TagClass.Provides<Options>,
+          TagClass.Requires<Options>,
+          TagClass.Failure<Options>
+        >
+      : RpcMiddleware<
+        TagClass.Service<Options>,
+        TagClass.FailureService<Options>,
+        TagClass.Requires<Options>
+      >
+  >
+{}
+
+export const Tag = <Self>() =>
+<
+  const Name extends string,
+  const Options extends RpcOptionsOriginal | RpcOptionsDynamic<any, any>
+>(
+  id: Name,
+  options?: Options | undefined
+) =>
+<E, R, L extends NonEmptyReadonlyArray<Layer.Layer.Any>>(opts: {
+  effect: Effect.Effect<
+    Options extends RpcOptionsDynamic<any, any> ? TagClass.Wrap<Options> extends true ? RpcMiddlewareDynamicWrap<
+          TagClass.FailureService<Options>,
+          TagClass.Requires<Options>,
+          { [K in Options["dynamic"]["key"]]?: Options["dynamic"]["settings"]["contextActivation"] }
+        >
+      : RpcMiddlewareDynamicNormal<
+        TagClass.Service<Options>,
+        TagClass.FailureService<Options>,
+        TagClass.Requires<Options>,
+        { [K in Options["dynamic"]["key"]]?: Options["dynamic"]["settings"]["contextActivation"] }
+      >
+      : TagClass.Wrap<Options> extends true ? RpcMiddlewareWrap<
+          TagClass.Provides<Options>,
+          TagClass.Failure<Options>,
+          TagClass.Requires<Options>
+        >
+      : RpcMiddleware<
+        TagClass.Service<Options>,
+        TagClass.FailureService<Options>,
+        TagClass.Requires<Options>
+      >,
+    E,
+    R
+  >
+  dependencies?: L
+}): TagClass<Self, Name, Options> & {
+  Default: Layer.Layer<Self, E | LayerUtils.GetLayersError<L>, Exclude<R, LayerUtils.GetLayersSuccess<L>>>
+} =>
+  class extends RpcMiddleware.Tag<Self>()(id, options as any) {
+    static readonly dynamic = options && "dynamic" in options ? options.dynamic : undefined
+    static readonly dependsOn = options && "dependsOn" in options ? options.dependsOn : undefined
+    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

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

@@ -1,12 +1,9 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { Array, type Context, Effect, type S } from "effect-app"
-import { type GetEffectContext, type RPCContextMap } from "effect-app/client"
-import { type Tag } from "effect-app/Context"
-import { type HttpHeaders } from "effect-app/http"
-import { typedValuesOf } from "effect-app/utils"
-import { type ContextTagWithDefault, mergeOptionContexts } from "../../layerUtils.js"
-import { sort } from "../tsort.js"
-import { type RpcMiddlewareDynamic } from "./DynamicMiddleware.js"
+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,
@@ -48,47 +45,3 @@ export namespace ContextWithLayer {
     any
   >
 }
-
-// Effect Rpc Middleware: no substitute atm. though maybe something could be achieved with Wrap, we just don't have type safety on the Request input etc.
-export const implementMiddleware = <T extends Record<string, RPCContextMap.Any>>() =>
-<
-  TI extends {
-    [K in keyof T]: ContextWithLayer.Base<
-      { [K in keyof T]?: T[K]["contextActivation"] },
-      T[K]["service"],
-      S.Schema.Type<T[K]["error"]>
-    >
-  }
->(implementations: TI) => ({
-  dependencies: typedValuesOf(implementations).map((_) => _.Default) as {
-    [K in keyof TI]: TI[K]["Default"]
-  }[keyof TI][],
-  effect: Effect.gen(function*() {
-    const sorted = sort(typedValuesOf(implementations))
-
-    const makers = yield* Effect.all(sorted)
-    return Effect.fnUntraced(
-      function*(options: { config: { [K in keyof T]?: T[K]["contextActivation"] }; headers: HttpHeaders.Headers }) {
-        const ctx = yield* mergeOptionContexts(
-          Array.map(
-            makers,
-            (_, i) => ({ maker: sorted[i], handle: (_ as any)(options) as any }) as any
-          )
-        )
-        return ctx as Context.Context<
-          GetEffectContext<T, typeof options["config"]>
-        >
-      }
-    )
-  }) as unknown as Effect<
-    (
-      options: { config: { [K in keyof T]?: T[K]["contextActivation"] }; headers: HttpHeaders.Headers }
-    ) => Effect.Effect<
-      Context.Context<GetEffectContext<T, typeof options["config"]>>,
-      Effect.Error<ReturnType<Tag.Service<TI[keyof TI]>>>,
-      Effect.Context<ReturnType<Tag.Service<TI[keyof TI]>>>
-    >,
-    never,
-    Tag.Identifier<{ [K in keyof TI]: TI[K] }[keyof TI]>
-  >
-})

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

@@ -1,28 +1,11 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { type Rpc, type RpcMiddleware } from "@effect/rpc"
-import { type SuccessValue, type TypeId } from "@effect/rpc/RpcMiddleware"
-import { type Array, Context, Effect, type Layer, type NonEmptyReadonlyArray, type Schema, type Scope } from "effect-app"
-import { type RPCContextMap } from "effect-app/client"
+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 HttpHeaders } from "effect-app/http"
-import { type Tag } from "effect/Context"
 import { InfraLogger } from "../../../logger.js"
-import { type TagClassDynamicAny } from "./DynamicMiddleware.js"
-
-export type ContextRepr = NonEmptyReadonlyArray<Context.Tag<any, any>>
-export namespace ContextRepr {
-  export type Identifier<A> = A extends ContextRepr ? Tag.Identifier<A[number]> : never
-  export type Service<A> = A extends ContextRepr ? Tag.Service<A[number]> : never
-}
-
-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 failure: Schema.Schema.All
-  readonly requiredForClient: boolean
-  readonly wrap: boolean
-}
+import { type TagClassAny } from "./RpcMiddleware.js"
 
 export interface GenericMiddlewareOptions<E> {
   // Effect rpc middleware does not support changing payload or headers, but we do..
@@ -34,9 +17,6 @@ export interface GenericMiddlewareOptions<E> {
 }
 
 export type GenericMiddlewareMaker = TagClassAny & { Default: Layer.Layer.Any } // todo; and Layer..
-export type DynamicMiddlewareMaker<RequestContext extends Record<string, RPCContextMap.Any>> =
-  & TagClassDynamicAny<RequestContext>
-  & { Default: Layer.Layer.Any } // todo; and Layer..
 
 export namespace GenericMiddlewareMaker {
   export type ApplyServices<A extends TagClassAny, R> = Exclude<R, Provided<A>> | Required<A>
@@ -56,8 +36,6 @@ export namespace GenericMiddlewareMaker {
     : never
 }
 
-export const genericMiddleware = (i: GenericMiddlewareMaker) => i
-
 export const genericMiddlewareMaker = <
   T extends Array<GenericMiddlewareMaker>
 >(...middlewares: T): {
@@ -70,11 +48,6 @@ export const genericMiddlewareMaker = <
     dependencies: middlewares.map((_) => _.Default),
     effect: Effect.gen(function*() {
       const context = yield* Effect.context()
-      // const middlewares: readonly (RpcMiddlewareWrap<any, any> | RpcMiddleware.RpcMiddleware<any, any>)[] =
-      //   (yield* Effect.all(
-      //     middlewares
-      //   )) as any
-
       return <E>(
         options: GenericMiddlewareOptions<E>
       ) => {
@@ -83,13 +56,13 @@ export const genericMiddlewareMaker = <
         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 }))
+            handler = InfraLogger.logDebug("Applying middleware wrap " + tag.key).pipe(
+              Effect.zipRight(middleware({ ...options, next: handler }))
             ) 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(
+            handler = InfraLogger.logDebug("Applying middleware optional " + tag.key).pipe(
               Effect.zipRight(Effect.matchEffect(middleware(options), {
                 onFailure: () => previous,
                 onSuccess: tag.provides !== undefined
@@ -100,6 +73,22 @@ export const genericMiddlewareMaker = <
                   : (_) => previous
               }))
             )
+          } else if (tag.dynamic) {
+            const middleware = Context.unsafeGet(context, tag) as RpcMiddleware.RpcMiddleware<any, any>
+            const 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)
+                      : previous
+                  )
+                )
+              )
+            )
           } else {
             const middleware = Context.unsafeGet(context, tag) as RpcMiddleware.RpcMiddleware<any, any>
             const previous = handler

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

@@ -1,13 +1,19 @@
-import { Array, Either, type NonEmptyArray } from "effect-app"
+import { Rpc } from "@effect/rpc"
+import { Context, Effect, Layer, type NonEmptyArray, type NonEmptyReadonlyArray } from "effect-app"
 import { type RPCContextMap } from "effect-app/client"
-import { type DynamicMiddlewareMaker, type GenericMiddlewareMaker, makeMiddleware, type makeMiddlewareBasic, type RequestContextMapProvider } from "../../routing.js"
+import { type LayerUtils } from "../../layerUtils.js"
+import { type GenericMiddlewareMaker, genericMiddlewareMaker } from "./generic-middleware.js"
+import { makeRpcEffect, type MiddlewareMakerId, type RPCHandlerFactory } from "./RouterMiddleware.js"
+import { type AnyDynamic, type RpcDynamic, type TagClassAny } from "./RpcMiddleware.js"
 
-// TODO: ContextMap should be physical Tag (so typeof Tag), so that we can retrieve Identifier and Service separately.
-// in Service classes and TagId, the Id and Service are the same, but don't have to be in classic Tag or GenericTag.
-export const contextMap = <RequestContextMap>() => <K extends keyof RequestContextMap>(a: K) => ({
-  key: a,
-  settings: null as any as RequestContextMap[typeof a]
-})
+// 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 =
+  <RequestContextMap extends Record<string, RPCContextMap.Any>>() =>
+  <K extends keyof RequestContextMap>(a: K, service: RequestContextMap[K]["service"]) => ({
+    key: a,
+    settings: { service } as any as RequestContextMap[typeof a]
+  })
 
 export interface MiddlewareM<
   RequestContext extends Record<string, RPCContextMap.Any>,
@@ -28,6 +34,13 @@ export interface MiddlewareM<
   >
 }
 
+type GetDependsOnKeys<MW extends GenericMiddlewareMaker> = 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
+
 export interface MiddlewareDynamic<
   RequestContext extends Record<string, RPCContextMap.Any>,
   Provided extends keyof RequestContext,
@@ -35,14 +48,17 @@ export interface MiddlewareDynamic<
   DynamicMiddlewareProviders,
   out MiddlewareR
 > {
-  // TODO: this still allows to mix both types of middleware but with bad typing result
-  // either have to block it, or implement the support properly.
-  middleware<MW extends NonEmptyArray<DynamicMiddlewareMaker<RequestContext>> | NonEmptyArray<GenericMiddlewareMaker>>(
+  middleware<MW extends NonEmptyArray<GenericMiddlewareMaker>>(
     ...mw: MW
-  ): [MW] extends [NonEmptyArray<DynamicMiddlewareMaker<RequestContext>>] ? DynamicMiddlewareMakerrsss<
+  ): MW extends NonEmptyArray<{ dynamic: RpcDynamic<any, RequestContext[keyof RequestContext]> }>
+    ? DynamicMiddlewareMakerrsss<
       RequestContext,
-      Provided | MW[number]["dynamic"]["key"],
-      Middlewares,
+      // when one dynamic middleware depends on another, substract the key, to enforce the dependency to be provided after.
+      Exclude<
+        Provided | MW[number]["dynamic"]["key"],
+        { [K in keyof MW]: GetDependsOnKeys<MW[K]> }[number]
+      >,
+      [...Middlewares, ...MW],
       & DynamicMiddlewareProviders
       & {
         [U in MW[number] as U["dynamic"]["key"]]: U
@@ -58,9 +74,6 @@ export interface MiddlewareDynamic<
     >
 }
 
-type GetDynamicMiddleware<T, RequestContext extends Record<string, RPCContextMap.Any>> = T extends
-  RequestContextMapProvider<RequestContext> ? T : never
-
 type DynamicMiddlewareMakerrsss<
   RequestContext extends Record<string, RPCContextMap.Any>,
   Provided extends keyof RequestContext = never,
@@ -71,16 +84,9 @@ type DynamicMiddlewareMakerrsss<
       & ReturnType<
         typeof makeMiddlewareBasic<
           RequestContext,
-          GetDynamicMiddleware<DynamicMiddlewareProviders, RequestContext>,
           Middlewares
         >
       >
-      // & {
-      //   MiddlewareR: MiddlewareR
-      //   Provided: Provided
-      //   Middlewares: Middlewares
-      //   DynamicMiddlewareProviders: Simplify<DynamicMiddlewareProviders>
-      // }
       & MiddlewareM<
         RequestContext,
         Provided,
@@ -103,35 +109,91 @@ type DynamicMiddlewareMakerrsss<
     MiddlewareR
   >
 
-export const makeNewMiddleware: <
+export const makeMiddleware: <
   RequestContextMap extends Record<string, RPCContextMap.Any>
 >() => DynamicMiddlewareMakerrsss<RequestContextMap> = () => {
-  const make = makeMiddleware<any>()
-  let capturedMiddlewares: (DynamicMiddlewareMaker<any> | GenericMiddlewareMaker)[] = []
+  let allMiddleware: GenericMiddlewareMaker[] = []
   const it = {
     middleware: (...middlewares: any[]) => {
       for (const mw of middlewares) {
-        capturedMiddlewares = [mw, ...capturedMiddlewares]
-        if (mw.dynamic) {
-          console.log("Adding dynamic middleware", mw.key, mw.dynamic.key)
-        } else {
-          console.log("Adding generic middleware", mw.key)
-        }
+        allMiddleware = [mw, ...allMiddleware]
       }
-      const [genericMiddlewares, dyn] = Array.partitionMap(
-        capturedMiddlewares,
-        (mw) =>
-          "dynamic" in mw && mw.dynamic
-            ? Either.right(mw as DynamicMiddlewareMaker<any>)
-            : Either.left(mw as GenericMiddlewareMaker)
-      )
-      const dynamicMiddlewares = dyn.reduce(
-        (prev, cur) => ({ ...prev, [cur.dynamic.key]: cur }),
-        {} as Record<string, any>
-      )
       // TODO: support dynamic and generic intertwined. treat them as one
-      return Object.assign(make({ genericMiddlewares, dynamicMiddlewares }), it)
+      return Object.assign(makeMiddlewareBasic<any, any>(...allMiddleware), it)
     }
   }
   return it as any
 }
+
+export const makeMiddlewareBasic =
+  // by setting RequestContextMap beforehand, execute contextual typing does not fuck up itself to anys
+  <
+    RequestContextMap extends Record<string, RPCContextMap.Any>,
+    // RequestContextProviders extends RequestContextMapProvider<RequestContextMap>, // how to resolve the dynamic middleware
+    GenericMiddlewareProviders extends ReadonlyArray<GenericMiddlewareMaker>
+  >(
+    ...make: GenericMiddlewareProviders
+  ) => {
+    const MiddlewareMaker = Context.GenericTag<
+      MiddlewareMakerId,
+      {
+        effect: RPCHandlerFactory<
+          RequestContextMap,
+          GenericMiddlewareMaker.Provided<GenericMiddlewareProviders[number]>
+        >
+        _tag: "MiddlewareMaker"
+      }
+    >(
+      "MiddlewareMaker"
+    )
+
+    const middlewares = genericMiddlewareMaker(...make)
+
+    const l = Layer.scoped(
+      MiddlewareMaker,
+      middlewares
+        .effect
+        .pipe(
+          Effect.map((generic) => ({
+            _tag: "MiddlewareMaker" as const,
+            effect: makeRpcEffect<
+              RequestContextMap,
+              GenericMiddlewareMaker.Provided<GenericMiddlewareProviders[number]>
+            >()(
+              (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 as any),
+                          key: `${moduleName}.${payload._tag}`,
+                          _tag: `${moduleName}.${payload._tag}`
+                        }
+                      }
+                      return yield* generic({
+                        ...basic,
+                        next: next(payload, headers) as any
+                      })
+                    }) as any // why?
+              }
+            )
+          }))
+        )
+    )
+
+    const middlewareLayer = l
+      .pipe(
+        Layer.provide(middlewares.dependencies as any)
+      ) as Layer.Layer<
+        MiddlewareMakerId,
+        LayerUtils.GetLayersError<typeof middlewares.dependencies>, // what could go wrong when building the dynamic middleware provider
+        LayerUtils.GetLayersContext<typeof middlewares.dependencies>
+      >
+
+    return Object.assign(MiddlewareMaker, { Default: middlewareLayer })
+  }

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

@@ -3,7 +3,7 @@ import { Cause, Context, Duration, Effect, Layer, ParseResult, Request } from "e
 import { pretty } from "effect-app/utils"
 import { logError, reportError } from "../../../errorReporter.js"
 import { InfraLogger } from "../../../logger.js"
-import { Tag } from "../middleware.js"
+import { Tag } from "./RpcMiddleware.js"
 
 const logRequestError = logError("Request")
 const reportRequestError = reportError("Request")

package/src/api/routing/middleware.ts

@@ -1,10 +1,11 @@
 // codegen:start {preset: barrel, include: ./middleware/*.ts, nodir: false }
 export * from "./middleware/ContextProvider.js"
 export * from "./middleware/dynamic-middleware.js"
-export * from "./middleware/DynamicMiddleware.js"
 export * from "./middleware/generic-middleware.js"
 export * from "./middleware/middleware-api.js"
 export * from "./middleware/middleware.js"
+export * from "./middleware/RouterMiddleware.js"
+export * from "./middleware/RpcMiddleware.js"
 // codegen:end
 
 export * as Middleware from "./middleware.js"