@effect-app/infra 2.79.0 → 2.81.0

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

@@ -2,10 +2,10 @@
 /* eslint-disable @typescript-eslint/no-unsafe-return */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 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 SuccessValue, type TypeId } from "@effect/rpc/RpcMiddleware"
+import { Console, Context, Effect, Layer, type NonEmptyReadonlyArray, type Option, type Request, type S, type Schema, type Scope, Unify } from "effect-app"
 import type { GetEffectContext, RPCContextMap } from "effect-app/client/req"
-import { type HttpHeaders, 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"
@@ -73,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
@@ -83,7 +83,7 @@ export type RPCHandlerFactory<
   >
 >
 
-type RequestContextMapProvider<RequestContextMap extends Record<string, RPCContextMap.Any>> = {
+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"],
@@ -109,23 +109,23 @@ export interface MiddlewareMake<
   // this actually builds "the middleware", i.e. returns the augmented next factory when yielded...
   execute?: (
     maker: (
-      // MiddlewareR is set to GenericMiddlewareProviders | 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,
         | GenericMiddlewareMaker.Provided<GenericMiddlewareProviders[number]>
-        | HttpRouter.HttpRouter.Provided
+        | Scope.Scope
       >
     ) => MakeRPCHandlerFactory<
       RequestContextMap,
       | GenericMiddlewareMaker.Provided<GenericMiddlewareProviders[number]>
-      | HttpRouter.HttpRouter.Provided
+      | Scope.Scope
     >
   ) => Effect<
     MakeRPCHandlerFactory<
       RequestContextMap,
       | GenericMiddlewareMaker.Provided<GenericMiddlewareProviders[number]>
-      | HttpRouter.HttpRouter.Provided
+      | Scope.Scope
     >,
     MakeMiddlewareE,
     MakeMiddlewareR | Scope // ...that's why MakeMiddlewareR is here
@@ -155,6 +155,13 @@ export type RequestContextMapErrors<RequestContextMap extends Record<string, RPC
   RequestContextMap[keyof RequestContextMap]["error"]
 >
 
+/*:
+    & Context.Tag<MiddlewareMakerId, {
+      effect: RPCHandlerFactory<RequestContextMap, GenericMiddlewareMaker.Provided<GenericMiddlewareProviders[number]>>
+      _tag: "MiddlewareMaker"
+    }>
+    & { Default: "abc" } */
+
 // factory for middlewares
 export const makeMiddleware =
   // by setting RequestContextMap beforehand, execute contextual typing does not fuck up itself to anys
@@ -203,13 +210,138 @@ export const makeMiddleware =
             ? make.execute((
               cb: MakeRPCHandlerFactory<
                 RequestContextMap,
-                HttpRouter.HttpRouter.Provided | GenericMiddlewareMaker.Provided<GenericMiddlewareProviders[number]>
+                Scope.Scope | GenericMiddlewareMaker.Provided<GenericMiddlewareProviders[number]>
+              >
+            ) => cb)
+            : Effect.succeed<
+              MakeRPCHandlerFactory<
+                RequestContextMap,
+                Scope.Scope | GenericMiddlewareMaker.Provided<GenericMiddlewareProviders[number]>
+              >
+            >((_schema, next) => (payload, headers) => next(payload, headers))
+        })
+        .pipe(
+          Effect.map(({ dynamicMiddlewares, generic, middleware }) => ({
+            _tag: "MiddlewareMaker" as const,
+            effect: makeRpcEffect<
+              RequestContextMap,
+              GenericMiddlewareMaker.Provided<GenericMiddlewareProviders[number]>
+            >()(
+              (schema, next, moduleName) => {
+                const h = middleware(schema, next as any, moduleName)
+                return (payload, headers) => {
+                  const basic = {
+                    config: schema.config ?? {},
+                    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 /* ? */
+                    }
+                  }
+                  return Effect
+                    .gen(function*() {
+                      const gen = generic({
+                        ...basic,
+                        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(basic).pipe(
+                            Effect.flatMap((dynamicContext) => h(payload, headers).pipe(Effect.provide(dynamicContext)))
+                          ) as any
+                      })
+                      console.log({ gen })
+
+                      return yield* gen
+                    })
+                    .pipe(Effect.onExit(Console.log)) as any // why?
+                }
+              }
+            )
+          })),
+          Effect.onExit(Console.log)
+        )
+    )
+
+    const dependencies = [
+      ...(make.dependencies ? make.dependencies : []),
+      ...(dynamicMiddlewares.dependencies as any),
+      ...middlewares.dependencies
+    ]
+    const middlewareLayer = l
+      .pipe(
+        Layer.provide(dependencies as any)
+      ) as Layer.Layer<
+        MiddlewareMakerId,
+        | MakeMiddlewareE // what the middleware construction can fail with
+        | 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
+      >
+
+    return Object.assign(MiddlewareMaker, { Default: middlewareLayer })
+  }
+
+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 NonEmptyReadonlyArray<GenericMiddlewareMaker>
+  >(
+    make: MiddlewareMake<
+      RequestContextMap,
+      RequestContextProviders,
+      GenericMiddlewareProviders,
+      never,
+      never,
+      never
+    >
+  ) => {
+    const MiddlewareMaker = Context.GenericTag<
+      MiddlewareMakerId,
+      {
+        effect: RPCHandlerFactory<
+          RequestContextMap,
+          GenericMiddlewareMaker.Provided<GenericMiddlewareProviders[number]>
+        >
+        _tag: "MiddlewareMaker"
+      }
+    >(
+      "MiddlewareMaker"
+    )
+
+    const dynamicMiddlewares = implementMiddleware<RequestContextMap>()(make.dynamicMiddlewares)
+    const middlewares = genericMiddlewareMaker(...make.genericMiddlewares)
+
+    const l = Layer.scoped(
+      MiddlewareMaker,
+      Effect
+        .all({
+          dynamicMiddlewares: dynamicMiddlewares.effect,
+          generic: middlewares.effect,
+          middleware: make.execute
+            ? make.execute((
+              cb: MakeRPCHandlerFactory<
+                RequestContextMap,
+                Scope.Scope | GenericMiddlewareMaker.Provided<GenericMiddlewareProviders[number]>
               >
             ) => cb)
             : Effect.succeed<
               MakeRPCHandlerFactory<
                 RequestContextMap,
-                HttpRouter.HttpRouter.Provided | GenericMiddlewareMaker.Provided<GenericMiddlewareProviders[number]>
+                Scope.Scope | GenericMiddlewareMaker.Provided<GenericMiddlewareProviders[number]>
               >
             >((_schema, next) => (payload, headers) => next(payload, headers))
         })
@@ -225,7 +357,8 @@ export const makeMiddleware =
                 return (payload, headers) =>
                   Effect
                     .gen(function*() {
-                      const gen = generic({
+                      const basic = {
+                        config: schema.config ?? {},
                         payload,
                         headers,
                         clientId: 0, // TODO: get the clientId from the request context
@@ -239,17 +372,17 @@ export const makeMiddleware =
                           _tag: `${moduleName}.${payload._tag}`,
                           key: `${moduleName}.${payload._tag}` /* ? */
                           // clientId: 0 as number /* ? */
-                        }, // todo: make moduleName part of the tag on S.Req creation.
+                        }
+                      }
+                      return yield* generic({
+                        ...basic,
                         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(
+                          dynamicMiddlewares(basic).pipe(
                             Effect.flatMap((dynamicContext) => h(payload, headers).pipe(Effect.provide(dynamicContext)))
                           ) as any
                       })
-                      console.log({ gen })
-
-                      return yield* gen
                     })
                     .pipe(Effect.onExit(Console.log)) as any // why?
               }
@@ -261,7 +394,7 @@ export const makeMiddleware =
 
     const dependencies = [
       ...(make.dependencies ? make.dependencies : []),
-      ...(dynamicMiddlewares.dependencies as any),
+      ...(dynamicMiddlewares.dependencies),
       ...middlewares.dependencies
     ]
     const middlewareLayer = l
@@ -269,13 +402,10 @@ export const makeMiddleware =
         Layer.provide(dependencies as any)
       ) as Layer.Layer<
         MiddlewareMakerId,
-        | MakeMiddlewareE // what the middleware construction can fail with
         | 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
       >
 
     return Object.assign(MiddlewareMaker, { Default: middlewareLayer })
@@ -310,7 +440,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"]>>,
@@ -320,14 +450,14 @@ function makeRpcEffect<
   ) => cb
 }
 
