@effect-app/infra 2.88.0 → 2.89.0

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

@@ -1,38 +1,41 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { type Rpc, type RpcMiddleware } from "@effect/rpc"
-import { type SuccessValue } from "@effect/rpc/RpcMiddleware"
-import { type Array, Context, Effect, type Layer, type NonEmptyReadonlyArray, Option, type Scope } from "effect-app"
+import { type RpcMiddleware } from "@effect/rpc"
+import { Context, Effect, type Layer, type NonEmptyReadonlyArray, Option, type S, type Scope } from "effect-app"
 import { type ContextTagArray } from "effect-app/client"
-import { type HttpHeaders } from "effect-app/http"
 import { InfraLogger } from "../../../logger.js"
-import { type TagClassAny } from "./RpcMiddleware.js"
+import { type RpcMiddlewareWrap, type TagClassAny } from "./RpcMiddleware.js"
 
 // Effect rpc middleware does not support changing payload or headers, but we do..
 
-// it's like an Effect/rpc wrap middleware, but with fixed R to Scope.Scope
-export interface GenericMiddlewareOptions<E> {
-  readonly clientId: number
-  readonly rpc: Rpc.AnyWithProps
-  readonly payload: unknown
-  readonly headers: HttpHeaders.Headers
-  readonly next: Effect.Effect<SuccessValue, E, Scope.Scope>
-}
-
-export type GenericMiddlewareMaker = TagClassAny & { Default: Layer.Layer.Any } // todo; and Layer..
+export type MiddlewareMaker = TagClassAny & { Default: Layer.Layer.Any } // todo; and Layer..
 
-export namespace GenericMiddlewareMaker {
+export namespace MiddlewareMaker {
   export type ApplyServices<A extends TagClassAny, R> = Exclude<R, Provided<A>> | Required<A>
 
   export type ApplyManyServices<A extends NonEmptyReadonlyArray<TagClassAny>, R> =
     | Exclude<R, { [K in keyof A]: Provided<A[K]> }[number]>
     | { [K in keyof A]: Required<A[K]> }[number]
 
+  export type ManyProvided<A extends ReadonlyArray<TagClassAny>> = A extends NonEmptyReadonlyArray<TagClassAny>
+    ? { [K in keyof A]: Provided<A[K]> }[number]
+    : Provided<A[number]>
+  export type ManyRequired<A extends ReadonlyArray<TagClassAny>> = A extends NonEmptyReadonlyArray<TagClassAny>
+    ? { [K in keyof A]: Required<A[K]> }[number]
+    : Required<A[number]>
+  export type ManyErrors<A extends ReadonlyArray<TagClassAny>> = A extends NonEmptyReadonlyArray<TagClassAny>
+    ? { [K in keyof A]: Errors<A[K]> }[number]
+    : Errors<A[number]>
+
   export type Provided<T> = T extends TagClassAny
     ? T extends { provides: Context.Tag<any, any> } ? Context.Tag.Identifier<T["provides"]>
     : T extends { provides: ContextTagArray } ? ContextTagArray.Identifier<T["provides"]>
     : never
     : never
 
+  export type Errors<T> = T extends TagClassAny ? T extends { failure: S.Schema.Any } ? S.Schema.Type<T["failure"]>
+    : never
+    : never
+
   export type Required<T> = T extends TagClassAny
     ? T extends { requires: Context.Tag<any, any> } ? Context.Tag.Identifier<T["requires"]>
     : T extends { requires: ContextTagArray } ? ContextTagArray.Identifier<T["requires"]>
@@ -40,11 +43,21 @@ export namespace GenericMiddlewareMaker {
     : never
 }
 
-export const genericMiddlewareMaker = <
-  T extends Array<GenericMiddlewareMaker>
->(...middlewares: T): {
-  dependencies: { [K in keyof T]: T[K]["Default"] }
-  effect: Effect.Effect<RpcMiddleware.RpcMiddlewareWrap<any, any>>
+export const middlewareMaker = <
+  MiddlewareProviders extends ReadonlyArray<MiddlewareMaker>
+>(middlewares: MiddlewareProviders): {
+  dependencies: { [K in keyof MiddlewareProviders]: MiddlewareProviders[K]["Default"] }
+  effect: Effect.Effect<
+    RpcMiddlewareWrap<
+      MiddlewareMaker.ManyProvided<MiddlewareProviders>,
+      MiddlewareMaker.ManyErrors<MiddlewareProviders>,
+      Exclude<
+        MiddlewareMaker.ManyRequired<MiddlewareProviders>,
+        MiddlewareMaker.ManyProvided<MiddlewareProviders>
+      > extends never ? never
+        : Exclude<MiddlewareMaker.ManyRequired<MiddlewareProviders>, MiddlewareMaker.ManyProvided<MiddlewareProviders>>
+    >
+  >
 } => {
   // we want to run them in reverse order because latter middlewares will provide context to former ones
   middlewares = middlewares.toReversed() as any
@@ -55,8 +68,14 @@ export const genericMiddlewareMaker = <
       const context = yield* Effect.context()
 
       // returns a Effect/RpcMiddlewareWrap with Scope in requirements
-      return <E>(
-        options: GenericMiddlewareOptions<E>
+      return (
+        options: Parameters<
+          RpcMiddlewareWrap<
+            MiddlewareMaker.ManyProvided<MiddlewareProviders>,
+            never,
+            Scope.Scope
+          >
+        >[0]
       ) => {
         // we start with the actual handler
         let handler = options.next
@@ -113,7 +132,7 @@ export const genericMiddlewareMaker = <
                   )
                 )
               )
-            )
+            ) as any
           } else {
             // use the tag to get the middleware from context
             const middleware = Context.unsafeGet(context, tag) as RpcMiddleware.RpcMiddleware<any, any>
@@ -134,10 +153,9 @@ export const genericMiddlewareMaker = <
                   )
                   : Effect.zipRight(middleware(options), previous)
               )
