@effect-app/infra 2.86.0 → 2.87.0

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

@@ -1,13 +1,20 @@
-import { Array, Either, type NonEmptyArray } from "effect-app"
+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 DynamicMiddlewareMaker, type GenericMiddlewareMaker, makeMiddleware, type makeMiddlewareBasic, type RequestContextMapProvider } from "../../routing.js"
+import { type Simplify } from "effect-app/Types"
+import { type LayerUtils } from "../../layerUtils.js"
+import { type GenericMiddlewareMaker, genericMiddlewareMaker } from "./generic-middleware.js"
+import { makeRpcEffect, type MiddlewareMakerId, type RPCHandlerFactory } from "./RouterMiddleware.js"
+import { type AnyDynamic, type RpcDynamic, type TagClassAny } from "./RpcMiddleware.js"
 
-// TODO: ContextMap should be physical Tag (so typeof Tag), so that we can retrieve Identifier and Service separately.
-// in Service classes and TagId, the Id and Service are the same, but don't have to be in classic Tag or GenericTag.
-export const contextMap = <RequestContextMap>() => <K extends keyof RequestContextMap>(a: K) => ({
-  key: a,
-  settings: null as any as RequestContextMap[typeof a]
-})
+// TODO: don't expect service when it's wrap/never
+// perhaps RequestContextMap should be an object, instead of an interface, so that we don't need to provide anything here
+export const contextMap =
+  <RequestContextMap extends Record<string, RPCContextMap.Any>>() =>
+  <K extends keyof RequestContextMap>(a: K, service: RequestContextMap[K]["service"]) => ({
+    key: a,
+    settings: { service } as any as RequestContextMap[typeof a]
+  })
 
 export interface MiddlewareM<
   RequestContext extends Record<string, RPCContextMap.Any>,
@@ -28,6 +35,13 @@ export interface MiddlewareM<
   >
 }
 
+type GetDependsOnKeys<MW extends GenericMiddlewareMaker> = 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
+
 export interface MiddlewareDynamic<
   RequestContext extends Record<string, RPCContextMap.Any>,
   Provided extends keyof RequestContext,
