@effect-app/infra 2.73.2 → 2.73.3

package/src/api/routing/DynamicMiddleware.ts

@@ -1,12 +1,18 @@
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
 /* eslint-disable @typescript-eslint/no-unsafe-return */
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { type Array, Context, Effect, Layer, type NonEmptyArray, type Request, type S } from "effect-app"
+import { type Array, Context, Effect, Layer, type NonEmptyArray, pipe, type Request, type S } 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 LayersUtils } from "../routing.js"
 
+// utils:
+//
+type GetContext<T> = T extends Context.Context<infer Y> ? Y : never
+
+// module:
+//
 export type MakeRPCHandlerFactory<
   RequestContextMap extends Record<string, RPCContextMap.Any>,
   MiddlewareR
@@ -33,7 +39,7 @@ export type MakeRPCHandlerFactory<
 ) => 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 the MiddlewareR
+  // 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"]>>
@@ -41,7 +47,6 @@ export type MakeRPCHandlerFactory<
 
 export type RPCHandlerFactory<
   RequestContextMap extends Record<string, RPCContextMap.Any>,
-  MiddlewareR,
   ContextProviderA
 > = <
   T extends {
@@ -66,32 +71,32 @@ export type RPCHandlerFactory<
 ) => Effect.Effect<
   Request.Request.Success<Req>,
   Request.Request.Error<Req> | RequestContextMapErrors<RequestContextMap>,
-  | HttpRouter.HttpRouter.Provided
-  // the middleware will remove from HandlerR the dynamic context, but will also add the MiddlewareR
+  | HttpRouter.HttpRouter.Provided // because of the context provider and the middleware (Middleware)
   | Exclude<
-    | MiddlewareR
+    // 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"]>>,
+    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
   >
 >
 
-function makeRpcHandler<RequestContextMap extends Record<string, RPCContextMap.Any>, MiddlewareR>() {
-  return (cb: MakeRPCHandlerFactory<RequestContextMap, MiddlewareR>) => cb
-}
-
-export type ContextProviderShape<ContextProviderA, ContextProviderR> = Effect<
+// the context provider provides additional stuff
+export type ContextProviderShape<ContextProviderA, ContextProviderR extends HttpRouter.HttpRouter.Provided> = Effect<
   Context.Context<ContextProviderA>,
-  never,
+  never, // no errors are allowed
   ContextProviderR
 >
 
+export interface ContextProviderId {
+  _tag: "ContextProvider"
+}
+
 export interface MiddlewareMake<
-  MiddlewareR, // what the middlware requires to execute
-  RequestContextMap extends Record<string, RPCContextMap.Any>, // what services will the middlware provide dynamically to the handler, or raise errors.
+  RequestContextMap extends Record<string, RPCContextMap.Any>, // what services will the middleware provide dynamically to the handler, or raise errors.
   MakeMiddlewareE, // what the middleware construction can fail with
-  MakeMiddlewareR, // what the middlware requires to be constructed
-  MiddlewareDependencies extends NonEmptyArray<Layer.Layer.Any>, // layers provided for the middlware to be constructed
+  MakeMiddlewareR, // what the middleware requires to be constructed
+  MiddlewareDependencies extends NonEmptyArray<Layer.Layer.Any>, // layers provided for the middleware to be constructed
   //
   // ContextProvider is a service that builds additional context for each request.
   ContextProviderA, // what the context provider provides
@@ -108,32 +113,29 @@ export interface MiddlewareMake<
     & {
       Default: Layer.Layer<ContextProviderId, MakeContextProviderE, MakeContextProviderR>
     }
+  // this actually builds "the middleware", i.e. returns the augmented handler factory when yielded...
   execute: (
     maker: (
-      cb: MakeRPCHandlerFactory<RequestContextMap, MiddlewareR>
-    ) => MakeRPCHandlerFactory<RequestContextMap, MiddlewareR>
+      // 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, MiddlewareR>,
+    MakeRPCHandlerFactory<RequestContextMap, ContextProviderA | HttpRouter.HttpRouter.Provided>,
     MakeMiddlewareE,
-    MakeMiddlewareR
+    MakeMiddlewareR // ...that's why MakeMiddlewareR is here
   >
 }
 
-export interface MiddlewareMakerId {
-  _tag: "MiddlewareMaker"
-}
-
-export interface ContextProviderId {
-  _tag: "ContextProvider"
-}
-
-type GetContext<T> = T extends Context.Context<infer Y> ? Y : never
-
+// 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 }>
     )
