@effect-app/infra 2.74.0 → 2.76.0

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/{dynamic-middleware.ts → middleware/dynamic-middleware.ts}

@@ -1,81 +1,43 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { Array, Context, Effect, type Layer, Option, type S } from "effect-app"
+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 { sort } from "./tsort.js"
+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[]
-> =
-  & Context.Tag<
-    Id,
-    { handle: (...args: Args) => Effect<Option<Context<Service>>, E, R>; _tag: Tag }
+  Error,
+  Dependencies,
+  Thing extends ContextTagWithDefault<
+    any,
+    {
+      handle: (
+        ...args: [config: Config, headers: Record<string, string>]
+      ) => Effect<Option<Context<Service>>, Error, unknown>
+    },
+    any,
+    unknown,
+    any
   >
+> =
+  & Thing
   & {
-    Default: Layer.Layer<Id, MakeE, MakeR>
     dependsOn?: Dependencies
   }
 
-export type AnyContextWithLayer<Config, Service, Error> =
-  | ContextWithLayer<
+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) {
@@ -116,7 +78,7 @@ export const mergeOptionContexts = Effect.fnUntraced(
 export const implementMiddleware = <T extends Record<string, RPCContextMap.Any>>() =>
 <
   TI extends {
-    [K in keyof T]: AnyContextWithLayer<
+    [K in keyof T]: ContextWithLayer.Base<
       { [K in keyof T]?: T[K]["contextActivation"] },
       T[K]["service"],
       S.Schema.Type<T[K]["error"]>
@@ -142,13 +104,17 @@ export const implementMiddleware = <T extends Record<string, RPCContextMap.Any>>
           GetEffectContext<T, typeof config>
         >
       }
-    ) as (
+    )
+  }) as unknown as Effect<
+    (
       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"]>>
-    >
-  })
+    >,
+    never,
+    Tag.Identifier<{ [K in keyof TI]: TI[K] }[keyof TI]>
+  >
 })

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
+}

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

