@effect-app/infra 2.73.4 → 2.75.0

package/src/api/layerUtils.ts

@@ -0,0 +1,34 @@
+import { type Context, type Layer, type NonEmptyReadonlyArray } from "effect-app"
+
+export namespace LayerUtils {
+  export type GetLayersSuccess<Layers extends ReadonlyArray<Layer.Layer.Any>> = Layers extends
+    NonEmptyReadonlyArray<Layer.Layer.Any> ? {
+      [k in keyof Layers]: Layer.Layer.Success<Layers[k]>
+    }[number]
+    : never
+
+  export type GetLayersContext<Layers extends ReadonlyArray<Layer.Layer.Any>> = Layers extends
+    NonEmptyReadonlyArray<Layer.Layer.Any> ? {
+      [k in keyof Layers]: Layer.Layer.Context<Layers[k]>
+    }[number]
+    : never
+
+  export type GetLayersError<Layers extends ReadonlyArray<Layer.Layer.Any>> = Layers extends
+    NonEmptyReadonlyArray<Layer.Layer.Any> ? {
+      [k in keyof Layers]: Layer.Layer.Error<Layers[k]>
+    }[number]
+    : never
+}
+
+export type ContextTagWithDefault<Id, A, LayerE, LayerR, Tag = unknown> =
+  & (Tag extends string ? Context.Tag<Id, { _tag: Tag } & A> : Context.Tag<Id, A>)
+  & {
+    Default: Layer.Layer<Id, LayerE, LayerR>
+    // new(a: A): Id
+  }
+
+export namespace ContextTagWithDefault {
+  export type Base<A> = ContextTagWithDefault<any, any, A, any, any>
+}
+
+export type GetContext<T> = T extends Context.Context<infer Y> ? Y : never

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