@@ -142,15 +144,23 @@ export const mergeContextProviders = <
       Default: Layer.Layer<Effect<Context.Context<any>> & { _tag: any }, any, any>
     }
   >
->(...deps: TDeps): {
+>(
+  ...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]>>>>,
-      Effect.Error<InstanceType<TDeps[number]>>,
+      never,
       Effect.Context<InstanceType<TDeps[number]>>
     >,
-    never,
+    LayersUtils.GetLayersError<{ [K in keyof TDeps]: TDeps[K]["Default"] }>,
     InstanceType<TDeps[number]>
   >
 } => ({
@@ -158,34 +168,32 @@ export const mergeContextProviders = <
   effect: Effect.gen(function*() {
     const services = yield* Effect.all(deps)
     // services are effects which return some Context.Context<...>
+    // @effect-diagnostics effect/returnEffectInGen:off
     return Effect.all(services as any[]).pipe(
       Effect.map((_) => Context.mergeAll(..._ as any))
     )
   }) as any
 })
 
-// TODO: andrea; how?
-// 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<
-//     & (
-//       | 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: TDeps) => ContextProvider(mergeContextProviders(...deps))
+export interface MiddlewareMakerId {
+  _tag: "MiddlewareMaker"
+}
 
-export const ContextProvider = <A, E, R, ContextE, ContextR, Dependencies extends NonEmptyArray<Layer.Layer.Any>>(
-  input: { effect: Effect<Effect<A, ContextE, ContextR>, E, R>; dependencies?: Dependencies }
+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>
+    dependencies?: Dependencies
+  }
 ) => {
   const ctx = Context.GenericTag<
     ContextProviderId,
-    Effect<A, ContextE, ContextR>
+    Effect<ContextProviderA, never, ContextProviderR>
   >(
     "ContextProvider"
   )
@@ -195,16 +203,68 @@ export const ContextProvider = <A, E, R, ContextE, ContextR, Dependencies extend
       input.dependencies ? Layer.provide(input.dependencies) as any : (_) => _
     ) as Layer.Layer<
       ContextProviderId,
-      E | LayersUtils.GetLayersError<Dependencies>,
-      Exclude<R, LayersUtils.GetLayersSuccess<Dependencies>> | LayersUtils.GetLayersContext<Dependencies>
+      | MakeContextProviderE
+      | LayersUtils.GetLayersError<Dependencies>,
+      | Exclude<MakeContextProviderR, LayersUtils.GetLayersSuccess<Dependencies>>
+      | LayersUtils.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
+    & Context.Tag<
+      ContextProviderId,
+      Effect.Effect<
+        Context.Context<GetContext<Effect.Success<InstanceType<TDeps[number]>>>>,
+        never,
+        Effect.Context<InstanceType<TDeps[number]>>
+      >
+    >
+    & {
+      Default: Layer.Layer<
+        ContextProviderId,
+        LayersUtils.GetLayersError<{ [K in keyof TDeps]: TDeps[K]["Default"] }>,
+        | Exclude<
+          InstanceType<TDeps[number]>,
+          LayersUtils.GetLayersSuccess<{ [K in keyof TDeps]: TDeps[K]["Default"] }>
+        >
+        | LayersUtils.GetLayersContext<{ [K in keyof TDeps]: TDeps[K]["Default"] }>
+      >
+    }
+
 export const EmptyContextProvider = ContextProvider({ effect: Effect.succeed(Effect.succeed(Context.empty())) })
 
 export type Middleware<
-  MiddlewareR, // what the middlware requires to execute
   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