-            )
+            ) as any
           }
         }
-
         return handler
       }
     })

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

@@ -1,12 +1,11 @@
-import { Rpc } from "@effect/rpc"
-import { Context, Effect, Layer, type NonEmptyArray, type NonEmptyReadonlyArray } from "effect-app"
-import { type RPCContextMap } from "effect-app/client"
-import { type LayerUtils } from "../../layerUtils.js"
-import { type GenericMiddlewareMaker, genericMiddlewareMaker } from "./generic-middleware.js"
-import { makeRpcEffect, type RPCHandlerFactory } from "./RouterMiddleware.js"
-import { type AnyDynamic, type RpcDynamic, type TagClassAny } from "./RpcMiddleware.js"
-
-// adapter used when setting the dynamic prop on a middleware implementation
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { type AnyWithProps } from "@effect/rpc/Rpc"
+import { Context, type Effect, type NonEmptyArray, type NonEmptyReadonlyArray, S } from "effect-app"
+import { type GetContextConfig, type RPCContextMap } from "effect-app/client"
+import { type MiddlewareMaker, middlewareMaker } from "./generic-middleware.js"
+import { type AnyDynamic, type RpcDynamic, Tag, type TagClassAny } from "./RpcMiddleware.js"
+
+/** Adapter used when setting the dynamic prop on a middleware implementation */
 export const contextMap = <
   RequestContextMap extends Record<string, RPCContextMap.Any>,
   Key extends (keyof RequestContextMap) & string
@@ -15,19 +14,26 @@ export const contextMap = <
   settings: { service: rcm[key]!["service"] } as RequestContextMap[Key]
 })
 
+/** Retrieves RequestContextConfig out of the RPC annotations */
+export const getConfig = <
+  RequestContextMap extends Record<string, RPCContextMap.Any>
+>() =>
+(rpc: AnyWithProps): GetContextConfig<RequestContextMap> => {
+  return Context.unsafeGet(rpc.annotations, Context.GenericTag("RequestContextConfig"))
+}
+
 // the following implements sort of builder pattern
 // we support both sideways and upwards elimination of dependencies
 
 // it's for dynamic middlewares