@@ -35,14 +49,17 @@ export interface MiddlewareDynamic<
   DynamicMiddlewareProviders,
   out MiddlewareR
 > {
-  // TODO: this still allows to mix both types of middleware but with bad typing result
-  // either have to block it, or implement the support properly.
-  middleware<MW extends NonEmptyArray<DynamicMiddlewareMaker<RequestContext>> | NonEmptyArray<GenericMiddlewareMaker>>(
+  middleware<MW extends NonEmptyArray<GenericMiddlewareMaker>>(
     ...mw: MW
-  ): [MW] extends [NonEmptyArray<DynamicMiddlewareMaker<RequestContext>>] ? DynamicMiddlewareMakerrsss<
+  ): MW extends NonEmptyArray<{ dynamic: RpcDynamic<any, RequestContext[keyof RequestContext]> }>
+    ? DynamicMiddlewareMakerrsss<
       RequestContext,
-      Provided | MW[number]["dynamic"]["key"],
-      Middlewares,
+      // when one dynamic middleware depends on another, substract the key, to enforce the dependency to be provided after.
+      Exclude<
+        Provided | MW[number]["dynamic"]["key"],
+        { [K in keyof MW]: GetDependsOnKeys<MW[K]> }[number]
+      >,
+      [...Middlewares, ...MW],
       & DynamicMiddlewareProviders
       & {
         [U in MW[number] as U["dynamic"]["key"]]: U
@@ -58,9 +75,6 @@ export interface MiddlewareDynamic<
     >
 }
 
-type GetDynamicMiddleware<T, RequestContext extends Record<string, RPCContextMap.Any>> = T extends
-  RequestContextMapProvider<RequestContext> ? T : never
-
 type DynamicMiddlewareMakerrsss<
   RequestContext extends Record<string, RPCContextMap.Any>,
   Provided extends keyof RequestContext = never,
@@ -68,19 +82,18 @@ type DynamicMiddlewareMakerrsss<
   DynamicMiddlewareProviders = unknown,
   MiddlewareR = never
 > = keyof Omit<RequestContext, Provided> extends never ? [MiddlewareR] extends [never] ?
+      & {
+        MiddlewareR: MiddlewareR
+        Provided: Provided
+        Middlewares: Middlewares
+        DynamicMiddlewareProviders: Simplify<DynamicMiddlewareProviders>
+      }
       & ReturnType<
         typeof makeMiddlewareBasic<
           RequestContext,
-          GetDynamicMiddleware<DynamicMiddlewareProviders, RequestContext>,
           Middlewares
         >
       >
-      // & {
-      //   MiddlewareR: MiddlewareR
-      //   Provided: Provided
-      //   Middlewares: Middlewares
-      //   DynamicMiddlewareProviders: Simplify<DynamicMiddlewareProviders>
-      // }
       & MiddlewareM<
         RequestContext,
         Provided,
@@ -88,50 +101,120 @@ type DynamicMiddlewareMakerrsss<
         DynamicMiddlewareProviders,
         MiddlewareR
       >
-  : MiddlewareM<
-    RequestContext,
-    Provided,
-    Middlewares,
-    DynamicMiddlewareProviders,
-    MiddlewareR
-  >
-  : MiddlewareDynamic<
-    RequestContext,
-    Provided,
-    Middlewares,
-    DynamicMiddlewareProviders,
-    MiddlewareR
-  >
+  :
+    & {
+      MiddlewareR: MiddlewareR
+      Provided: Provided
+      Middlewares: Middlewares
+      DynamicMiddlewareProviders: Simplify<DynamicMiddlewareProviders>
+    }
+    & MiddlewareM<
+      RequestContext,
+      Provided,
+      Middlewares,
+      DynamicMiddlewareProviders,
+      MiddlewareR
+    >
+  :
+    & {
+      MiddlewareR: MiddlewareR
+      Provided: Provided
+      Middlewares: Middlewares
+      DynamicMiddlewareProviders: Simplify<DynamicMiddlewareProviders>
+    }
+    & MiddlewareDynamic<
+      RequestContext,
+      Provided,
+      Middlewares,
+      DynamicMiddlewareProviders,
+      MiddlewareR
+    >
 
-export const makeNewMiddleware: <
+export const makeMiddleware: <
   RequestContextMap extends Record<string, RPCContextMap.Any>
 >() => DynamicMiddlewareMakerrsss<RequestContextMap> = () => {
-  const make = makeMiddleware<any>()
-  let capturedMiddlewares: (DynamicMiddlewareMaker<any> | GenericMiddlewareMaker)[] = []
+  let allMiddleware: GenericMiddlewareMaker[] = []
   const it = {
     middleware: (...middlewares: any[]) => {
       for (const mw of middlewares) {
-        capturedMiddlewares = [mw, ...capturedMiddlewares]
-        if (mw.dynamic) {
-          console.log("Adding dynamic middleware", mw.key, mw.dynamic.key)
-        } else {
-          console.log("Adding generic middleware", mw.key)
-        }
+        allMiddleware = [mw, ...allMiddleware]
       }
-      const [genericMiddlewares, dyn] = Array.partitionMap(
-        capturedMiddlewares,
-        (mw) =>
-          "dynamic" in mw && mw.dynamic
-            ? Either.right(mw as DynamicMiddlewareMaker<any>)
-            : Either.left(mw as GenericMiddlewareMaker)
-      )
-      const dynamicMiddlewares = dyn.reduce(
-        (prev, cur) => ({ ...prev, [cur.dynamic.key]: cur }),
-        {} as Record<string, any>
-      )
       // TODO: support dynamic and generic intertwined. treat them as one
-      return Object.assign(make({ genericMiddlewares, dynamicMiddlewares }), it)
+      return Object.assign(makeMiddlewareBasic<any, any>(...allMiddleware), it)
     }
   }
   return it as any
 }
+
+export const makeMiddlewareBasic =
+  // by setting RequestContextMap beforehand, execute contextual typing does not fuck up itself to anys
+  <
+    RequestContextMap extends Record<string, RPCContextMap.Any>,
+    // RequestContextProviders extends RequestContextMapProvider<RequestContextMap>, // how to resolve the dynamic middleware
+    GenericMiddlewareProviders extends ReadonlyArray<GenericMiddlewareMaker>
+  >(
+    ...make: GenericMiddlewareProviders
+  ) => {
+    const MiddlewareMaker = Context.GenericTag<
+      MiddlewareMakerId,
+      {
+        effect: RPCHandlerFactory<
+          RequestContextMap,
+          GenericMiddlewareMaker.Provided<GenericMiddlewareProviders[number]>
+        >
+        _tag: "MiddlewareMaker"
+      }
+    >(
+      "MiddlewareMaker"
+    )
+
+    const middlewares = genericMiddlewareMaker(...make)
+
+    const l = Layer.scoped(
+      MiddlewareMaker,
+      middlewares
+        .effect
+        .pipe(
+          Effect.map((generic) => ({
+            _tag: "MiddlewareMaker" as const,
+            effect: makeRpcEffect<
+              RequestContextMap,
+              GenericMiddlewareMaker.Provided<GenericMiddlewareProviders[number]>
+            >()(
+              (schema, next, moduleName) => {
+                return (payload, headers) =>
+                  Effect
+                    .gen(function*() {
+                      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: next(payload, headers) as any
+                      })
+                    }) as any // why?
+              }
+            )
+          }))
+        )
+    )
+
+    const middlewareLayer = l
+      .pipe(
+        Layer.provide(middlewares.dependencies as any)
+      ) as Layer.Layer<
+        MiddlewareMakerId,
+        LayerUtils.GetLayersError<typeof middlewares.dependencies>, // what could go wrong when building the dynamic middleware provider
+        LayerUtils.GetLayersContext<typeof middlewares.dependencies>
+      >
+
+    return Object.assign(MiddlewareMaker, { Default: middlewareLayer })
+  }

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