@@ -0,0 +1,148 @@
+import { type Array, Context, Effect, Layer, type NonEmptyArray, pipe, type Scope } from "effect-app"
+import { type HttpRouter } from "effect-app/http"
+import { type ContextTagWithDefault, type GetContext, type LayerUtils } from "../../layerUtils.js"
+import { mergeContexts } from "./dynamic-middleware.js"
+
+// the context provider provides additional stuff
+export type ContextProviderShape<ContextProviderA, ContextProviderR extends HttpRouter.HttpRouter.Provided> = Effect<
+  Context.Context<ContextProviderA>,
+  never, // no errors are allowed
+  ContextProviderR
+>
+
+export interface ContextProviderId {
+  _tag: "ContextProvider"
+}
+
+// Note: the type here must be aligned with MergedContextProvider
+export const mergeContextProviders = <
+  // TDeps is an array of services whit Default implementation
+  // each service is an effect which builds some context for each request
+  TDeps extends Array.NonEmptyReadonlyArray<
+    & (
+      // E = never => the context provided cannot trigger errors
+      // can't put HttpRouter.HttpRouter.Provided as R here because of variance
+      // (TDeps is an input type parameter so it's contravariant therefore Effect's R becomes contravariant too)
+      | Context.Tag<any, Effect<Context.Context<any>, never, any> & { _tag: any }>
+      | Context.Tag<any, Effect<Context.Context<any>, never, never> & { _tag: any }>
+    )
+    & {
+      new(...args: any[]): any
+      Default: Layer.Layer<Effect<Context.Context<any>> & { _tag: any }, any, any>
+    }
+  >
+>(
+  ...deps: {
+    [K in keyof TDeps]: TDeps[K]["Service"] extends Effect<Context.Context<any>, never, HttpRouter.HttpRouter.Provided>
+      ? TDeps[K]
+      : `HttpRouter.HttpRouter.Provided are the only requirements ${TDeps[K]["Service"][
+        "_tag"
+      ]}'s returned effect can have`
+  }
+): {
+  dependencies: { [K in keyof TDeps]: TDeps[K]["Default"] }
+  effect: Effect.Effect<
+    Effect.Effect<
+      Context.Context<GetContext<Effect.Success<InstanceType<TDeps[number]>>>>,
+      never,
+      Effect.Context<InstanceType<TDeps[number]>>
+    >,
+    LayerUtils.GetLayersError<{ [K in keyof TDeps]: TDeps[K]["Default"] }>,
+    LayerUtils.GetLayersSuccess<{ [K in keyof TDeps]: TDeps[K]["Default"] }>
+  >
+} => ({
+  dependencies: deps.map((_) => _.Default) as any,
+  effect: Effect.gen(function*() {
+    const makers = yield* Effect.all(deps)
+    return Effect
+      .gen(function*() {
+        const services = (makers as any[]).map((handle, i) => ({ maker: deps[i], handle }))
+        // services are effects which return some Context.Context<...>
+        const context = yield* mergeContexts(services as any)
+        return context
+      })
+  }) as any
+})
+
+export const ContextProvider = <
+  ContextProviderA,
+  MakeContextProviderE,
+  MakeContextProviderR,
+  ContextProviderR extends HttpRouter.HttpRouter.Provided,
+  Dependencies extends NonEmptyArray<Layer.Layer.Any>
+>(
+  input: {
+    effect: Effect<
+      Effect<ContextProviderA, never, ContextProviderR>,
+      MakeContextProviderE,
+      MakeContextProviderR | Scope
+    >
+    dependencies?: Dependencies
+  }
+) => {
+  const ctx = Context.GenericTag<
+    ContextProviderId,
+    Effect<ContextProviderA, never, ContextProviderR>
+  >(
+    "ContextProvider"
+  )
+  const l = Layer.scoped(ctx, input.effect)
+  return Object.assign(ctx, {
+    Default: l.pipe(
+      input.dependencies ? Layer.provide(input.dependencies) as any : (_) => _
+    ) as Layer.Layer<
+      ContextProviderId,
+      | MakeContextProviderE
+      | LayerUtils.GetLayersError<Dependencies>,
+      | Exclude<MakeContextProviderR, LayerUtils.GetLayersSuccess<Dependencies>>
+      | LayerUtils.GetLayersContext<Dependencies>
+    >
+  })
+}
+
+// Note: the type here must be aligned with mergeContextProviders
+export const MergedContextProvider = <
+  // TDeps is an array of services whit Default implementation
+  // each service is an effect which builds some context for each request
+  TDeps extends Array.NonEmptyReadonlyArray<
+    & (
+      // E = never => the context provided cannot trigger errors
+      // can't put HttpRouter.HttpRouter.Provided as R here because of variance
+      // (TDeps is an input type parameter so it's contravariant therefore Effect's R becomes contravariant too)
+      | Context.Tag<any, Effect<Context.Context<any>, never, any> & { _tag: any }>
+      | Context.Tag<any, Effect<Context.Context<any>, never, never> & { _tag: any }>
+    )
+    & {
+      new(...args: any[]): any
+      Default: Layer.Layer<Effect<Context.Context<any>> & { _tag: any }, any, any>
+    }
+  >
+>(
+  ...deps: {
+    [K in keyof TDeps]: TDeps[K]["Service"] extends Effect<Context.Context<any>, never, HttpRouter.HttpRouter.Provided>
+      ? TDeps[K]
+      : `HttpRouter.HttpRouter.Provided are the only requirements ${TDeps[K]["Service"][
+        "_tag"
+      ]}'s returned effect can have`
+  }
+) =>
+  pipe(
+    deps as [Parameters<typeof mergeContextProviders>[0]],
+    (_) => mergeContextProviders(..._),
+    (_) => ContextProvider(_ as any)
+  ) as unknown as ContextTagWithDefault<
+    ContextProviderId,
+    Effect.Effect<
+      Context.Context<GetContext<Effect.Success<InstanceType<TDeps[number]>>>>,
+      never,
+      Effect.Context<InstanceType<TDeps[number]>>
+    >,
+    LayerUtils.GetLayersError<{ [K in keyof TDeps]: TDeps[K]["Default"] }>,
+    | Exclude<
+      InstanceType<TDeps[number]>,
+      LayerUtils.GetLayersSuccess<{ [K in keyof TDeps]: TDeps[K]["Default"] }>
+    >
+    | LayerUtils.GetLayersContext<{ [K in keyof TDeps]: TDeps[K]["Default"] }>
+  >
+
+export const EmptyContextProvider = ContextProvider({ effect: Effect.succeed(Effect.succeed(Context.empty())) })

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