-type GetDependsOnKeys<MW extends GenericMiddlewareMaker> = MW extends { dependsOn: NonEmptyReadonlyArray<TagClassAny> }
-  ? {
+type GetDependsOnKeys<MW extends MiddlewareMaker> = MW extends { dependsOn: NonEmptyReadonlyArray<TagClassAny> } ? {
     [K in keyof MW["dependsOn"]]: MW["dependsOn"][K] extends AnyDynamic ? MW["dependsOn"][K]["dynamic"]["key"]
       : never
   }[keyof MW["dependsOn"]]
   : never
 
 type FilterInDynamicMiddlewares<
-  MWs extends ReadonlyArray<GenericMiddlewareMaker>,
+  MWs extends ReadonlyArray<MiddlewareMaker>,
   RequestContextMap extends Record<string, RPCContextMap.Any>
 > = {
   [K in keyof MWs]: MWs[K] extends { dynamic: RpcDynamic<any, RequestContextMap[keyof RequestContextMap]> } ? MWs[K]
@@ -39,13 +45,13 @@ type RecursiveHandleMWsSideways<
   R extends {
     rcm: Record<string, RPCContextMap.Any>
     provided: keyof R["rcm"] // that's fine
-    middlewares: ReadonlyArray<GenericMiddlewareMaker>
+    middlewares: ReadonlyArray<MiddlewareMaker>
     dmp: any
     middlewareR: any
   }
 > = MWs extends [
-  infer F extends GenericMiddlewareMaker,
-  ...infer Rest extends ReadonlyArray<GenericMiddlewareMaker>
+  infer F extends MiddlewareMaker,
+  ...infer Rest extends ReadonlyArray<MiddlewareMaker>
 ] ? RecursiveHandleMWsSideways<Rest, {
     rcm: R["rcm"]
     // when one dynamic middleware depends on another, subtract the key to enforce the dependency to be provided after
@@ -62,18 +68,18 @@ type RecursiveHandleMWsSideways<
         & {
           [U in FilterInDynamicMiddlewares<[F], R["rcm"]>[number] as U["dynamic"]["key"]]: U
         }
-    middlewareR: GenericMiddlewareMaker.ApplyManyServices<[F], R["middlewareR"]>
+    middlewareR: MiddlewareMaker.ApplyManyServices<[F], R["middlewareR"]>
   }>
   : R
 
 export interface BuildingMiddleware<
   RequestContextMap extends Record<string, RPCContextMap.Any>,
   Provided extends keyof RequestContextMap,
-  Middlewares extends ReadonlyArray<GenericMiddlewareMaker>,
+  Middlewares extends ReadonlyArray<MiddlewareMaker>,
   DynamicMiddlewareProviders,
   out MiddlewareR extends { _tag: string } = never
 > {
-  middleware<MWs extends NonEmptyArray<GenericMiddlewareMaker>>(
+  middleware<MWs extends NonEmptyArray<MiddlewareMaker>>(
     ...mw: MWs
   ): RecursiveHandleMWsSideways<MWs, {
     rcm: RequestContextMap
@@ -84,7 +90,7 @@ export interface BuildingMiddleware<
   }> extends infer Res extends {
     rcm: RequestContextMap
     provided: keyof RequestContextMap
-    middlewares: ReadonlyArray<GenericMiddlewareMaker>
+    middlewares: ReadonlyArray<MiddlewareMaker>
     dmp: any
     middlewareR: any
   } ? MiddlewaresBuilder<
@@ -106,7 +112,7 @@ export interface BuildingMiddleware<
 export type MiddlewaresBuilder<
   RequestContextMap extends Record<string, RPCContextMap.Any>,
   Provided extends keyof RequestContextMap = never,
-  Middlewares extends ReadonlyArray<GenericMiddlewareMaker> = [],
+  Middlewares extends ReadonlyArray<MiddlewareMaker> = [],
   DynamicMiddlewareProviders = unknown,
   MiddlewareR extends { _tag: string } = never
 > =
@@ -136,7 +142,7 @@ export type MiddlewaresBuilder<
 export const makeMiddleware: <
   RequestContextMap extends Record<string, RPCContextMap.Any>
 >(rcm: RequestContextMap) => MiddlewaresBuilder<RequestContextMap> = (rcm) => {
-  let allMiddleware: GenericMiddlewareMaker[] = []
+  let allMiddleware: MiddlewareMaker[] = []
   const it = {
     middleware: (...middlewares: any[]) => {
       for (const mw of middlewares) {
@@ -154,92 +160,71 @@ export const makeMiddleware: <
 }
 
 //
-export const MiddlewareMakerTag = "MiddlewareMaker" as const
-
-export interface MiddlewareMaker<E> {
-  readonly effect: E
-  readonly _tag: typeof MiddlewareMakerTag
+export interface MiddlewareMakerId {
+  readonly _id: unique symbol
 }
 
-export type MiddlewareMakerId = Pick<MiddlewareMaker<any>, "_tag">
-
-export const buildMiddlewareMaker = <E>(eff: E) =>
-  ({
-    _tag: MiddlewareMakerTag,
-    effect: eff
-  }) satisfies MiddlewareMaker<E>
+// TODO: actually end up with [Tag<A, A>, Tag<B, B>, ...]
+type MakeTags<A> = Context.Tag<A, A>
 
 const makeMiddlewareBasic =
   // by setting RequestContextMap beforehand, execute contextual typing does not fuck up itself to anys
   <
     RequestContextMap extends Record<string, RPCContextMap.Any>,
-    GenericMiddlewareProviders extends ReadonlyArray<GenericMiddlewareMaker>
+    MiddlewareProviders extends ReadonlyArray<MiddlewareMaker>
   >(
     _rcm: RequestContextMap,
-    ...make: GenericMiddlewareProviders
+    ...make: MiddlewareProviders
   ) => {
-    const MiddlewareMaker = Context.GenericTag<
-      MiddlewareMakerId,
-      MiddlewareMaker<
-        RPCHandlerFactory<
-          RequestContextMap,
-          GenericMiddlewareMaker.Provided<GenericMiddlewareProviders[number]>
-        >
-      >
-    >(
-      MiddlewareMakerTag
-    )
-
     // reverse middlewares and wrap one after the other
-    const middlewares = genericMiddlewareMaker(...make)
-
-    const l = Layer.scoped(
-      MiddlewareMaker,
-      middlewares
-        .effect
-        .pipe(
-          Effect.map((generic) => (buildMiddlewareMaker(
-            makeRpcEffect<
-              RequestContextMap,
-              GenericMiddlewareMaker.Provided<GenericMiddlewareProviders[number]>
-            >()(
-              (schema, handler, moduleName) => {
-                return (payload, headers) =>
-                  Effect
-                    .gen(function*() {
-                      // will be propagated to all the wrapped middlewares
-                      const basic = {
-                        config: schema.config ?? {},
-                        payload,
-                        headers,
-                        clientId: 0, // TODO: get the clientId from the request context
-                        rpc: {
-                          ...Rpc.fromTaggedRequest(schema as any),
-                          key: `${moduleName}.${payload._tag}`,
-                          _tag: `${moduleName}.${payload._tag}`
-                        }
-                      }
-                      return yield* generic({
-                        ...basic,
-                        next: handler(payload, headers) as any
-                      })
-                    }) as any // why? because: Type 'SuccessValue' is not assignable to type 'Success<Req>' :P
-              }
-            )
-          )))
-        )
+    const middleware = middlewareMaker(make)
+
+    const failures = make.map((_) => _.failure).filter(Boolean)
+    const provides = make.flatMap((_) => !_.provides ? [] : Array.isArray(_.provides) ? _.provides : [_.provides])
+    const requires = make
+      .flatMap((_) => !_.requires ? [] : Array.isArray(_.requires) ? _.requires : [_.requires])
+      .filter((_) => !provides.includes(_))
+
+    const MiddlewareMaker = Tag<MiddlewareMakerId>()("MiddlewareMaker", {
+      failure: (failures.length > 0
+        ? S.Union(...failures)
+        : S.Never) as unknown as MiddlewareMaker.ManyErrors<MiddlewareProviders> extends never ? never
+          : S.Schema<MiddlewareMaker.ManyErrors<MiddlewareProviders>>,
+      requires: (requires.length > 0
+        ? requires
+        : undefined) as unknown as Exclude<
+          MiddlewareMaker.ManyRequired<MiddlewareProviders>,
+          MiddlewareMaker.ManyProvided<MiddlewareProviders>
+        > extends never ? never : [
+          MakeTags<
+            Exclude<
+              MiddlewareMaker.ManyRequired<MiddlewareProviders>,
+              MiddlewareMaker.ManyProvided<MiddlewareProviders>
+            >
+          >
+        ],
+      provides: (provides.length > 0
+        ? provides
+        : undefined) as unknown as MiddlewareMaker.ManyProvided<MiddlewareProviders> extends never ? never : [
+          MakeTags<MiddlewareMaker.ManyProvided<MiddlewareProviders>>
+        ],
+      wrap: true
+    })(
+      middleware as {
+        dependencies: typeof middleware["dependencies"]
+        effect: Effect<
+          any, // TODO: why ?
+          Effect.Error<typeof middleware["effect"]>,
+          Effect.Context<typeof middleware["effect"]>
+        >
+      }
     )
 
-    const middlewareLayer = l
-      .pipe(
-        Layer.provide(middlewares.dependencies as any)
-      ) as Layer.Layer<
-        MiddlewareMakerId,
-        // what could go wrong when building the dynamic middleware provider
-        LayerUtils.GetLayersError<typeof middlewares.dependencies>,
-        LayerUtils.GetLayersContext<typeof middlewares.dependencies>
-      >
-
     // add to the tag a default implementation
-    return Object.assign(MiddlewareMaker, { Default: middlewareLayer })
+    return Object.assign(MiddlewareMaker, {
+      // tag to be used to retrieve the RequestContextConfig from RPC annotations
+      requestContext: Context.GenericTag<"RequestContextConfig", GetContextConfig<RequestContextMap>>(
+        "RequestContextConfig"
+      )
+    })
   }

package/src/api/routing/middleware.ts

@@ -1,5 +1,4 @@
 // codegen:start {preset: barrel, include: ./middleware/*.ts, nodir: false }
-export * from "./middleware/ContextProvider.js"
 export * from "./middleware/dynamic-middleware.js"
 export * from "./middleware/generic-middleware.js"
 export * from "./middleware/middleware-api.js"

package/src/api/routing.ts

@@ -167,13 +167,17 @@ export const makeRouter = <
   RequestContextMap extends Record<string, RPCContextMap.Any>,
   MakeMiddlewareE,
   MakeMiddlewareR,
-  ContextProviderA
+  ContextProviderA,
+  ContextProviderE,
+  ContextProviderR
 >(
   middleware: RouterMiddleware<
     RequestContextMap,
     MakeMiddlewareE,
     MakeMiddlewareR,
-    ContextProviderA
+    ContextProviderA,
+    ContextProviderE,
+    ContextProviderR
   >,
   devMode: boolean
 ) => {
@@ -370,7 +374,6 @@ export const makeRouter = <
             : make
 
           const controllers = yield* make
-          const rpc = yield* middleware
 
           // return make.pipe(Effect.map((c) => controllers(c, dependencies)))
           const mapped = typedKeysOf(requestModules).reduce((acc, cur) => {
@@ -400,16 +403,12 @@ export const makeRouter = <
                   }
                 } as any
                 : resource,
-              rpc.effect(
-                resource,
-                (req, headers) =>
-                  handle(req, headers).pipe(
-                    Effect.withSpan("Request." + meta.moduleName + "." + resource._tag, {
-                      captureStackTrace: () => handler.stack
-                    })
-                  ),
-                meta.moduleName
-              ),
+              (payload: any, headers: any) =>
+                handle(payload, headers).pipe(
+                  Effect.withSpan("Request." + resource._tag, {
+                    captureStackTrace: () => handler.stack // capturing the handler stack is the main reason why we are doing the span here
+                  })
+                ),
               meta.moduleName
             ] as const
             return acc
@@ -431,16 +430,19 @@ export const makeRouter = <
             ]
           }
 
-          const rpcs = RpcGroup.make(
-            ...typedValuesOf(mapped).map(([resource]) => {
-              return Rpc.fromTaggedRequest(resource)
-            })
-          )
+          const rpcs = RpcGroup
+            .make(
+              ...typedValuesOf(mapped).map(([resource]) => {
+                return Rpc.fromTaggedRequest(resource).annotate(middleware.requestContext, resource.config ?? {})
+              })
+            )
+            .prefix(`${meta.moduleName}.`)
+            .middleware(middleware as any)
           const rpcLayer = rpcs.toLayer(Effect.gen(function*() {
             return typedValuesOf(mapped).reduce((acc, [resource, handler]) => {
-              acc[resource._tag] = handler
+              acc[`${meta.moduleName}.${resource._tag}`] = handler
               return acc
-            }, {} as Record<string, any>)
+            }, {} as Record<string, any>) as any // TODO
           })) as unknown as Layer<
             { [K in keyof RequestModules]: Rpc.Handler<K> },
             | Layer.Error<typeof middleware.Default>

package/test/contextProvider.test.ts

@@ -2,7 +2,7 @@
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
 import { expectTypeOf, it } from "@effect/vitest"
 import { Context, Effect, Scope } from "effect-app"
-import { ContextProvider, mergeContextProviders, MergedContextProvider } from "../src/api/routing.js"
+import { ContextProvider, mergeContextProviders, MergedContextProvider } from "../src/api/ContextProvider.js"
 import { CustomError1, Some, SomeElse, SomeService } from "./fixtures.js"
 
 // @effect-diagnostics-next-line missingEffectServiceDependency:off

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

@@ -1 +1 @@
-{"version":3,"file":"fixtures.d.ts","sourceRoot":"","sources":["../fixtures.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAU,CAAC,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAC9D,OAAO,EAAE,gBAAgB,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAA;AAEtF,OAAO,EAAc,UAAU,EAAE,MAAM,uBAAuB,CAAA;;;;;;;;;;;;;AAE9D,qBAAa,WAAY,SAAQ,gBAKhC;CACA;;;;;;;;;;;;;;;;;;;;;;;;;AAED,qBAAa,IAAK,SAAQ,SAA2D;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;AACxF,qBAAa,QAAS,SAAQ,aAAmE;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;AAEpG,qBAAa,WAAY,SAAQ,gBAAgE;CAAG;AAOpG,eAAO,MAAM,iBAAiB;;;;CAIpB,CAAA;AAEV,KAAK,kBAAkB,GAAG,OAAO,iBAAiB,CAAA;AAClD,MAAM,WAAW,iBAAkB,SAAQ,kBAAkB;CAAG;;;;;;;AAEhE,qBAAa,cAAe,SAAQ,mBA4BlC;CACD;;;;;;;;AAID,qBAAa,YAAa,SAAQ,iBA6BhC;CACD;;;;;;;AAGD,qBAAa,IAAK,SAAQ,SASxB;CAAG;;;;AAEL,qBAAa,YAAa,SAAQ,iBAAmD;CAAG;;;;AACxF,qBAAa,YAAa,SAAQ,iBAAmD;CAAG"}
+{"version":3,"file":"fixtures.d.ts","sourceRoot":"","sources":["../fixtures.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAU,CAAC,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAC9D,OAAO,EAAE,gBAAgB,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAA;AAEtF,OAAO,EAAyB,UAAU,EAAE,MAAM,uBAAuB,CAAA;;;;;;;;;;;;;AAEzE,qBAAa,WAAY,SAAQ,gBAKhC;CACA;;;;;;;;;;;;;;;;;;;;;;;;;AAED,qBAAa,IAAK,SAAQ,SAA2D;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;AACxF,qBAAa,QAAS,SAAQ,aAAmE;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;AAEpG,qBAAa,WAAY,SAAQ,gBAAgE;CAAG;AASpG,eAAO,MAAM,iBAAiB;;;;CAIpB,CAAA;AAEV,KAAK,kBAAkB,GAAG,OAAO,iBAAiB,CAAA;AAClD,MAAM,WAAW,iBAAkB,SAAQ,kBAAkB;CAAG;;;;;;;AAEhE,qBAAa,cAAe,SAAQ,mBA4BlC;CACD;;;;;;;;AAID,qBAAa,YAAa,SAAQ,iBA6BhC;CACD;;;;;;;AAGD,qBAAa,IAAK,SAAQ,SASxB;CAAG;;;;AAEL,qBAAa,YAAa,SAAQ,iBAAmD;CAAG;;;;AACxF,qBAAa,YAAa,SAAQ,iBAAmD;CAAG"}

package/test/dist/fixtures.js

@@ -1,7 +1,7 @@
 import { Context, Effect, Option, S, Scope } from "effect-app";
 import { NotLoggedInError, RPCContextMap, UnauthorizedError } from "effect-app/client";
 import { TaggedError } from "effect-app/Schema";
-import { contextMap, Middleware } from "../src/api/routing.js";
+import { contextMap, getConfig, Middleware } from "../src/api/routing.js";
 export class UserProfile extends Context.assignTag("UserProfile")(S.Class("UserProfile")({
     id: S.String,
     roles: S.Array(S.String)
@@ -14,6 +14,7 @@ export class SomeElse extends Context.TagMakeId("SomeElse", Effect.succeed({ b:
 const MakeSomeService = Effect.succeed({ a: 1 });
 export class SomeService extends Context.TagMakeId("SomeService", MakeSomeService)() {
 }
+const requestConfig = getConfig();
 // TODO: null as never sucks
 // why [UserProfile] is needed? AllowAnonymous triggers an error if just UserProfile without []
 // [] requires return Context, non [] requires return the Service instance
@@ -29,12 +30,12 @@ export class AllowAnonymous extends Middleware.Tag()("AllowAnonymous", {
     requires: SomeElse
 })({
     effect: Effect.gen(function* () {
-        return Effect.fnUntraced(function* ({ config, headers }) {
+        return Effect.fnUntraced(function* ({ headers, rpc }) {
             yield* SomeElse;
             yield* Scope.Scope; // provided by HttpRouter.HttpRouter.Provided
             const isLoggedIn = !!headers["x-user"];
             if (!isLoggedIn) {
-                if (!config.allowAnonymous) {
+                if (!requestConfig(rpc).allowAnonymous) {
                     return yield* new NotLoggedInError({ message: "Not logged in" });
                 }
                 return Option.none();
@@ -59,10 +60,10 @@ export class RequireRoles extends Middleware.Tag()("RequireRoles", {
 })({
     effect: Effect.gen(function* () {
         yield* SomeService;
-        return Effect.fnUntraced(function* ({ config, next }) {
+        return Effect.fnUntraced(function* ({ next, rpc }) {
             // we don't know if the service will be provided or not, so we use option..
             const userProfile = yield* Effect.serviceOption(UserProfile);
-            const { requireRoles } = config;
+            const { requireRoles } = requestConfig(rpc);
             console.dir({
                 userProfile,
                 requireRoles
@@ -91,4 +92,4 @@ export class CustomError1 extends TaggedError()("CustomError1", {}) {
 }
 export class CustomError2 extends TaggedError()("CustomError1", {}) {
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1 +1 @@
-{"version":3,"file":"requires.test.d.ts","sourceRoot":"","sources":["../requires.test.ts"],"names":[],"mappings":"AACA,OAAO,EAAkB,KAAK,EAAK,MAAM,YAAY,CAAA;AAErD,OAAO,EAAkB,UAAU,EAAE,MAAM,uBAAuB,CAAA;AAClE,OAAO,EAAmD,IAAI,EAAE,QAAQ,EAAqB,MAAM,eAAe,CAAA;;;;;;AAElH,qBAAa,cAAe,SAAQ,mBAUlC;CACD;;;;;;;AAGD,qBAAa,kBAAmB,SAAQ,uBAQtC;CACD;;;;;;;AAED,qBAAa,kBAAmB,SAAQ,uBAYtC;CACD;;;;;;;AAED,qBAAa,sBAAuB,SAAQ,2BAa1C;CACD"}
+{"version":3,"file":"requires.test.d.ts","sourceRoot":"","sources":["../requires.test.ts"],"names":[],"mappings":"AAGA,OAAO,EAA2B,KAAK,EAAK,MAAM,YAAY,CAAA;AAG9D,OAAO,EAAkB,UAAU,EAAE,MAAM,uBAAuB,CAAA;AAClE,OAAO,EAAmD,IAAI,EAAE,QAAQ,EAAqB,MAAM,eAAe,CAAA;;;;;;AAElH,qBAAa,cAAe,SAAQ,mBAUlC;CACD;;;;;;;AAGD,qBAAa,kBAAmB,SAAQ,uBAQtC;CACD;;;;;;;AAED,qBAAa,kBAAmB,SAAQ,uBAYtC;CACD;;;;;;;AAED,qBAAa,sBAAuB,SAAQ,2BAa1C;CACD"}

package/test/fixtures.ts

@@ -1,7 +1,7 @@
 import { Context, Effect, Option, S, Scope } from "effect-app"
 import { NotLoggedInError, RPCContextMap, UnauthorizedError } from "effect-app/client"
 import { TaggedError } from "effect-app/Schema"
-import { contextMap, Middleware } from "../src/api/routing.js"
+import { contextMap, getConfig, Middleware } from "../src/api/routing.js"
 
 export class UserProfile extends Context.assignTag<UserProfile, UserProfile>("UserProfile")(
   S.Class<UserProfile>("UserProfile")({
@@ -16,6 +16,8 @@ export class SomeElse extends Context.TagMakeId("SomeElse", Effect.succeed({ b:
 const MakeSomeService = Effect.succeed({ a: 1 })
 export class SomeService extends Context.TagMakeId("SomeService", MakeSomeService)<SomeService>() {}
 
+const requestConfig = getConfig<RequestContextMap>()
+
 // TODO: null as never sucks
 // why [UserProfile] is needed? AllowAnonymous triggers an error if just UserProfile without []
 // [] requires return Context, non [] requires return the Service instance
@@ -36,12 +38,12 @@ export class AllowAnonymous extends Middleware.Tag<AllowAnonymous>()("AllowAnony
 })({
   effect: Effect.gen(function*() {
     return Effect.fnUntraced(
-      function*({ config, headers }) {
+      function*({ headers, rpc }) {
         yield* SomeElse
         yield* Scope.Scope // provided by HttpRouter.HttpRouter.Provided
         const isLoggedIn = !!headers["x-user"]
         if (!isLoggedIn) {
-          if (!config.allowAnonymous) {
+          if (!requestConfig(rpc).allowAnonymous) {
             return yield* new NotLoggedInError({ message: "Not logged in" })
           }
           return Option.none()
@@ -74,10 +76,10 @@ export class RequireRoles extends Middleware.Tag<RequireRoles>()("RequireRoles",
   effect: Effect.gen(function*() {
     yield* SomeService
     return Effect.fnUntraced(
-      function*({ config, next }) {
+      function*({ next, rpc }) {
         // we don't know if the service will be provided or not, so we use option..
         const userProfile = yield* Effect.serviceOption(UserProfile)
-        const { requireRoles } = config
+        const { requireRoles } = requestConfig(rpc)
         console.dir(
           {
             userProfile,