-// updated to support HttpRouter.HttpRouter.Provided
+// 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, HttpRouter.HttpRouter.Provided>
+  }): Effect.Effect<Provides, E, Scope.Scope>
 }
 export interface RpcMiddlewareWrap<Provides, E> {
   (options: {
@@ -335,8 +465,8 @@ export interface RpcMiddlewareWrap<Provides, E> {
     readonly rpc: Rpc.AnyWithProps
     readonly payload: unknown
     readonly headers: HttpHeaders.Headers
-    readonly next: Effect.Effect<SuccessValue, E, Provides | HttpRouter.HttpRouter.Provided>
-  }): Effect.Effect<SuccessValue, E, HttpRouter.HttpRouter.Provided>
+    readonly next: Effect.Effect<SuccessValue, E, Provides | Scope.Scope>
+  }): Effect.Effect<SuccessValue, E, Scope.Scope>
 }
 
 type RpcOptionsOriginal = {
@@ -347,10 +477,154 @@ type RpcOptionsOriginal = {
   readonly requiredForClient?: boolean
 }
 
+type RpcDynamic<Key extends string, A extends RPCContextMap.Any> = {
+  key: Key
+  settings: A
+}
+
+type RpcOptionsDynamic<Key extends string, A extends RPCContextMap.Any> = RpcOptionsOriginal & {
+  readonly dynamic: RpcDynamic<Key, A>
+}
+
+export type Dynamic<Options> = Options extends RpcOptionsDynamic<any, any> ? true : false
+
+export interface RpcMiddlewareDynamic<A, E, Config> {
+  (options: {
+    readonly config: Config // todo
+    readonly clientId: number
+    readonly rpc: Rpc.AnyWithProps
+    readonly payload: unknown
+    readonly headers: HttpHeaders.Headers
+  }): Effect.Effect<Option.Option<Context.Context<A>>, E, Scope.Scope>
+}
+
+export interface TagClassDynamicAny<RequestContext extends Record<string, RPCContextMap.Any>>
+  extends Context.Tag<any, any>
+{
+  readonly [RpcMiddleware.TypeId]: RpcMiddleware.TypeId
+  readonly optional: boolean
+  readonly provides?: Context.Tag<any, any> | undefined
+  readonly failure: Schema.Schema.All
+  readonly requiredForClient: boolean
+  readonly dynamic: RpcDynamic<any, RequestContext[keyof RequestContext]>
+  readonly wrap: boolean
+}
+
+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"]>
+    : 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> } ? A["service"]
+    : 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"]
+      : undefined
+    readonly dynamic: Options extends RpcOptionsDynamic<any, any> ? Options["dynamic"]
+      : undefined
+    readonly requiredForClient: RequiredForClient<Options>
+    readonly wrap: Wrap<Options>
+  }
+}
+
+export interface TagClass<
+  Self,
+  Name extends string,
+  Options
+> extends
+  TagClass.Base<
+    Self,
+    Name,
+    Options,
+    TagClass.Wrap<Options> extends true ? RpcMiddlewareWrap<
+        TagClass.Provides<Options>,
+        TagClass.Failure<Options>
+      >
+      : Options extends RpcOptionsDynamic<any, any> ? RpcMiddlewareDynamic<
+          TagClass.Service<Options>,
+          TagClass.FailureService<Options>,
+          { [K in Options["dynamic"]["key"]]?: Options["dynamic"]["settings"]["contextActivation"] }
+        >
+      : RpcMiddleware<
+        TagClass.Service<Options>,
+        TagClass.FailureService<Options>
+      >
+  >
+{}
+
 export const Tag = <Self>() =>
 <
   const Name extends string,