@@ -3,7 +3,7 @@ import { Cause, Context, Duration, Effect, Layer, ParseResult, Request } from "e
 import { pretty } from "effect-app/utils"
 import { logError, reportError } from "../../../errorReporter.js"
 import { InfraLogger } from "../../../logger.js"
-import { Tag } from "../middleware.js"
+import { Tag } from "./RpcMiddleware.js"
 
 const logRequestError = logError("Request")
 const reportRequestError = reportError("Request")

package/src/api/routing/middleware.ts

@@ -1,10 +1,11 @@
 // 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-api.js"
 export * from "./middleware/middleware.js"
+export * from "./middleware/RouterMiddleware.js"
+export * from "./middleware/RpcMiddleware.js"
 // codegen:end
 
 export * as Middleware from "./middleware.js"

package/src/api/routing/tsort.ts

@@ -39,7 +39,7 @@ export function tsort(edges) {
   return sorted
 }
 
-export const createEdges = <T extends { dependsOn?: any[] }>(dep: readonly T[]) => {
+export const createEdges = <T extends { dependsOn?: readonly any[] }>(dep: readonly T[]) => {
   const result = []
   dep.forEach((key) => {
     key.dependsOn?.forEach((n) => {
@@ -49,7 +49,7 @@ export const createEdges = <T extends { dependsOn?: any[] }>(dep: readonly T[])
   return result
 }
 
-export const sort = <T>(dep: readonly (T & { dependsOn?: any[] })[]): readonly T[] => {
+export const sort = <T>(dep: readonly (T & { dependsOn?: readonly any[] })[]): readonly T[] => {
   const edges = createEdges(dep)
   const result = tsort(edges)
   return result.concat(dep.filter((v) => !result.includes(v)))

package/test/controller.test.ts

@@ -2,9 +2,9 @@
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
 import { type MakeContext, type MakeErrors, makeRouter } from "@effect-app/infra/api/routing"
 import { expect, expectTypeOf, it } from "@effect/vitest"
-import { Context, Effect, Layer, S, Scope } from "effect-app"
+import { Context, Effect, type Layer, S, Scope } from "effect-app"
 import { InvalidStateError, makeRpcClient, NotLoggedInError, UnauthorizedError } from "effect-app/client"
-import { DefaultGenericMiddlewares, implementMiddleware, makeMiddleware, makeNewMiddleware, Middleware, Tag } from "../src/api/routing/middleware.js"
+import { DefaultGenericMiddlewares, makeMiddleware, Middleware, Tag } from "../src/api/routing/middleware.js"
 import { sort } from "../src/api/routing/tsort.js"
 import { AllowAnonymous, CustomError1, type RequestContextMap, RequireRoles, Some, SomeElse, SomeService, Test } from "./fixtures.js"
 
@@ -53,13 +53,13 @@ class MyContextProvider2 extends Middleware.Tag<MyContextProvider2>()("MyContext
 //
 
 const Str = Context.GenericTag<"str", "str">("str")
-const Str2 = Context.GenericTag<"str2", "str">("str2")
 
 export class BogusMiddleware extends Tag<BogusMiddleware>()("BogusMiddleware", {
   provides: SomeService,
   wrap: true
 })({
   effect: Effect.gen(function*() {
+    yield* Str
     // yield* Effect.context<"test-dep">()
     return ({ next }) =>
       Effect.gen(function*() {
@@ -72,61 +72,31 @@ export class BogusMiddleware extends Tag<BogusMiddleware>()("BogusMiddleware", {
 
 const genericMiddlewares = [
   ...DefaultGenericMiddlewares,
-  // BogusMiddleware,
-  MyContextProvider2,
-  MyContextProvider
+  BogusMiddleware,
+  MyContextProvider2
 ] as const
 
-// TODO: eventually it might be nice if we have total control over order somehow..
-// [ AddRequestNameToSpanContext, RequestCacheContext, UninterruptibleMiddleware, Dynamic(or individual, AllowAnonymous, RequireRoles, Test - or whichever order) ]
-const middleware = makeMiddleware<RequestContextMap>()({
-  genericMiddlewares,
-
-  dynamicMiddlewares: {
-    requireRoles: RequireRoles,
-    allowAnonymous: AllowAnonymous,
-    test: Test
-  },
-
-  dependencies: [Layer.effect(Str2, Str)],
-  execute: (maker) =>
-    Effect.gen(function*() {
-      return maker(
-        (_schema, handler) => (req, headers) =>
-          // contextProvider and dynamicMiddlewares are already provided here.
-          // aka this runs "last"
-          Effect
-            .gen(function*() {
-              // you can use only HttpRouter.HttpRouter.Provided here as additional context
-              // and what ContextProvider provides too
-              // const someElse = yield* SomeElse
-              yield* Some // provided by ContextProvider
-              yield* Scope.Scope // provided by HttpRouter.HttpRouter.Provided
-
-              return yield* handler(req, headers)
-            })
-      )
-    })
-})
+const middleware = makeMiddleware<RequestContextMap>()
+  .middleware(MyContextProvider)
+  .middleware(
+    RequireRoles,
+    Test
+  )
+  .middleware(AllowAnonymous)
+  .middleware(...genericMiddlewares)
+// dependencies: [Layer.effect(Str2, Str)],
 
-const middleware2 = makeMiddleware<RequestContextMap>()({
-  // TODO: I guess it makes sense to support just passing array of context providers too, like dynamicMiddlewares?
-  genericMiddlewares: [...DefaultGenericMiddlewares, BogusMiddleware, MyContextProvider2, MyContextProvider],
-  // or is the better api to use constructors outside, like how contextProvider is used now?
-  dynamicMiddlewares: {
-    requireRoles: RequireRoles,
-    allowAnonymous: AllowAnonymous,
-    test: Test
-  }
-})
+const middleware2 = makeMiddleware<RequestContextMap>()
+  .middleware(MyContextProvider)
+  .middleware(RequireRoles, Test)
+  .middleware(AllowAnonymous)
+  .middleware(...DefaultGenericMiddlewares, BogusMiddleware, MyContextProvider2)
 
-export const middleware3 = makeNewMiddleware<RequestContextMap>()
+export const middleware3 = makeMiddleware<RequestContextMap>()
   .middleware(...genericMiddlewares)
   .middleware(AllowAnonymous, RequireRoles)
   .middleware(Test)
-// .middleware(BogusMiddleware)
-
-// expectTypeOf(middleware3).toExtend<typeof middleware2>()
+  .middleware(BogusMiddleware)
 
 export type RequestConfig = {
   /** Disable authentication requirement */
@@ -348,16 +318,10 @@ const router2 = r2.Router(Something)({
 
 // eslint-disable-next-line unused-imports/no-unused-vars
 const matched2 = matchAll({ router: router2 })
-expectTypeOf({} as Layer.Context<typeof matched2>).toEqualTypeOf<Some | SomeService>()
+expectTypeOf({} as Layer.Context<typeof matched2>).toEqualTypeOf<Some | SomeService | "str">()
 
 type makeContext2 = MakeContext<typeof router2.make>
 expectTypeOf({} as MakeErrors<typeof router2.make>).toEqualTypeOf<InvalidStateError>()
 expectTypeOf({} as makeContext2).toEqualTypeOf<
   SomethingService | SomethingRepo | SomethingService2
 >()
-
-export const dynamicMiddlewares = implementMiddleware<RequestContextMap>()({
-  requireRoles: RequireRoles,
-  allowAnonymous: AllowAnonymous,
-  test: Test
-})

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;AAE7F,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAC7D,OAAO,EAAoC,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAA;AACzG,OAAO,EAAqF,UAAU,EAAO,MAAM,kCAAkC,CAAA;AAErJ,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,KAAK,iBAAiB,EAAE,YAAY,EAAE,IAAI,EAAE,QAAQ,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,eAAe,CAAA;;;;;;;AAGrI,cAAM,iBAAkB,SAAQ,sBA0B9B;CAAG;;;;;;AAGL,cAAM,kBAAmB,SAAQ,uBAU/B;CAAG;;;;;;;AAOL,qBAAa,eAAgB,SAAQ,oBAYnC;CACD;AAoDD,eAAO,MAAM,WAAW;;;;;YAGL,CAAA;AAKnB,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAI/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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uCAAiC,CAAA;AAE1E,eAAO,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAgC,CAAA;AAyJ/C,eAAO,MAAM,kBAAkB;;;;;;;;;;CAI7B,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;AAE7F,OAAO,EAAW,MAAM,EAAE,KAAK,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAElE,OAAO,EAA6C,UAAU,EAAO,MAAM,kCAAkC,CAAA;AAE7G,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,KAAK,iBAAiB,EAAE,YAAY,EAAE,IAAI,EAAE,QAAQ,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,eAAe,CAAA;;;;;;AAgCrI,cAAM,kBAAmB,SAAQ,uBAU/B;CAAG;;;;;;;AAML,qBAAa,eAAgB,SAAQ,oBAanC;CACD;AAwBD,eAAO,MAAM,WAAW;;;;;;;;;;;;;;YAIM,CAAA;AAE9B,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAI/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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uCAAiC,CAAA;AAE1E,eAAO,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAgC,CAAA"}

package/test/dist/fixtures.d.ts

@@ -68,14 +68,14 @@ declare const SomeElse_base: (abstract new (service: {
 export declare class SomeElse extends SomeElse_base {
 }
 export type RequestContextMap = {
-    allowAnonymous: RPCContextMap.Inverted<UserProfile, typeof NotLoggedInError>;
+    allowAnonymous: RPCContextMap.Inverted<[typeof UserProfile], typeof NotLoggedInError>;
     requireRoles: RPCContextMap.Custom<never, typeof UnauthorizedError, Array<string>>;
     test: RPCContextMap<never, typeof S.Never>;
 };
 declare const AllowAnonymous_base: Middleware.TagClass<AllowAnonymous, "AllowAnonymous", {
     readonly dynamic: {
         key: "allowAnonymous";
-        settings: RPCContextMap.Inverted<UserProfile, typeof NotLoggedInError>;
+        settings: RPCContextMap.Inverted<[typeof UserProfile], typeof NotLoggedInError>;
     };
     readonly requires: typeof SomeElse;
 }> & {
@@ -88,6 +88,7 @@ declare const RequireRoles_base: Middleware.TagClass<RequireRoles, "RequireRoles
         key: "requireRoles";
         settings: RPCContextMap.Custom<never, typeof UnauthorizedError, string[]>;
     };
+    readonly wrap: true;
     readonly dependsOn: readonly [typeof AllowAnonymous];
 }> & {
     Default: import("effect/Layer").Layer<RequireRoles, never, Some>;
@@ -95,6 +96,7 @@ declare const RequireRoles_base: Middleware.TagClass<RequireRoles, "RequireRoles
 export declare class RequireRoles extends RequireRoles_base {
 }
 declare const Test_base: Middleware.TagClass<Test, "Test", {
+    readonly wrap: true;
     readonly dynamic: {
         key: "test";
         settings: RPCContextMap<never, typeof S.Never>;

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,KAAK,aAAa,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAA;AAE3F,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,MAAM,MAAM,iBAAiB,GAAG;IAC9B,cAAc,EAAE,aAAa,CAAC,QAAQ,CAAC,WAAW,EAAE,OAAO,gBAAgB,CAAC,CAAA;IAC5E,YAAY,EAAE,aAAa,CAAC,MAAM,CAAC,KAAK,EAAE,OAAO,iBAAiB,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC,CAAA;IAClF,IAAI,EAAE,aAAa,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC,KAAK,CAAC,CAAA;CAC3C,CAAA;;;;;;;;;;AAED,qBAAa,cAAe,SAAQ,mBAuBlC;CACD;;;;;;;;;;AAGD,qBAAa,YAAa,SAAQ,iBAoBhC;CACD;;;;;;;;;AAED,qBAAa,IAAK,SAAQ,SAMxB;CAAG;;;;AAEL,qBAAa,YAAa,SAAQ,iBAAmD;CAAG;;;;AACxF,qBAAa,YAAa,SAAQ,iBAAmD;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;AAGxF,qBAAa,WAAY,SAAQ,gBAAgE;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,KAAK,aAAa,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAA;AAE3F,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,MAAM,MAAM,iBAAiB,GAAG;IAC9B,cAAc,EAAE,aAAa,CAAC,QAAQ,CAAC,CAAC,OAAO,WAAW,CAAC,EAAE,OAAO,gBAAgB,CAAC,CAAA;IACrF,YAAY,EAAE,aAAa,CAAC,MAAM,CAAC,KAAK,EAAE,OAAO,iBAAiB,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC,CAAA;IAClF,IAAI,EAAE,aAAa,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC,KAAK,CAAC,CAAA;CAC3C,CAAA;;;;;;;;;;AAED,qBAAa,cAAe,SAAQ,mBA4BlC;CACD;;;;;;;;;;;AAGD,qBAAa,YAAa,SAAQ,iBA6BhC;CACD;;;;;;;;;;AAED,qBAAa,IAAK,SAAQ,SASxB;CAAG;;;;AAEL,qBAAa,YAAa,SAAQ,iBAAmD;CAAG;;;;AACxF,qBAAa,YAAa,SAAQ,iBAAmD;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;AAGxF,qBAAa,WAAY,SAAQ,gBAAgE;CAAG"}

package/test/dist/fixtures.js

@@ -12,7 +12,7 @@ export class Some extends Context.TagMakeId("Some", Effect.succeed({ a: 1 }))()
 export class SomeElse extends Context.TagMakeId("SomeElse", Effect.succeed({ b: 2 }))() {
 }
 export class AllowAnonymous extends Middleware.Tag()("AllowAnonymous", {
-    dynamic: contextMap()("allowAnonymous"),
+    dynamic: contextMap()("allowAnonymous", [UserProfile]),
     requires: SomeElse
 })({
     effect: Effect.gen(function* () {
@@ -26,36 +26,48 @@ export class AllowAnonymous extends Middleware.Tag()("AllowAnonymous", {
                 }
                 return Option.none();
             }
-            return Option.some(Context.make(UserProfile, { id: "whatever", roles: ["user", "manager"] }));
+            return Option.some(Context.make(UserProfile, new UserProfile({
+                id: "whatever",
+                roles: ["user", ...headers["x-is-manager"] === "true" ? ["manager"] : []]
+            })));
         });
     })
 }) {
 }
 // @effect-diagnostics-next-line missingEffectServiceDependency:off
 export class RequireRoles extends Middleware.Tag()("RequireRoles", {
-    dynamic: contextMap()("requireRoles"),
+    dynamic: contextMap()("requireRoles", null), // TODO
+    wrap: true,
+    // wrap: true,
     // had to move this in here, because once you put it manually as a readonly static property on the class,
     // there's a weird issue where the fluent api stops behaving properly after adding this middleware via `addDynamicMiddleware`
     dependsOn: [AllowAnonymous]
 })({
     effect: Effect.gen(function* () {
         yield* Some;
-        return Effect.fnUntraced(function* ({ config }) {
+        return Effect.fnUntraced(function* ({ config, next }) {
             // 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;
+            console.dir({
+                userProfile,
+                requireRoles
+            }, { depth: 5 });
             if (requireRoles && !userProfile.value?.roles?.some((role) => requireRoles.includes(role))) {
                 return yield* new UnauthorizedError({ message: "don't have the right roles" });
             }
-            return Option.none();
+            return yield* next;
         });
     })
 }) {
 }
-export class Test extends Middleware.Tag()("Test", { dynamic: contextMap()("test") })({
+export class Test extends Middleware.Tag()("Test", {
+    wrap: true,
+    dynamic: contextMap()("test", null) // TODO
+})({
     effect: Effect.gen(function* () {
-        return Effect.fn(function* () {
-            return Option.none();
+        return Effect.fn(function* ({ next }) {
+            return yield* next;
         });
     })
 }) {
@@ -67,4 +79,4 @@ export class CustomError2 extends TaggedError()("CustomError1", {}) {
 const MakeSomeService = Effect.succeed({ a: 1 });
 export class SomeService extends Context.TagMakeId("SomeService", MakeSomeService)() {
 }
-//# 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,EAAU,KAAK,EAAK,MAAM,YAAY,CAAA;AAC7C,OAAO,EAAqB,UAAU,EAAE,MAAM,uBAAuB,CAAA;AACrE,OAAO,EAAwD,IAAI,EAAE,QAAQ,EAAQ,MAAM,eAAe,CAAA;;;;;;;AAE1G,qBAAa,cAAe,SAAQ,mBAYlC;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":"AACA,OAAO,EAAkB,KAAK,EAAK,MAAM,YAAY,CAAA;AAErD,OAAO,EAAkB,UAAU,EAAE,MAAM,uBAAuB,CAAA;AAClE,OAAO,EAAwD,IAAI,EAAE,QAAQ,EAAQ,MAAM,eAAe,CAAA;;;;;;AAE1G,qBAAa,cAAe,SAAQ,mBAUlC;CACD;;;;;;;AAED,qBAAa,kBAAmB,SAAQ,uBAYtC;CACD;;;;;;;AAED,qBAAa,sBAAuB,SAAQ,2BAa1C;CACD"}

package/test/fixtures.ts

@@ -15,13 +15,13 @@ export class Some extends Context.TagMakeId("Some", Effect.succeed({ a: 1 }))<So
 export class SomeElse extends Context.TagMakeId("SomeElse", Effect.succeed({ b: 2 }))<SomeElse>() {}
 
 export type RequestContextMap = {
-  allowAnonymous: RPCContextMap.Inverted<UserProfile, typeof NotLoggedInError>
+  allowAnonymous: RPCContextMap.Inverted<[typeof UserProfile], typeof NotLoggedInError>
   requireRoles: RPCContextMap.Custom<never, typeof UnauthorizedError, Array<string>>
   test: RPCContextMap<never, typeof S.Never>
 }
 
 export class AllowAnonymous extends Middleware.Tag<AllowAnonymous>()("AllowAnonymous", {
-  dynamic: contextMap<RequestContextMap>()("allowAnonymous"),
+  dynamic: contextMap<RequestContextMap>()("allowAnonymous", [UserProfile]),
   requires: SomeElse
 })({
   effect: Effect.gen(function*() {
@@ -36,10 +36,15 @@ export class AllowAnonymous extends Middleware.Tag<AllowAnonymous>()("AllowAnony
           }
           return Option.none()
         }
-        return Option.some(Context.make(
-          UserProfile,
-          { id: "whatever", roles: ["user", "manager"] }
-        ))
+        return Option.some(
+          Context.make(
+            UserProfile,
+            new UserProfile({
+              id: "whatever",
+              roles: ["user", ...headers["x-is-manager"] === "true" ? ["manager"] : []]
+            })
+          )
+        )
       }
     )
   })
@@ -48,7 +53,9 @@ export class AllowAnonymous extends Middleware.Tag<AllowAnonymous>()("AllowAnony
 
 // @effect-diagnostics-next-line missingEffectServiceDependency:off
 export class RequireRoles extends Middleware.Tag<RequireRoles>()("RequireRoles", {
-  dynamic: contextMap<RequestContextMap>()("requireRoles"),
+  dynamic: contextMap<RequestContextMap>()("requireRoles", null as never), // TODO
+  wrap: true,
+  // wrap: true,
   // had to move this in here, because once you put it manually as a readonly static property on the class,
   // there's a weird issue where the fluent api stops behaving properly after adding this middleware via `addDynamicMiddleware`
   dependsOn: [AllowAnonymous]
@@ -56,24 +63,34 @@ export class RequireRoles extends Middleware.Tag<RequireRoles>()("RequireRoles",
   effect: Effect.gen(function*() {
     yield* Some
     return Effect.fnUntraced(
-      function*({ config }) {
+      function*({ config, next }) {
         // 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
+        console.dir(
+          {
+            userProfile,
+            requireRoles
+          },
+          { depth: 5 }
+        )
         if (requireRoles && !userProfile.value?.roles?.some((role) => requireRoles.includes(role))) {
           return yield* new UnauthorizedError({ message: "don't have the right roles" })
         }
-        return Option.none<Context<never>>()
+        return yield* next
       }
     )
   })
 }) {
 }
 
-export class Test extends Middleware.Tag<Test>()("Test", { dynamic: contextMap<RequestContextMap>()("test") })({
+export class Test extends Middleware.Tag<Test>()("Test", {
+  wrap: true,
+  dynamic: contextMap<RequestContextMap>()("test", null as never) // TODO
+})({
   effect: Effect.gen(function*() {
-    return Effect.fn(function*() {
-      return Option.none<Context<never>>()
+    return Effect.fn(function*({ next }) {
+      return yield* next
     })
   })
 }) {}