@@ -0,0 +1,317 @@
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-unsafe-return */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { Context, Effect, Layer, type NonEmptyArray, type Request, type S, type Scope } from "effect-app"
+import type { GetEffectContext, RPCContextMap } from "effect-app/client/req"
+import { type HttpRouter } from "effect-app/http"
+import type * as EffectRequest from "effect/Request"
+import { type ContextTagWithDefault, type LayerUtils } from "../../layerUtils.js"
+import { type ContextProviderId, type ContextProviderShape } from "./ContextProvider.js"
+import { type ContextWithLayer, implementMiddleware } from "./dynamic-middleware.js"
+import { type GenericMiddlewareMaker, genericMiddlewareMaker } from "./generic-middleware.js"
+
+// 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>,
+  handler: (
+    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>,
+  ContextProviderA
+> = <
+  T extends {
+    config?: Partial<Record<keyof RequestContextMap, any>>
+  },
+  Req extends S.TaggedRequest.All,
+  HandlerR
+>(
+  schema: T & S.Schema<Req, any, never>,
+  handler: (
+    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>,
+  | HttpRouter.HttpRouter.Provided // 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
+    Exclude<HandlerR, GetEffectContext<RequestContextMap, (T & S.Schema<Req, any, never>)["config"]>>,
+    // the context provider provides additional stuff both to the middleware and the handler
+    ContextProviderA
+  >
+>
+
+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 MiddlewareMake<
+  RequestContextMap extends Record<string, RPCContextMap.Any>, // what services will the middleware provide dynamically to the handler, or raise errors.
+  //
+  // ContextProvider is a service that builds additional context for each request.
+  ContextProviderA, // what the context provider provides
+  ContextProviderR extends HttpRouter.HttpRouter.Provided, // what the context provider requires
+  MakeContextProviderE, // what the context provider construction can fail with
+  MakeContextProviderR, // what the context provider construction requires
+  DynamicMiddlewareProviders extends RequestContextMapProvider<RequestContextMap>, // how to resolve the dynamic middleware
+  GenericMiddlewareProviders extends Array<
+    ContextTagWithDefault.Base<GenericMiddlewareMaker>
+  >,
+  MakeMiddlewareE, // what the middleware construction can fail with
+  MakeMiddlewareR, // what the middleware requires to be constructed
+  MiddlewareDependencies extends NonEmptyArray<Layer.Layer.Any> // layers provided for the middleware to be constructed
+> {
+  /* dynamic middlewares to be applied based on Request Configuration */
+  dynamicMiddlewares: DynamicMiddlewareProviders
+  /** generic middlewares are those which follow the (next) => (input, headers) => pattern */
+  genericMiddlewares: GenericMiddlewareProviders
+  /** static context providers */
+  contextProvider: ContextTagWithDefault<
+    ContextProviderId,
+    ContextProviderShape<ContextProviderA, ContextProviderR>,
+    MakeContextProviderE,
+    MakeContextProviderR
+  >
+
+  /* dependencies for the main middleware running just before the handler is called */
+  dependencies?: MiddlewareDependencies
+  // this actually builds "the middleware", i.e. returns the augmented handler factory when yielded...
+  execute?: (
+    maker: (
+      // MiddlewareR is set to ContextProviderA | HttpRouter.HttpRouter.Provided because that's what, at most
+      // a middleware can additionally require to get executed
+      cb: MakeRPCHandlerFactory<RequestContextMap, ContextProviderA | HttpRouter.HttpRouter.Provided>
+    ) => MakeRPCHandlerFactory<RequestContextMap, ContextProviderA | HttpRouter.HttpRouter.Provided>
+  ) => Effect<
+    MakeRPCHandlerFactory<RequestContextMap, ContextProviderA | HttpRouter.HttpRouter.Provided>,
+    MakeMiddlewareE,
+    MakeMiddlewareR | Scope // ...that's why MakeMiddlewareR is here
+  >
+}
+
+export interface MiddlewareMakerId {
+  _tag: "MiddlewareMaker"
+}
+
+export type Middleware<
+  RequestContextMap extends Record<string, RPCContextMap.Any>, // what services will the middlware provide dynamically to the handler, or raise errors.
+  MakeMiddlewareE, // what the middleware construction can fail with
+  MakeMiddlewareR, // what the middlware requires to be constructed
+  ContextProviderA // what the context provider provides
+> = ContextTagWithDefault<
+  MiddlewareMakerId,
+  {
+    effect: RPCHandlerFactory<RequestContextMap, ContextProviderA>
+  },
+  MakeMiddlewareE,
+  MakeMiddlewareR,
+  "MiddlewareMaker"
+>
+
+export type RequestContextMapErrors<RequestContextMap extends Record<string, RPCContextMap.Any>> = S.Schema.Type<
+  RequestContextMap[keyof RequestContextMap]["error"]
+>
+
+// factory for middlewares
+export const makeMiddleware =
+  // by setting RequestContextMap beforehand, execute contextual typing does not fuck up itself to anys
+  <
+    RequestContextMap extends Record<string, RPCContextMap.Any>
+  >() =>
+  <
+    //
+    // ContextProvider is a service that builds additional context for each request.
+    ContextProviderA, // what the context provider provides
+    ContextProviderR extends HttpRouter.HttpRouter.Provided, // what the context provider requires
+    MakeContextProviderE, // what the context provider construction can fail with
+    MakeContextProviderR, // what the context provider construction requires
+    RequestContextProviders extends RequestContextMapProvider<RequestContextMap>, // how to resolve the dynamic middleware
+    GenericMiddlewareProviders extends Array<
+      ContextTagWithDefault.Base<GenericMiddlewareMaker>
+    >,
+    MiddlewareDependencies extends NonEmptyArray<Layer.Layer.Any>, // layers provided for the middlware to be constructed
+    MakeMiddlewareE = never, // what the middleware construction can fail with
+    MakeMiddlewareR = never // what the middlware requires to be constructed
+  >(
+    make: MiddlewareMake<
+      RequestContextMap,
+      ContextProviderA,
+      ContextProviderR,
+      MakeContextProviderE,
+      MakeContextProviderR,
+      RequestContextProviders,
+      GenericMiddlewareProviders,
+      MakeMiddlewareE,
+      MakeMiddlewareR,
+      MiddlewareDependencies
+    >
+  ) => {
+    // type Id = MiddlewareMakerId &
+    const MiddlewareMaker = Context.GenericTag<
+      MiddlewareMakerId,
+      {
+        effect: RPCHandlerFactory<RequestContextMap, ContextProviderA>
+        _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, HttpRouter.HttpRouter.Provided | ContextProviderA>
+            ) => cb)
+            : Effect.succeed<
+              MakeRPCHandlerFactory<RequestContextMap, ContextProviderA | HttpRouter.HttpRouter.Provided>
+            >((_schema, handle) => (req, headers) => handle(req, headers)),
+          contextProvider: make.contextProvider // uses the middleware.contextProvider tag to get the context provider service
+        })
+        .pipe(
+          Effect.map(({ contextProvider, dynamicMiddlewares, generic, middleware }) => ({
+            _tag: "MiddlewareMaker" as const,
+            effect: makeRpcEffect<RequestContextMap, ContextProviderA>()(
+              (schema, handler, moduleName) => {
+                const h = middleware(schema, handler as any, moduleName)
+                return generic(
+                  Effect.fnUntraced(function*(req, headers) {
+                    yield* Effect.annotateCurrentSpan(
+                      "request.name",
+                      moduleName ? `${moduleName}.${req._tag}` : req._tag
+                    )
+
+                    // the contextProvider is an Effect that builds the context for the request
+                    return yield* contextProvider.pipe(
+                      Effect.flatMap((contextProviderContext) =>
+                        // the dynamicMiddlewares is an Effect that builds the dynamiuc context for the request
+                        dynamicMiddlewares(schema.config ?? {}, headers).pipe(
+                          Effect.flatMap((dynamicContext) => h(req, headers).pipe(Effect.provide(dynamicContext))),
+                          Effect.provide(contextProviderContext)
+                        )
+                      )
+                    )
+                  }) as any,
+                  moduleName
+                )
+              }
+            )
+          }))
+        )
+    )
+
+    const middlewareLayer = l
+      .pipe(
+        Layer.provide(
+          Layer.mergeAll(
+            make.dependencies ? make.dependencies as any : Layer.empty,
+            ...(dynamicMiddlewares.dependencies as any),
+            make.contextProvider.Default,
+            ...middlewares.dependencies
+          )
+        )
+      ) as Layer.Layer<
+        MiddlewareMakerId,
+        | MakeMiddlewareE // what the middleware construction can fail with
+        | LayerUtils.GetLayersContext<typeof dynamicMiddlewares.dependencies>
+        | LayerUtils.GetLayersContext<typeof middlewares.dependencies> // what could go wrong when building the dynamic middleware provider
+        | Layer.Error<typeof make.contextProvider.Default>, // what could go wrong when building the context 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
+        | Layer.Context<typeof make.contextProvider.Default> // what's needed to build the contextProvider
+      >
+
+    return Object.assign(MiddlewareMaker, { Default: middlewareLayer })
+  }
+
+// it just provides the right types without cluttering the implementation with them
+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>,
+      handler: (
+        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>,
+      | HttpRouter.HttpRouter.Provided // the context provider may require HttpRouter.Provided to run
+      | Exclude<
+        // it can also be removed from HandlerR
+        Exclude<HandlerR, GetEffectContext<RequestContextMap, (T & S.Schema<Req, any, never>)["config"]>>,
+        ContextProviderA
+      >
+    >
+  ) => cb
+}

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