-  const Options extends RpcOptionsOriginal
+  const Options extends RpcOptionsOriginal | RpcOptionsDynamic<any, any>
 >(
   id: Name,
   options?: Options | undefined
@@ -361,6 +635,11 @@ export const Tag = <Self>() =>
         TagClass.Provides<Options>,
         TagClass.Failure<Options>
       >
+      : Options extends RpcOptionsDynamic<any, any> ? RpcMiddlewareDynamic<
+          TagClass.Service<Options>,
+          TagClass.FailureService<Options>,
+          { [K in Options["dynamic"]["key"]]?: Options["dynamic"]["settings"]["contextActivation"] }
+        >
       : RpcMiddleware<
         TagClass.Service<Options>,
         TagClass.FailureService<Options>
@@ -369,10 +648,12 @@ export const Tag = <Self>() =>
     R
   >
   dependencies?: L
-}): RpcMiddleware.TagClass<Self, Name, Options> & {
+}): TagClass<Self, Name, Options> & {
   Default: Layer.Layer<Self, E | LayerUtils.GetLayersError<L>, Exclude<R, LayerUtils.GetLayersSuccess<L>>>
 } =>
   class extends RpcMiddleware.Tag<Self>()(id, options) {
+    // TODO: move to TagClass.
+    static readonly dynamic = options && "dynamic" in options ? options.dynamic : undefined
     static readonly Default = Layer.scoped(this, opts.effect as any).pipe(
       Layer.provide([Layer.empty, ...opts.dependencies ?? []])
     )

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

@@ -1,10 +1,12 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { Array, type Context, Effect, type Option, type S } from "effect-app"
+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"
 
 export type ContextWithLayer<
   Config,
@@ -18,25 +20,13 @@ export type ContextWithLayer<
   & (
     | ContextTagWithDefault<
       Id,
-      {
-        _tag: any
-        handle: (
-          config: Config,
-          headers: Record<string, string>
-        ) => Effect<Option<Context<Service>>, Error, any>
-      },
+      RpcMiddlewareDynamic<Service, Error, Config>,
       LayerE,
       LayerR
     >
     | ContextTagWithDefault<
       Id,
-      {
-        _tag: any
-        handle: (
-          config: Config,
-          headers: Record<string, string>
-        ) => Effect<Option<Context<Service>>, Error, never>
-      },
+      RpcMiddlewareDynamic<Service, Error, Config>,
       LayerE,
       LayerR
     >
@@ -76,26 +66,25 @@ export const implementMiddleware = <T extends Record<string, RPCContextMap.Any>>
 
     const makers = yield* Effect.all(sorted)
     return Effect.fnUntraced(
-      function*(config: { [K in keyof T]?: T[K]["contextActivation"] }, headers: Record<string, string>) {
+      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).handle(config, headers) as any }) as any
+            (_, i) => ({ maker: sorted[i], handle: (_ as any)(options) as any }) as any
           )
         )
         return ctx as Context.Context<