@@ -213,9 +273,7 @@ export type Middleware<
   & Context.Tag<
     MiddlewareMakerId,
     MiddlewareMakerId & {
-      effect: RPCHandlerFactory<RequestContextMap, MiddlewareR, ContextProviderA>
-    } & {
-      _tag: "MiddlewareMaker"
+      effect: RPCHandlerFactory<RequestContextMap, ContextProviderA>
     }
   >
   & {
@@ -230,10 +288,12 @@ export type RequestContextMapErrors<RequestContextMap extends Record<string, RPC
   RequestContextMap[keyof RequestContextMap]["error"]
 >
 
-// identity factory for Middleware
+// factory for middlewares
 export const makeMiddleware =
-  // by setting MiddlewareR and RequestContextMap beforehand, execute contextual typing does not fuck up itself to anys
-  <RequestContextMap extends Record<string, RPCContextMap.Any>, MiddlewareR>() =>
+  // by setting RequestContextMap beforehand, execute contextual typing does not fuck up itself to anys
+  <
+    RequestContextMap extends Record<string, RPCContextMap.Any>
+  >() =>
   <
     MakeMiddlewareE, // what the middleware construction can fail with
     MakeMiddlewareR, // what the middlware requires to be constructed
@@ -246,7 +306,6 @@ export const makeMiddleware =
     MakeContextProviderR // what the context provider construction requires
   >(
     make: MiddlewareMake<
-      MiddlewareR,
       RequestContextMap,
       MakeMiddlewareE,
       MakeMiddlewareR,
@@ -261,7 +320,7 @@ export const makeMiddleware =
     const MiddlewareMaker = Context.GenericTag<
       MiddlewareMakerId,
       {
-        effect: RPCHandlerFactory<RequestContextMap, MiddlewareR, ContextProviderA>
+        effect: RPCHandlerFactory<RequestContextMap, ContextProviderA>
         _tag: "MiddlewareMaker"
       }
     >(
@@ -272,13 +331,15 @@ export const makeMiddleware =
       MiddlewareMaker,
       Effect
         .all({
-          middleware: make.execute(makeRpcHandler<RequestContextMap, MiddlewareR>()),
+          middleware: make.execute((
+            cb: MakeRPCHandlerFactory<RequestContextMap, HttpRouter.HttpRouter.Provided | ContextProviderA>
+          ) => cb),
           contextProvider: make.contextProvider // uses the middleware.contextProvider tag to get the context provider service
         })
         .pipe(
           Effect.map(({ contextProvider, middleware }) => ({
             _tag: "MiddlewareMaker" as const,
-            effect: makeRpcEffect<RequestContextMap, MiddlewareR, ContextProviderA>()(
+            effect: makeRpcEffect<RequestContextMap, ContextProviderA>()(
               (schema, handler, moduleName) => {
                 const h = middleware(schema, handler, moduleName)
                 return (req, headers) =>
@@ -304,11 +365,11 @@ export const makeMiddleware =
         Layer.provide(make.contextProvider.Default)
       ) as Layer.Layer<
         MiddlewareMakerId,
-        | MakeMiddlewareE
-        | Layer.Error<typeof make.contextProvider.Default>,
-        | LayersUtils.GetLayersContext<MiddlewareDependencies>
-        | Exclude<MakeMiddlewareR, LayersUtils.GetLayersSuccess<MiddlewareDependencies>>
-        | Layer.Context<typeof make.contextProvider.Default>
+        | MakeMiddlewareE // what the middleware construction can fail with
+        | Layer.Error<typeof make.contextProvider.Default>, // what could go wrong when building the context provider
+        | LayersUtils.GetLayersContext<MiddlewareDependencies> // what's needed to build layers
+        | Exclude<MakeMiddlewareR, LayersUtils.GetLayersSuccess<MiddlewareDependencies>> // what layers provides
+        | Layer.Context<typeof make.contextProvider.Default> // what's needed to build the contextProvider
       >
 
     return Object.assign(MiddlewareMaker, { Default: middlewareLayer })
@@ -317,7 +378,6 @@ export const makeMiddleware =
 // it just provides the right types without cluttering the implementation with them
 function makeRpcEffect<
   RequestContextMap extends Record<string, RPCContextMap.Any>,
-  MiddlewareR,
   ContextProviderA
 >() {
   return (
@@ -345,11 +405,11 @@ function makeRpcEffect<
       Request.Request.Success<Req>,
       Request.Request.Error<Req> | RequestContextMapErrors<RequestContextMap>,
       | HttpRouter.HttpRouter.Provided // the context provider may require HttpRouter.Provided to run
-      | Exclude<MiddlewareR, ContextProviderA> // for sure ContextProviderA is provided, so it can be removed from the MiddlewareR\
       | Exclude<
+        // it can also be removed from HandlerR
         Exclude<HandlerR, GetEffectContext<RequestContextMap, (T & S.Schema<Req, any, never>)["config"]>>,
         ContextProviderA
-      > // it can also be removed from HandlerR
+      >
     >
   ) => cb
 }

package/src/api/routing.ts

@@ -137,8 +137,7 @@ type Match<
   Resource extends Record<string, any>,
   RequestContextMap extends Record<string, any>,
   RT extends RequestType,
-  Key extends keyof Resource,
-  MiddlewareR
+  Key extends keyof Resource
 > = {
   // note: the defaults of = never prevent the whole router to error (??)
   <A extends GetSuccessShape<Resource[Key], RT>, R2 = never, E = never>(
@@ -147,7 +146,7 @@ type Match<
     Resource[Key],
     RT,
     Exclude<
-      MiddlewareR | Exclude<R2, GetEffectContext<RequestContextMap, Resource[Key]["config"]>>,
+      Exclude<R2, GetEffectContext<RequestContextMap, Resource[Key]["config"]>>,
       HttpRouter.HttpRouter.Provided
     >
   >
@@ -158,7 +157,7 @@ type Match<
     Resource[Key],
     RT,
     Exclude<
-      MiddlewareR | Exclude<R2, GetEffectContext<RequestContextMap, Resource[Key]["config"]>>,
+      Exclude<R2, GetEffectContext<RequestContextMap, Resource[Key]["config"]>>,
       HttpRouter.HttpRouter.Provided
     >
   >
@@ -166,15 +165,14 @@ type Match<
 
 export type RouteMatcher<
   RequestContextMap extends Record<string, any>,
-  Resource extends Record<string, any>,
-  MiddlewareR
+  Resource extends Record<string, any>
 > = {
   // use Resource as Key over using Keys, so that the Go To on X.Action remain in tact in Controllers files
   /**
    * Requires the Type shape
    */
   [Key in keyof FilterRequestModules<Resource>]:
-    & Match<Resource, RequestContextMap, RequestTypes.DECODED, Key, MiddlewareR>
+    & Match<Resource, RequestContextMap, RequestTypes.DECODED, Key>
     & {
       success: Resource[Key]["success"]
       successRaw: S.SchemaClass<S.Schema.Encoded<Resource[Key]["success"]>>
@@ -182,21 +180,19 @@ export type RouteMatcher<
       /**
        * Requires the Encoded shape (e.g directly undecoded from DB, so that we don't do multiple Decode/Encode)
        */
-      raw: Match<Resource, RequestContextMap, RequestTypes.TYPE, Key, MiddlewareR>
+      raw: Match<Resource, RequestContextMap, RequestTypes.TYPE, Key>
     }
 }
 
 export class Router extends HttpRouter.Tag("@effect-app/Rpc")<Router>() {}
 
 export const makeRouter = <
-  MiddlewareR,
   RequestContextMap extends Record<string, RPCContextMap.Any>,
   MakeMiddlewareE,
   MakeMiddlewareR,
   ContextProviderA
 >(
   middleware: Middleware<
-    MiddlewareR,
     RequestContextMap,
     MakeMiddlewareE,
     MakeMiddlewareR,
@@ -323,7 +319,7 @@ export const makeRouter = <
         })
         return prev
       },
-      {} as RouteMatcher<RequestContextMap, Resource, MiddlewareR>
+      {} as RouteMatcher<RequestContextMap, Resource>
     )
 
     const router: AddAction<RequestModules[keyof RequestModules]> = {
@@ -347,8 +343,7 @@ export const makeRouter = <
         FilterRequestModules<Resource>[K],
         Impl[K] extends { raw: any } ? RequestTypes.TYPE : RequestTypes.DECODED,
         Exclude<
-          | MiddlewareR
-          | Exclude<
+          Exclude<
             // retrieves context R from the actual implementation of the handler
             Impl[K] extends { raw: any } ? Impl[K]["raw"] extends (...args: any[]) => Effect<any, any, infer R> ? R
               : Impl[K]["raw"] extends Effect<any, any, infer R> ? R
@@ -499,8 +494,7 @@ export const makeRouter = <
                 Effect.Success<ReturnType<THandlers[K]["handler"]>>,
                 | Effect.Error<ReturnType<THandlers[K]["handler"]>>
                 | GetEffectError<RequestContextMap, Resource[K]["config"]>,
-                | Exclude<MiddlewareR, ContextProviderA>
-                | Exclude<
+                Exclude<
                   Effect.Context<ReturnType<THandlers[K]["handler"]>>,
                   ContextProviderA | GetEffectContext<RequestContextMap, Resource[K]["config"]>
                 >
@@ -823,7 +817,7 @@ export const makeRouter = <
           RouterShape<Resource>,
           `${ModuleName}Router`,
           never,
-          Exclude<MiddlewareR, HttpRouter.HttpRouter.Provided>
+          never
         > // | Exclude<
         //   RPCRouteR<
         //     { [K in keyof Filter<Resource>]: Rpc.Rpc<Resource[K], Effect.Context<ReturnType<THandlers[K]["handler"]>>> }[keyof Filter<Resource>]

package/test/controller.test.ts

@@ -3,11 +3,11 @@
 import { type MakeContext, type MakeErrors, makeRouter } from "@effect-app/infra/api/routing"
 import type { RequestContext } from "@effect-app/infra/RequestContext"
 import { expectTypeOf } from "@effect/vitest"
-import { Console, Context, Effect, Layer, S } from "effect-app"
+import { Context, Effect, Layer, S } from "effect-app"
 import { type GetEffectContext, InvalidStateError, makeRpcClient, type RPCContextMap, UnauthorizedError } from "effect-app/client"
 import { HttpServerRequest } from "effect-app/http"
 import { Class, TaggedError } from "effect-app/Schema"
-import { ContextProvider, makeMiddleware, mergeContextProviders } from "../src/api/routing/DynamicMiddleware.js"
+import { ContextProvider, makeMiddleware, mergeContextProviders, MergedContextProvider } from "../src/api/routing/DynamicMiddleware.js"
 import { SomeService } from "./query.test.js"
 
 class UserProfile extends Context.assignTag<UserProfile, UserProfile>("UserProfile")(
@@ -21,19 +21,32 @@ class NotLoggedInError extends TaggedError<NotLoggedInError>()("NotLoggedInError
   message: S.String
 }) {}
 
+export class CustomError1 extends TaggedError<NotLoggedInError>()("CustomError1", {}) {}
+export class CustomError2 extends TaggedError<NotLoggedInError>()("CustomError1", {}) {}
+
 export interface CTX {
   context: RequestContext
 }
 
 export class Some extends Context.TagMakeId("Some", Effect.succeed({ a: 1 }))<Some>() {}
+export class SomeElse extends Context.TagMakeId("SomeElse", Effect.succeed({ b: 2 }))<SomeElse>() {}
 
 // @effect-diagnostics-next-line missingEffectServiceDependency:off
 const contextProvider = ContextProvider({
   effect: Effect.gen(function*() {
     yield* SomeService
+    if (Math.random() > 0.5) return yield* new CustomError1()
+
     return Effect.gen(function*() {
+      // the only requirements you can have are the one provided by HttpRouter.HttpRouter.Provided
       yield* HttpServerRequest.HttpServerRequest
-      // yield* Str2 // not allowed
+
+      // not allowed
+      // yield* SomeElse
+
+      // currently the effectful context provider cannot trigger an error when building the per request context
+      // if (Math.random() > 0.5) return yield* new CustomError2()
+
       return Context.make(Some, new Some({ a: 1 }))
     })
   })
@@ -43,9 +56,19 @@ const contextProvider = ContextProvider({
 class MyContextProvider extends Effect.Service<MyContextProvider>()("MyContextProvider", {
   effect: Effect.gen(function*() {
     yield* SomeService
+    if (Math.random() > 0.5) return yield* new CustomError1()
+
     return Effect.gen(function*() {
+      // the only requirements you can have are the one provided by HttpRouter.HttpRouter.Provided
       yield* HttpServerRequest.HttpServerRequest
-      // yield* Str2 // not allowed
+
+      // this is allowed here but mergeContextProviders/MergedContextProvider will trigger an error
+      // yield* SomeElse
+
+      // currently the effectful context provider cannot trigger an error when building the per request context
+      // this is allowed here but mergeContextProviders/MergedContextProvider will trigger an error
+      // if (Math.random() > 0.5) return yield* new CustomError2()
+
       return Context.make(Some, new Some({ a: 1 }))
     })
   })
@@ -53,6 +76,10 @@ class MyContextProvider extends Effect.Service<MyContextProvider>()("MyContextPr
 
 const merged = mergeContextProviders(MyContextProvider)
 export const contextProvider2 = ContextProvider(merged)
+export const contextProvider3 = MergedContextProvider(MyContextProvider)
+
+expectTypeOf(contextProvider2).toEqualTypeOf<typeof contextProvider>()
+expectTypeOf(contextProvider3).toEqualTypeOf<typeof contextProvider2>()
 
 export type RequestContextMap = {
   allowAnonymous: RPCContextMap.Inverted<"userProfile", UserProfile, typeof NotLoggedInError>
@@ -63,7 +90,7 @@ export type RequestContextMap = {
 const Str = Context.GenericTag<"str", "str">("str")
 const Str2 = Context.GenericTag<"str2", "str">("str2")
 
-const middleware = makeMiddleware<RequestContextMap, HttpServerRequest.HttpServerRequest>()({
+const middleware = makeMiddleware<RequestContextMap>()({
   dependencies: [Layer.effect(Str2, Str)],
   contextProvider,
   execute: (maker) =>
@@ -76,11 +103,12 @@ const middleware = makeMiddleware<RequestContextMap, HttpServerRequest.HttpServe
               Context.add(UserProfile, { id: "whatever" })
             )
 
-            // you can use only HttpServerRequest.HttpServerRequest here as additional context
-            // const some = yield* Some
+            // you can use only HttpRouter.HttpRouter.Provided here as additional context
+            // and what ContextMaker provides too
+            // const someElse = yield* SomeElse
 
-            const httpReq = yield* HttpServerRequest.HttpServerRequest
-            yield* Console.log("HttpServerRequest", httpReq)
+            yield* Some // provided by ContextMaker
+            yield* HttpServerRequest.HttpServerRequest // provided by HttpRouter.HttpRouter.Provided
 
             return yield* handler(req, headers).pipe(
               Effect.provide(ctx as Context.Context<GetEffectContext<RequestContextMap, (typeof _schema)["config"]>>)

package/test/dist/controller.test.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"controller.test.d.ts","sourceRoot":"","sources":["../controller.test.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,WAAW,EAAE,KAAK,UAAU,EAAc,MAAM,+BAA+B,CAAA;AAC7F,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAA;AAEtE,OAAO,EAAW,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,MAAM,YAAY,CAAA;AAC/D,OAAO,EAAE,KAAK,gBAAgB,EAAoC,KAAK,aAAa,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAA;AAClI,OAAO,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAA;AAGnD,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAA;;;;;;;;AAE7C,cAAM,WAAY,SAAQ,gBAIzB;CACA;;;;;;AAED,cAAM,gBAAiB,SAAQ,qBAE7B;CAAG;AAEL,MAAM,WAAW,GAAG;IAClB,OAAO,EAAE,cAAc,CAAA;CACxB;;;;;;;;;;;;;;;;;;;;;;;;;AAED,qBAAa,IAAK,SAAQ,SAA2D;CAAG;AA2BxF,eAAO,MAAM,gBAAgB;;CAA0B,CAAA;AAEvD,MAAM,MAAM,iBAAiB,GAAG;IAC9B,cAAc,EAAE,aAAa,CAAC,QAAQ,CAAC,aAAa,EAAE,WAAW,EAAE,OAAO,gBAAgB,CAAC,CAAA;IAE3F,YAAY,EAAE,aAAa,CAAC,MAAM,CAAC,EAAE,EAAE,KAAK,EAAE,OAAO,iBAAiB,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC,CAAA;CACvF,CAAA;AA+CD,MAAM,MAAM,aAAa,GAAG;IAC1B,yCAAyC;IACzC,cAAc,CAAC,EAAE,IAAI,CAAA;IACrB,iEAAiE;IACjE,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CAC/B,CAAA;AACD,eAAO,MAAuB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAG/B,CAAA;;;;;;;;;;AAEF,qBAAa,GAAI,SAAQ,QAA0C;CAAG;;;;;;;;;;AACtE,qBAAa,GAAI,SAAQ,QAA0C;CAAG;;;;;;;;;;;;AAEtE,qBAAa,WAAY,SAAQ,gBAEV;CAAG;;;;;;;;;;;;AAgB1B,qBAAa,YAAa,SAAQ,iBAET;CAAG;;;;;;;;;;;;AAE5B,qBAAa,aAAc,SAAQ,kBAEA;CAAG;;;;;AAItC,qBAAa,gBAAiB,SAAQ,qBAKpC;CAAG;;;;;AASL,qBAAa,aAAc,SAAQ,kBAOjC;CAAG;;;;;AAEL,qBAAa,iBAAkB,SAAQ,sBAKrC;CAAG;AAEL,eAAO,MAAQ,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAE,QAAQ;;;;;2HAAE,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qFAAiC,CAAA"}
+{"version":3,"file":"controller.test.d.ts","sourceRoot":"","sources":["../controller.test.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,WAAW,EAAE,KAAK,UAAU,EAAc,MAAM,+BAA+B,CAAA;AAC7F,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAA;AAEtE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,MAAM,YAAY,CAAA;AACtD,OAAO,EAAE,KAAK,gBAAgB,EAAoC,KAAK,aAAa,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAA;AAClI,OAAO,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAA;AAGnD,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAA;;;;;;;;AAE7C,cAAM,WAAY,SAAQ,gBAIzB;CACA;;;;;;AAED,cAAM,gBAAiB,SAAQ,qBAE7B;CAAG;;;;AAEL,qBAAa,YAAa,SAAQ,iBAAmD;CAAG;;;;AACxF,qBAAa,YAAa,SAAQ,iBAAmD;CAAG;AAExF,MAAM,WAAW,GAAG;IAClB,OAAO,EAAE,cAAc,CAAA;CACxB;;;;;;;;;;;;;;;;;;;;;;;;;AAED,qBAAa,IAAK,SAAQ,SAA2D;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;AACxF,qBAAa,QAAS,SAAQ,aAAmE;CAAG;AA8CpG,eAAO,MAAM,gBAAgB;;CAA0B,CAAA;AACvD,eAAO,MAAM,gBAAgB;;CAA2C,CAAA;AAKxE,MAAM,MAAM,iBAAiB,GAAG;IAC9B,cAAc,EAAE,aAAa,CAAC,QAAQ,CAAC,aAAa,EAAE,WAAW,EAAE,OAAO,gBAAgB,CAAC,CAAA;IAE3F,YAAY,EAAE,aAAa,CAAC,MAAM,CAAC,EAAE,EAAE,KAAK,EAAE,OAAO,iBAAiB,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC,CAAA;CACvF,CAAA;AAgDD,MAAM,MAAM,aAAa,GAAG;IAC1B,yCAAyC;IACzC,cAAc,CAAC,EAAE,IAAI,CAAA;IACrB,iEAAiE;IACjE,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CAC/B,CAAA;AACD,eAAO,MAAuB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAG/B,CAAA;;;;;;;;;;AAEF,qBAAa,GAAI,SAAQ,QAA0C;CAAG;;;;;;;;;;AACtE,qBAAa,GAAI,SAAQ,QAA0C;CAAG;;;;;;;;;;;;AAEtE,qBAAa,WAAY,SAAQ,gBAEV;CAAG;;;;;;;;;;;;AAgB1B,qBAAa,YAAa,SAAQ,iBAET;CAAG;;;;;;;;;;;;AAE5B,qBAAa,aAAc,SAAQ,kBAEA;CAAG;;;;;AAItC,qBAAa,gBAAiB,SAAQ,qBAKpC;CAAG;;;;;AASL,qBAAa,aAAc,SAAQ,kBAOjC;CAAG;;;;;AAEL,qBAAa,iBAAkB,SAAQ,sBAKrC;CAAG;AAEL,eAAO,MAAQ,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAE,QAAQ;;;;;2HAAE,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qFAAiC,CAAA"}

package/test/dist/controller/test2.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"test2.test.d.ts","sourceRoot":"","sources":["../../controller/test2.test.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,WAAW,EAAE,KAAK,UAAU,EAA8B,MAAM,+BAA+B,CAAA;AAC7G,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAA;AAEtE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAY,MAAM,YAAY,CAAA;AAChE,OAAO,EAAE,KAAK,gBAAgB,EAAoC,KAAK,aAAa,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAA;AAClI,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,iBAAiB,CAAA;AAGxD,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;;;;;;;;AAE9C,cAAM,WAAY,SAAQ,gBAIzB;CACA;;;;;;AAED,cAAM,gBAAiB,SAAQ,qBAE7B;CAAG;AAKL,MAAM,WAAW,GAAG;IAClB,OAAO,EAAE,cAAc,CAAA;CACxB;;;;;;;;;;;;;;;;;;;;;;;;;AAED,qBAAa,IAAK,SAAQ,SAA2D;CAAG;;;;;AAExF,qBAAa,YAAa,SAAQ,iBAQhC;CAAG;AAEL,MAAM,MAAM,MAAM,GAAG;IACnB,cAAc,EAAE,aAAa,CAAC,QAAQ,CAAC,aAAa,EAAE,WAAW,EAAE,OAAO,gBAAgB,CAAC,CAAA;IAE3F,YAAY,EAAE,aAAa,CAAC,MAAM,CAAC,EAAE,EAAE,KAAK,EAAE,OAAO,iBAAiB,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC,CAAA;CACvF,CAAA;AAsGD,MAAM,MAAM,aAAa,GAAG;IAC1B,yCAAyC;IACzC,cAAc,CAAC,EAAE,IAAI,CAAA;IACrB,iEAAiE;IACjE,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CAC/B,CAAA;AACD,eAAO,MAAuB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAG/B,CAAA;;;;;;;;;;AAEF,qBAAa,GAAI,SAAQ,QAA0C;CAAG;;;;;;;;;;AACtE,qBAAa,GAAI,SAAQ,QAA0C;CAAG;;;;;;;;;;;;AAEtE,qBAAa,WAAY,SAAQ,gBAEV;CAAG;;;;;;;;;;;;AAE1B,qBAAa,YAAa,SAAQ,iBAET;CAAG;;;;;;;;;;;;AAE5B,qBAAa,aAAc,SAAQ,kBAEA;CAAG;;;;;AAItC,qBAAa,gBAAiB,SAAQ,qBAKpC;CAAG;;;;;AASL,qBAAa,aAAc,SAAQ,kBAOjC;CAAG;;;;;AAEL,qBAAa,iBAAkB,SAAQ,sBAKrC;CAAG;AAEL,eAAO,MAAQ,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAE,QAAQ;;;;;2HAAE,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qFAAiC,CAAA"}

package/test/dist/controller.legacy2.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"controller.legacy2.test.d.ts","sourceRoot":"","sources":["../controller.legacy2.test.ts"],"names":[],"mappings":"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"}

package/test/dist/controller.legacy3.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"controller.legacy3.test.d.ts","sourceRoot":"","sources":["../controller.legacy3.test.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAA;AACtE,OAAO,EAAE,GAAG,EAAE,MAAM,aAAa,CAAA;AAEjC,OAAO,EAAW,MAAM,EAAY,KAAK,EAAE,CAAC,EAAY,MAAM,YAAY,CAAA;AAC1E,OAAO,EAAwC,KAAK,aAAa,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAA;AAC/G,OAAO,EAAe,iBAAiB,EAAE,MAAM,iBAAiB,CAAA;AAOhE,MAAM,WAAW,GAAG;IAClB,OAAO,EAAE,cAAc,CAAA;CACxB;AAED,MAAM,MAAM,MAAM,GAAG;IAGnB,YAAY,EAAE,aAAa,CAAC,MAAM,CAAC,EAAE,EAAE,KAAK,EAAE,OAAO,iBAAiB,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC,CAAA;CACvF,CAAA;AAmGD,eAAO,MAAQ,QAAQ;;;;;gBA0EgwD,MAAO,KAAK;;;;;;GA1E1wD,QAAQ;;;;;;iDA0Eq0F,MAAM,KAAK,CAAC,GAAG;;;;;;;;;;;;iDAAg1D,MAAM,KAAK,CAAC,GAAG;;;;;;;;;;;;iDAAg1D,MAAM,KAAK,CAAC,GAAG;;;;;;;;;;;;iDAAg1D,MAAM,KAAK,CAAC,GAAG;;;;;;;;;;;;iDAA2yD,MAAM,KAAK,CAAC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;CA1E1oU,CAAA;AAElE,MAAM,MAAM,aAAa,GAAG;IAC1B,yCAAyC;IACzC,cAAc,CAAC,EAAE,IAAI,CAAA;IACrB,iEAAiE;IACjE,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CAC/B,CAAA;AACD,eAAO,MAAuB,GAAG;yCAxEL,EAAG,MAAM,CAAC,MAAM;iBAgClC,EA/BK,MACb,CA8BQ,GA9BJ,GA8BI,EA9BC,MAEV,CA4BS,MA5BF;iBAAuB,EAAE,MAC9B,CA2BO,GA3BH,GA2BG,EA3BG,MAAK,CAAC,MAAM;;;;;;2CASkB,EAAG,MAAM,CAAC,MAAM;iBAkBjD,EAAA,MAjBA,CAAC,GAAG,GAAE,EAAG,MAAM,CAAC,MAAM;;;;;;2CAiBtB,EAPO,MAAC,CAAC,MAAM;iBACA,EAAG,MAAM,CAAC,GAAG,GAAE,EAAG,MAAM,CAAC,MAAM;;;;;;2CAc1C,EAAA,MAAL,CAAK,MAAE;;;;;2CAMqC,EAAG,MAAM,CAAC,MAAM;;;;;CA6BnE,CAAA;;;;;;;;;;AAEF,qBAAa,YAAa,SAAQ,iBAEX;CAAG;;;;;;;;;;AAE1B,qBAAa,gBAAiB,SAAQ,qBAEb;CAAG;;;;;AAI5B,qBAAa,gBAAiB,SAAQ,qBAKpC;CAAG;;;;;AASL,qBAAa,aAAc,SAAQ,kBAOjC;CAAG;;;;;AAEL,qBAAa,iBAAkB,SAAQ,sBAKrC;CAAG"}