@@ -0,0 +1,158 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { Array, Context, Effect, Option, type S } from "effect-app"
+import { type GetEffectContext, type RPCContextMap } from "effect-app/client"
+import { type Tag } from "effect-app/Context"
+import { typedValuesOf } from "effect-app/utils"
+import { InfraLogger } from "../../../logger.js"
+import { type ContextTagWithDefault } from "../../layerUtils.js"
+import { sort } from "../tsort.js"
+
+export type ContextWithLayer<
+  Config,
+  Id,
+  Service,
+  E,
+  R,
+  MakeE,
+  MakeR,
+  Tag extends string,
+  Args extends [config: Config, headers: Record<string, string>],
+  Dependencies extends any[]
+> =
+  & ContextTagWithDefault<
+    Id,
+    { handle: (...args: Args) => Effect<Option<Context<Service>>, E, R>; _tag: Tag },
+    MakeE,
+    MakeR
+  >
+  & {
+    dependsOn?: Dependencies
+  }
+
+export namespace ContextWithLayer {
+  export type Base<Config, Service, Error> =
+    | ContextWithLayer<
+      Config,
+      any,
+      Service,
+      Error,
+      any,
+      any,
+      any,
+      string,
+      any,
+      any
+    >
+    | ContextWithLayer<
+      Config,
+      any,
+      Service,
+      Error,
+      never,
+      any,
+      never,
+      any,
+      any,
+      any
+    >
+    | ContextWithLayer<
+      Config,
+      any,
+      Service,
+      Error,
+      any,
+      any,
+      never,
+      any,
+      any,
+      any
+    >
+    | ContextWithLayer<
+      Config,
+      any,
+      Service,
+      Error,
+      never,
+      any,
+      any,
+      any,
+      any,
+      any
+    >
+}
+
+export const mergeContexts = Effect.fnUntraced(
+  function*<T extends readonly { maker: any; handle: Effect<Context<any>> }[]>(makers: T) {
+    let context = Context.empty()
+    for (const mw of makers) {
+      yield* InfraLogger.logDebug("Building context for middleware", mw.maker.key ?? mw.maker)
+      const moreContext = yield* mw.handle.pipe(Effect.provide(context))
+      yield* InfraLogger.logDebug(
+        "Built context for middleware",
+        mw.maker.key ?? mw.maker,
+        (moreContext as any).toJSON().services
+      )
+      context = Context.merge(context, moreContext)
+    }
+    return context as Context.Context<Effect.Success<T[number]["handle"]>>
+  }
+)
+
+export const mergeOptionContexts = Effect.fnUntraced(
+  function*<T extends readonly { maker: any; handle: Effect<Option<Context<any>>> }[]>(makers: T) {
+    let context = Context.empty()
+    for (const mw of makers) {
+      yield* InfraLogger.logDebug("Building context for middleware", mw.maker.key ?? mw.maker)
+      const moreContext = yield* mw.handle.pipe(Effect.provide(context))
+      yield* InfraLogger.logDebug(
+        "Built context for middleware",
+        mw.maker.key ?? mw.maker,
+        Option.map(moreContext, (c) => (c as any).toJSON().services)
+      )
+      if (moreContext.value) {
+        context = Context.merge(context, moreContext.value)
+      }
+    }
+    return context
+  }
+)
+
+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*(config: { [K in keyof T]?: T[K]["contextActivation"] }, headers: Record<string, string>) {
+        const ctx = yield* mergeOptionContexts(
+          Array.map(
+            makers,
+            (_, i) => ({ maker: sorted[i], handle: (_ as any).handle(config, headers) as any }) as any
+          )
+        )
+        return ctx as Context.Context<
+          GetEffectContext<T, typeof config>
+        >
+      }
+    ) as (
+      config: { [K in keyof T]?: T[K]["contextActivation"] },
+      headers: Record<string, string>
+    ) => 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"]>>
+    >
+  })
+})

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