-          GetEffectContext<T, typeof config>
+          GetEffectContext<T, typeof options["config"]>
         >
       }
     )
   }) as unknown as Effect<
     (
-      config: { [K in keyof T]?: T[K]["contextActivation"] },
-      headers: Record<string, string>
+      options: { config: { [K in keyof T]?: T[K]["contextActivation"] }; headers: HttpHeaders.Headers }
     ) => Effect.Effect<
-      Context.Context<GetEffectContext<T, typeof config>>,
-      Effect.Error<ReturnType<Tag.Service<TI[keyof TI]>["handle"]>>,
-      Effect.Context<ReturnType<Tag.Service<TI[keyof TI]>["handle"]>>
+      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,13 +1,15 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { type Rpc, type RpcMiddleware } from "@effect/rpc"
 import { type SuccessValue, type TagClassAny } from "@effect/rpc/RpcMiddleware"
-import { type Array, Context, Effect, type Layer } from "effect-app"
-import { type HttpHeaders, type HttpRouter } from "effect-app/http"
+import { type Array, Context, Effect, type Layer, type Scope } from "effect-app"
+import { type RPCContextMap } from "effect-app/client"
+import { type HttpHeaders } from "effect-app/http"
 import { InfraLogger } from "../../../logger.js"
+import { type TagClassDynamicAny } from "./DynamicMiddleware.js"
 
 export interface GenericMiddlewareOptions<E> {
   // Effect rpc middleware does not support changing payload or headers, but we do..
-  readonly next: Effect.Effect<SuccessValue, E, HttpRouter.HttpRouter.Provided>
+  readonly next: Effect.Effect<SuccessValue, E, Scope.Scope>
   readonly payload: unknown
   readonly headers: HttpHeaders.Headers
   readonly clientId: number
@@ -15,6 +17,9 @@ 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 Provided<T> = T extends TagClassAny

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

@@ -0,0 +1,44 @@
+import { 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"
+
+export const contextMap = <RequestContextMap>() => <K extends keyof RequestContextMap>(a: K) => ({
+  key: a,
+  settings: null as any as RequestContextMap[typeof a]
+})
+
+type DynamicMiddlewareMakerrsss<
+  RequestContext extends Record<string, RPCContextMap.Any>,
+  Provided extends keyof RequestContext,
+  Middlewares extends NonEmptyReadonlyArray<GenericMiddlewareMaker>,
+  DynamicMiddlewareProviders extends RequestContextMapProvider<RequestContext>
+> = keyof Omit<RequestContext, Provided> extends never
+  ? { make: () => ReturnType<typeof makeMiddlewareBasic<RequestContext, DynamicMiddlewareProviders, Middlewares>> }
+  : {
+    addDynamicMiddleware: <MW extends DynamicMiddlewareMaker<RequestContext>>(
+      a: MW
+    ) => DynamicMiddlewareMakerrsss<
+      RequestContext,
+      Provided | MW["dynamic"]["key"],
+      Middlewares,
+      DynamicMiddlewareProviders & { [K in MW["dynamic"]["key"]]: MW }
+    > // TODO: any of RequestContecxtMap, and track them, so remove the ones provided
+  }
+
+export const makeNewMiddleware: <
+  RequestContextMap extends Record<string, RPCContextMap.Any>
+>() => <Middlewares extends NonEmptyReadonlyArray<GenericMiddlewareMaker>>(
+  ...genericMiddlewares: Middlewares
+) => DynamicMiddlewareMakerrsss<RequestContextMap, never, Middlewares, never> = () => (...genericMiddlewares) => {
+  const dynamicMiddlewares: Record<keyof any, any> = {} as any
+  const make = makeMiddleware<any>()
+  const it = {
+    addDynamicMiddleware: (a: any) => {
+      console.log("Adding dynamic middleware", a, a.dynamic, Object.keys(a))
+      ;(dynamicMiddlewares as any)[a.dynamic.key] = a
+      return it
+    },
+    make: () => make({ genericMiddlewares: genericMiddlewares as any, dynamicMiddlewares })
+  }
+  return it
+}

package/src/api/routing/middleware.ts

@@ -3,6 +3,7 @@ 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"
 // codegen:end