@@ -0,0 +1,134 @@
+import { Cause, Context, Effect, ParseResult } from "effect-app"
+import { HttpHeaders, type HttpRouter, HttpServerRequest } from "effect-app/http"
+import { pretty } from "effect-app/utils"
+import { logError, reportError } from "../../../errorReporter.js"
+import { InfraLogger } from "../../../logger.js"
+import { RequestCacheLayers } from "../../routing.js"
+
+const logRequestError = logError("Request")
+const reportRequestError = reportError("Request")
+
+export class DevMode extends Context.Reference<DevMode>()("DevMode", { defaultValue: () => false }) {}
+
+export class RequestCacheMiddleware extends Effect.Service<RequestCacheMiddleware>()("RequestCacheMiddleware", {
+  effect: Effect.gen(function*() {
+    return <A, E>(
+      handle: (input: any, headers: HttpHeaders.Headers) => Effect.Effect<A, E, HttpRouter.HttpRouter.Provided>,
+      _moduleName: string
+    ) =>
+      Effect.fnUntraced(function*(input: any, headers: HttpHeaders.Headers) {
+        return yield* handle(input, headers).pipe(Effect.provide(RequestCacheLayers))
+      })
+  })
+}) {}
+
+export class ConfigureInterruptibility extends Effect.Service<ConfigureInterruptibility>()(
+  "ConfigureInterruptibility",
+  {
+    effect: Effect.gen(function*() {
+      return <A, E>(
+        handle: (input: any, headers: HttpHeaders.Headers) => Effect.Effect<A, E, HttpRouter.HttpRouter.Provided>,
+        _moduleName: string
+      ) =>
+        Effect.fnUntraced(function*(input: any, headers: HttpHeaders.Headers) {
+          return yield* handle(input, headers).pipe(
+            // TODO: make this depend on query/command, and consider if middleware also should be affected. right now it's not.
+            Effect.uninterruptible
+          )
+        })
+    })
+  }
+) {}
+
+export class CaptureHttpHeadersAsRpcHeaders
+  extends Effect.Service<CaptureHttpHeadersAsRpcHeaders>()("CaptureHttpHeadersAsRpcHeaders", {
+    effect: Effect.gen(function*() {
+      return <A, E>(
+        handle: (input: any, headers: HttpHeaders.Headers) => Effect.Effect<A, E, HttpRouter.HttpRouter.Provided>,
+        _moduleName: string
+      ) =>
+        Effect.fnUntraced(function*(input: any, rpcHeaders: HttpHeaders.Headers) {
+          // merge in the request headers
+          // we should consider if we should merge them into rpc headers on the Protocol layer instead.
+          const httpReq = yield* HttpServerRequest.HttpServerRequest
+          const headers = HttpHeaders.merge(httpReq.headers, rpcHeaders)
+          return yield* handle(input, headers)
+        })
+    })
+  })
+{}
+
+export class MiddlewareLogger extends Effect.Service<MiddlewareLogger>()("MiddlewareLogger", {
+  effect: Effect.gen(function*() {
+    return <A, E>(
+      handle: (input: any, headers: HttpHeaders.Headers) => Effect.Effect<A, E, HttpRouter.HttpRouter.Provided>,
+      moduleName: string
+    ) =>
+      Effect.fnUntraced(function*(input: any, rpcHeaders: HttpHeaders.Headers) {
+        const devMode = yield* DevMode
+        // merge in the request headers
+        // we should consider if we should merge them into rpc headers on the Protocol layer instead.
+        const httpReq = yield* HttpServerRequest.HttpServerRequest
+        const headers = HttpHeaders.merge(httpReq.headers, rpcHeaders)
+
+        return yield* Effect
+          .annotateCurrentSpan(
+            "requestInput",
+            Object.entries(input).reduce((prev, [key, value]: [string, unknown]) => {
+              prev[key] = key === "password"
+                ? "<redacted>"
+                : typeof value === "string" || typeof value === "number" || typeof value === "boolean"
+                ? typeof value === "string" && value.length > 256
+                  ? (value.substring(0, 253) + "...")
+                  : value
+                : Array.isArray(value)
+                ? `Array[${value.length}]`
+                : value === null || value === undefined
+                ? `${value}`
+                : typeof value === "object" && value
+                ? `Object[${Object.keys(value).length}]`
+                : typeof value
+              return prev
+            }, {} as Record<string, string | number | boolean>)
+          )
+          .pipe(
+            // can't use andThen due to some being a function and effect
+            Effect.zipRight(handle(input, headers)),
+            // TODO: support ParseResult if the error channel of the request allows it.. but who would want that?
+            Effect.catchAll((_) => ParseResult.isParseError(_) ? Effect.die(_) : Effect.fail(_)),
+            Effect.tapErrorCause((cause) => Cause.isFailure(cause) ? logRequestError(cause) : Effect.void),
+            Effect.tapDefect((cause) =>
+              Effect
+                .all([
+                  reportRequestError(cause, {
+                    action: `${moduleName}.${input._tag}`
+                  }),
+                  InfraLogger
+                    .logError("Finished request", cause)
+                    .pipe(Effect.annotateLogs({
+                      action: `${moduleName}.${input._tag}`,
+                      req: pretty(input),
+                      headers: pretty(headers)
+                      // resHeaders: pretty(
+                      //   Object
+                      //     .entries(headers)
+                      //     .reduce((prev, [key, value]) => {
+                      //       prev[key] = value && typeof value === "string" ? snipString(value) : value
+                      //       return prev
+                      //     }, {} as Record<string, any>)
+                      // )
+                    }))
+                ])
+            ),
+            devMode ? (_) => _ : Effect.catchAllDefect(() => Effect.die("Internal Server Error"))
+          )
+      })
+  })
+}) {}
+
+export const DefaultGenericMiddlewares = [
+  RequestCacheMiddleware,
+  ConfigureInterruptibility,
+  CaptureHttpHeadersAsRpcHeaders,
+  MiddlewareLogger
+] as const

package/src/api/routing/middleware.ts

@@ -0,0 +1,7 @@
+// 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.js"
+// codegen:end