@@ -0,0 +1,38 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { type Array, Effect } from "effect-app"
+import { type HttpHeaders, type HttpRouter } from "effect-app/http"
+import { type ContextTagWithDefault } from "../../layerUtils.js"
+
+export type GenericMiddlewareMaker = <A, E>(
+  handle: (input: any, headers: HttpHeaders.Headers) => Effect.Effect<A, E, HttpRouter.HttpRouter.Provided>,
+  moduleName: string
+) => (input: any, headers: HttpHeaders.Headers) => Effect.Effect<A, E, HttpRouter.HttpRouter.Provided>
+
+export const genericMiddlewareMaker = <
+  T extends Array<
+    ContextTagWithDefault.Base<GenericMiddlewareMaker>
+  >
+>(...middlewares: T): {
+  dependencies: { [K in keyof T]: T[K]["Default"] }
+  effect: Effect.Effect<GenericMiddlewareMaker>
+} => {
+  return {
+    dependencies: middlewares.map((_) => _.Default),
+    effect: Effect.gen(function*() {
+      const middlewaresInstances = yield* Effect.all(middlewares)
+
+      return <A, E, R>(
+        handle: (input: any, headers: HttpHeaders.Headers) => Effect.Effect<A, E, R>,
+        moduleName: string
+      ) => {
+        return (input: any, headers: HttpHeaders.Headers) => {
+          let effect = handle
+          for (const middleware of (middlewaresInstances as any[]).toReversed()) {
+            effect = middleware(effect, moduleName)
+          }
+          return effect(input, headers)
+        }
+      }
+    })
+  } as any
+}