@effect-app/infra 2.87.2 → 2.88.0

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

@@ -3,37 +3,22 @@ import { Context, Effect, Layer, type NonEmptyArray, type NonEmptyReadonlyArray
 import { type RPCContextMap } from "effect-app/client"
 import { type LayerUtils } from "../../layerUtils.js"
 import { type GenericMiddlewareMaker, genericMiddlewareMaker } from "./generic-middleware.js"
-import { makeRpcEffect, type MiddlewareMakerId, type RPCHandlerFactory } from "./RouterMiddleware.js"
+import { makeRpcEffect, type RPCHandlerFactory } from "./RouterMiddleware.js"
 import { type AnyDynamic, type RpcDynamic, type TagClassAny } from "./RpcMiddleware.js"
 
-// 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>,
-  Provided extends keyof RequestContext,
-  Middlewares extends ReadonlyArray<GenericMiddlewareMaker>,
-  DynamicMiddlewareProviders,
-  // out MiddlewareR = never
-  MiddlewareR = never
-> {
-  middleware<MW extends NonEmptyArray<GenericMiddlewareMaker>>(
-    ...mw: MW
-  ): DynamicMiddlewareMakerrsss<
-    RequestContext,
-    Provided,
-    [...Middlewares, ...MW],
-    DynamicMiddlewareProviders,
-    GenericMiddlewareMaker.ApplyManyServices<MW, MiddlewareR>
-  >
-}
+// 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
+>(rcm: RequestContextMap, key: Key): RpcDynamic<Key, RequestContextMap[Key]> => ({
+  key,
+  settings: { service: rcm[key]!["service"] } as RequestContextMap[Key]
+})
 
+// 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> }
   ? {
     [K in keyof MW["dependsOn"]]: MW["dependsOn"][K] extends AnyDynamic ? MW["dependsOn"][K]["dynamic"]["key"]
@@ -41,112 +26,171 @@ type GetDependsOnKeys<MW extends GenericMiddlewareMaker> = MW extends { dependsO
   }[keyof MW["dependsOn"]]
   : never
 
-export interface MiddlewareDynamic<
-  RequestContext extends Record<string, RPCContextMap.Any>,
-  Provided extends keyof RequestContext,
+type FilterInDynamicMiddlewares<
+  MWs extends ReadonlyArray<GenericMiddlewareMaker>,
+  RequestContextMap extends Record<string, RPCContextMap.Any>
+> = {
+  [K in keyof MWs]: MWs[K] extends { dynamic: RpcDynamic<any, RequestContextMap[keyof RequestContextMap]> } ? MWs[K]
+    : never
+}
+
+type RecursiveHandleMWsSideways<
+  MWs,
+  R extends {
+    rcm: Record<string, RPCContextMap.Any>
+    provided: keyof R["rcm"] // that's fine
+    middlewares: ReadonlyArray<GenericMiddlewareMaker>
+    dmp: any
+    middlewareR: any
+  }
+> = MWs extends [
+  infer F extends GenericMiddlewareMaker,
+  ...infer Rest extends ReadonlyArray<GenericMiddlewareMaker>
+] ? RecursiveHandleMWsSideways<Rest, {
+    rcm: R["rcm"]
+    // when one dynamic middleware depends on another, subtract the key to enforce the dependency to be provided after
+    // (if already provided, it would have to be re-provided anyway, so better to provide it after)
+    provided: Exclude<
+      R["provided"] | FilterInDynamicMiddlewares<[F], R["rcm"]>[number]["dynamic"]["key"],
+      // F is fine here because only dynamic middlewares will have 'dependsOn' prop
+      GetDependsOnKeys<F>
+    >
+    middlewares: [...R["middlewares"], F]
+    dmp: [FilterInDynamicMiddlewares<[F], R["rcm"]>[number]] extends [never] ? R["dmp"]
+      :
+        & R["dmp"]
+        & {
+          [U in FilterInDynamicMiddlewares<[F], R["rcm"]>[number] as U["dynamic"]["key"]]: U
+        }
+    middlewareR: GenericMiddlewareMaker.ApplyManyServices<[F], R["middlewareR"]>
+  }>
+  : R
+
+export interface BuildingMiddleware<
+  RequestContextMap extends Record<string, RPCContextMap.Any>,
+  Provided extends keyof RequestContextMap,
   Middlewares extends ReadonlyArray<GenericMiddlewareMaker>,
   DynamicMiddlewareProviders,
-  out MiddlewareR
+  out MiddlewareR extends { _tag: string } = never
 > {
-  middleware<MW extends NonEmptyArray<GenericMiddlewareMaker>>(
-    ...mw: MW
-  ): MW extends NonEmptyArray<{ dynamic: RpcDynamic<any, RequestContext[keyof RequestContext]> }>
-    ? DynamicMiddlewareMakerrsss<
-      RequestContext,
-      // 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
-      },
-      GenericMiddlewareMaker.ApplyManyServices<MW, MiddlewareR>
-    >
-    : DynamicMiddlewareMakerrsss<
-      RequestContext,
-      Provided,
-      [...Middlewares, ...MW],
-      DynamicMiddlewareProviders,
-      GenericMiddlewareMaker.ApplyManyServices<MW, MiddlewareR>
+  middleware<MWs extends NonEmptyArray<GenericMiddlewareMaker>>(
+    ...mw: MWs
+  ): RecursiveHandleMWsSideways<MWs, {
+    rcm: RequestContextMap
+    provided: Provided
+    middlewares: Middlewares
+    dmp: DynamicMiddlewareProviders
+    middlewareR: MiddlewareR
+  }> extends infer Res extends {
+    rcm: RequestContextMap
+    provided: keyof RequestContextMap
+    middlewares: ReadonlyArray<GenericMiddlewareMaker>
+    dmp: any
+    middlewareR: any
+  } ? MiddlewaresBuilder<
+      Res["rcm"],
+      Res["provided"],
+      Res["middlewares"],
+      Res["dmp"],
+      Res["middlewareR"]
     >
+    : never
+
+  // helps debugging what are the missing requirements (type only)
+  missing: {
+    missingDynamicMiddlewares: Exclude<keyof RequestContextMap, Provided>
+    missingContext: MiddlewareR
+  }
 }
 
-type DynamicMiddlewareMakerrsss<
-  RequestContext extends Record<string, RPCContextMap.Any>,
-  Provided extends keyof RequestContext = never,
+export type MiddlewaresBuilder<
+  RequestContextMap extends Record<string, RPCContextMap.Any>,
+  Provided extends keyof RequestContextMap = never,
   Middlewares extends ReadonlyArray<GenericMiddlewareMaker> = [],
   DynamicMiddlewareProviders = unknown,
-  MiddlewareR = never
-> = keyof Omit<RequestContext, Provided> extends never ? [MiddlewareR] extends [never] ?
-      & ReturnType<
+  MiddlewareR extends { _tag: string } = never
+> =
+  //  keyof Omit<RequestContextMap, Provided> extends never is true when all the dynamic middlewares are provided
+  // MiddlewareR is never when all the required services from generic & dynamic middlewares are provided
+  keyof Omit<RequestContextMap, Provided> extends never ? [MiddlewareR] extends [never] ? ReturnType<
         typeof makeMiddlewareBasic<
-          RequestContext,
+          RequestContextMap,
           Middlewares
         >
       >
-      & MiddlewareM<
-        RequestContext,
-        Provided,
-        Middlewares,
-        DynamicMiddlewareProviders,
-        MiddlewareR
-      >
-  : MiddlewareM<
-    RequestContext,
-    Provided,
-    Middlewares,
-    DynamicMiddlewareProviders,
-    MiddlewareR
-  >
-  : MiddlewareDynamic<
-    RequestContext,
-    Provided,
-    Middlewares,
-    DynamicMiddlewareProviders,
-    MiddlewareR
-  >
+    : BuildingMiddleware<
+      RequestContextMap,
+      Provided,
+      Middlewares,
+      DynamicMiddlewareProviders,
+      MiddlewareR
+    >
+    : BuildingMiddleware<
+      RequestContextMap,
+      Provided,
+      Middlewares,
+      DynamicMiddlewareProviders,
+      MiddlewareR
+    >
 
 export const makeMiddleware: <
   RequestContextMap extends Record<string, RPCContextMap.Any>
->() => DynamicMiddlewareMakerrsss<RequestContextMap> = () => {
+>(rcm: RequestContextMap) => MiddlewaresBuilder<RequestContextMap> = (rcm) => {
   let allMiddleware: GenericMiddlewareMaker[] = []
   const it = {
     middleware: (...middlewares: any[]) => {
       for (const mw of middlewares) {
+        // recall that we run middlewares in reverse order
         allMiddleware = [mw, ...allMiddleware]
       }
-      // TODO: support dynamic and generic intertwined. treat them as one
-      return Object.assign(makeMiddlewareBasic<any, any>(...allMiddleware), it)
+      return allMiddleware.filter((m) => !!m.dynamic).length !== Object.keys(rcm).length
+        // for sure, until all the dynamic middlewares are provided it's non sensical to call makeMiddlewareBasic
+        ? it
+        // actually, we don't know yet if MiddlewareR is never, but we can't easily check it at runtime
+        : Object.assign(makeMiddlewareBasic<any, any>(rcm, ...allMiddleware), it)
     }
   }
   return it as any
 }
 
-export const makeMiddlewareBasic =
+//
+export const MiddlewareMakerTag = "MiddlewareMaker" as const
+
+export interface MiddlewareMaker<E> {
+  readonly effect: E
+  readonly _tag: typeof MiddlewareMakerTag
+}
+
+export type MiddlewareMakerId = Pick<MiddlewareMaker<any>, "_tag">
+
+export const buildMiddlewareMaker = <E>(eff: E) =>
+  ({
+    _tag: MiddlewareMakerTag,
+    effect: eff
+  }) satisfies MiddlewareMaker<E>
+
+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>
   >(
+    _rcm: RequestContextMap,
     ...make: GenericMiddlewareProviders
   ) => {
     const MiddlewareMaker = Context.GenericTag<
       MiddlewareMakerId,
-      {
-        effect: RPCHandlerFactory<
+      MiddlewareMaker<
+        RPCHandlerFactory<
           RequestContextMap,
           GenericMiddlewareMaker.Provided<GenericMiddlewareProviders[number]>
         >
-        _tag: "MiddlewareMaker"
-      }
+      >
     >(
-      "MiddlewareMaker"
+      MiddlewareMakerTag
     )
 
+    // reverse middlewares and wrap one after the other
     const middlewares = genericMiddlewareMaker(...make)
 
     const l = Layer.scoped(
@@ -154,16 +198,16 @@ export const makeMiddlewareBasic =
       middlewares
         .effect
         .pipe(
-          Effect.map((generic) => ({
-            _tag: "MiddlewareMaker" as const,
-            effect: makeRpcEffect<
+          Effect.map((generic) => (buildMiddlewareMaker(
+            makeRpcEffect<
               RequestContextMap,
               GenericMiddlewareMaker.Provided<GenericMiddlewareProviders[number]>
             >()(
-              (schema, next, moduleName) => {
+              (schema, handler, moduleName) => {
                 return (payload, headers) =>
                   Effect
                     .gen(function*() {
+                      // will be propagated to all the wrapped middlewares
                       const basic = {
                         config: schema.config ?? {},
                         payload,
@@ -177,12 +221,12 @@ export const makeMiddlewareBasic =
                       }
                       return yield* generic({
                         ...basic,
-                        next: next(payload, headers) as any
+                        next: handler(payload, headers) as any
                       })
-                    }) as any // why?
+                    }) as any // why? because: Type 'SuccessValue' is not assignable to type 'Success<Req>' :P
               }
             )
-          }))
+          )))
         )
     )
 
@@ -191,9 +235,11 @@ export const makeMiddlewareBasic =
         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
+        // 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 })
   }

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

@@ -23,8 +23,8 @@ export class RequestCacheMiddleware extends Tag<RequestCacheMiddleware>()("Reque
 }) {
 }
 
-export class ConfigureInterruptibility
-  extends Tag<ConfigureInterruptibility>()("ConfigureInterruptibility", { wrap: true })({
+export class ConfigureInterruptibilityMiddleware
+  extends Tag<ConfigureInterruptibilityMiddleware>()("ConfigureInterruptibilityMiddleware", { wrap: true })({
     effect: Effect.succeed(({ next }) =>
       next.pipe(
         // TODO: make this depend on query/command, and consider if middleware also should be affected. right now it's not.
@@ -35,7 +35,7 @@ export class ConfigureInterruptibility
 {
 }
 
-export class MiddlewareLogger extends Tag<MiddlewareLogger>()("MiddlewareLogger", { wrap: true })({
+export class LoggerMiddleware extends Tag<LoggerMiddleware>()("LoggerMiddleware", { wrap: true })({
   effect: Effect.gen(function*() {
     const devMode = yield* DevMode
     return ({ headers, next, payload, rpc }) =>
@@ -98,6 +98,6 @@ export class MiddlewareLogger extends Tag<MiddlewareLogger>()("MiddlewareLogger"
 
 export const DefaultGenericMiddlewares = [
   RequestCacheMiddleware,
-  ConfigureInterruptibility,
-  MiddlewareLogger
+  ConfigureInterruptibilityMiddleware,
+  LoggerMiddleware
 ] as const

package/test/contextProvider.test.ts

@@ -1,6 +1,6 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
-import { expectTypeOf } from "@effect/vitest"
+import { expectTypeOf, it } from "@effect/vitest"
 import { Context, Effect, Scope } from "effect-app"
 import { ContextProvider, mergeContextProviders, MergedContextProvider } from "../src/api/routing.js"
 import { CustomError1, Some, SomeElse, SomeService } from "./fixtures.js"
@@ -119,33 +119,36 @@ export const someContextProviderGen = ContextProvider({
     }
   })
 })
-expectTypeOf(someContextProvider).toEqualTypeOf<typeof someContextProviderGen>()
 
-const merged = mergeContextProviders(MyContextProvider)
-const mergedGen = mergeContextProviders(MyContextProviderGen)
+it("works", () => {
+  expectTypeOf(someContextProvider).toEqualTypeOf<typeof someContextProviderGen>()
 
-export const contextProvider2 = ContextProvider(merged)
-export const contextProvider3 = MergedContextProvider(MyContextProvider)
-expectTypeOf(contextProvider2).toEqualTypeOf<typeof someContextProvider>()
-expectTypeOf(contextProvider3).toEqualTypeOf<typeof contextProvider2>()
+  const merged = mergeContextProviders(MyContextProvider)
+  const mergedGen = mergeContextProviders(MyContextProviderGen)
 
-export const contextProvider2Gen = ContextProvider(mergedGen)
-export const contextProvider3Gen = MergedContextProvider(MyContextProviderGen)
-expectTypeOf(contextProvider2Gen).toEqualTypeOf<typeof someContextProvider>()
-expectTypeOf(contextProvider3Gen).toEqualTypeOf<typeof contextProvider2Gen>()
+  const contextProvider2 = ContextProvider(merged)
+  const contextProvider3 = MergedContextProvider(MyContextProvider)
+  expectTypeOf(contextProvider2).toEqualTypeOf<typeof someContextProvider>()
+  expectTypeOf(contextProvider3).toEqualTypeOf<typeof contextProvider2>()
 
-expectTypeOf(contextProvider2Gen).toEqualTypeOf<typeof contextProvider2>()
-expectTypeOf(contextProvider3Gen).toEqualTypeOf<typeof contextProvider3>()
+  const contextProvider2Gen = ContextProvider(mergedGen)
+  const contextProvider3Gen = MergedContextProvider(MyContextProviderGen)
+  expectTypeOf(contextProvider2Gen).toEqualTypeOf<typeof someContextProvider>()
+  expectTypeOf(contextProvider3Gen).toEqualTypeOf<typeof contextProvider2Gen>()
 
-const merged2 = mergeContextProviders(MyContextProvider, MyContextProvider2)
-export const contextProvider22 = ContextProvider(merged2)
-export const contextProvider23 = MergedContextProvider(MyContextProvider, MyContextProvider2)
-expectTypeOf(contextProvider23).toEqualTypeOf<typeof contextProvider22>()
+  expectTypeOf(contextProvider2Gen).toEqualTypeOf<typeof contextProvider2>()
+  expectTypeOf(contextProvider3Gen).toEqualTypeOf<typeof contextProvider3>()
 
-const merged2Gen = mergeContextProviders(MyContextProviderGen, MyContextProvider2Gen)
-export const contextProvider22Gen = ContextProvider(merged2Gen)
-export const contextProvider23Gen = MergedContextProvider(MyContextProviderGen, MyContextProvider2Gen)
-expectTypeOf(contextProvider23Gen).toEqualTypeOf<typeof contextProvider22Gen>()
+  const merged2 = mergeContextProviders(MyContextProvider, MyContextProvider2)
+  const contextProvider22 = ContextProvider(merged2)
+  const contextProvider23 = MergedContextProvider(MyContextProvider, MyContextProvider2)
+  expectTypeOf(contextProvider23).toEqualTypeOf<typeof contextProvider22>()
 
-expectTypeOf(contextProvider22Gen).toEqualTypeOf<typeof contextProvider22>()
-expectTypeOf(contextProvider23Gen).toEqualTypeOf<typeof contextProvider23>()
+  const merged2Gen = mergeContextProviders(MyContextProviderGen, MyContextProvider2Gen)
+  const contextProvider22Gen = ContextProvider(merged2Gen)
+  const contextProvider23Gen = MergedContextProvider(MyContextProviderGen, MyContextProvider2Gen)
+  expectTypeOf(contextProvider23Gen).toEqualTypeOf<typeof contextProvider22Gen>()
+
+  expectTypeOf(contextProvider22Gen).toEqualTypeOf<typeof contextProvider22>()
+  expectTypeOf(contextProvider23Gen).toEqualTypeOf<typeof contextProvider23>()
+})

package/test/controller.test.ts

@@ -6,7 +6,7 @@ import { Context, Effect, type Layer, S, Scope } from "effect-app"
 import { InvalidStateError, makeRpcClient, NotLoggedInError, UnauthorizedError } from "effect-app/client"
 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"
+import { AllowAnonymous, CustomError1, RequestContextMap, RequireRoles, Some, SomeElse, SomeService, Test } from "./fixtures.js"
 
 // @effect-diagnostics-next-line missingEffectServiceDependency:off
 class MyContextProvider extends Middleware.Tag<MyContextProvider>()("MyContextProvider", {
@@ -55,7 +55,6 @@ class MyContextProvider2 extends Middleware.Tag<MyContextProvider2>()("MyContext
 const Str = Context.GenericTag<"str", "str">("str")
 
 export class BogusMiddleware extends Tag<BogusMiddleware>()("BogusMiddleware", {
-  provides: SomeService,
   wrap: true
 })({
   effect: Effect.gen(function*() {
@@ -64,7 +63,7 @@ export class BogusMiddleware extends Tag<BogusMiddleware>()("BogusMiddleware", {
     return ({ next }) =>
       Effect.gen(function*() {
         // yield* Effect.context<"test-dep2">()
-        return yield* next.pipe(Effect.provideService(SomeService, null as any))
+        return yield* next
       })
   })
 }) {
@@ -76,23 +75,59 @@ const genericMiddlewares = [
   MyContextProvider2
 ] as const
 
-const middleware = makeMiddleware<RequestContextMap>()
+const middleware = makeMiddleware<RequestContextMap>(RequestContextMap)
   .middleware(MyContextProvider)
   .middleware(
     RequireRoles,
     Test
   )
+  // AllowAnonymous provided after RequireRoles so that RequireRoles can access what AllowAnonymous provides
   .middleware(AllowAnonymous)
   .middleware(...genericMiddlewares)
-// dependencies: [Layer.effect(Str2, Str)],
 
-const middleware2 = makeMiddleware<RequestContextMap>()
+const middlewareBis = makeMiddleware<RequestContextMap>(RequestContextMap)
+  .middleware(MyContextProvider)
+  .middleware(
+    RequireRoles,
+    Test
+  )
+  // testing sideways elimination
+  .middleware(AllowAnonymous, ...genericMiddlewares)
+
+expectTypeOf(middleware).toEqualTypeOf<typeof middlewareBis>()
+
+const middlewareTrisWip = makeMiddleware<RequestContextMap>(RequestContextMap)
+  .middleware(
+    MyContextProvider,
+    RequireRoles,
+    Test
+  )
+  .missing
+
+expectTypeOf(middlewareTrisWip).toEqualTypeOf<{
+  missingDynamicMiddlewares: "allowAnonymous"
+  missingContext: SomeElse
+}>()
+
+// testing more sideways elimination]
+const middlewareQuater = makeMiddleware<RequestContextMap>(RequestContextMap)
+  .middleware(
+    MyContextProvider,
+    RequireRoles,
+    Test,
+    AllowAnonymous,
+    ...genericMiddlewares
+  )
+
+expectTypeOf(middleware).toEqualTypeOf<typeof middlewareQuater>()
+
+const middleware2 = makeMiddleware<RequestContextMap>(RequestContextMap)
   .middleware(MyContextProvider)
   .middleware(RequireRoles, Test)
   .middleware(AllowAnonymous)
   .middleware(...DefaultGenericMiddlewares, BogusMiddleware, MyContextProvider2)
 
-export const middleware3 = makeMiddleware<RequestContextMap>()
+export const middleware3 = makeMiddleware<RequestContextMap>(RequestContextMap)
   .middleware(...genericMiddlewares)
   .middleware(AllowAnonymous, RequireRoles)
   .middleware(Test)
@@ -246,7 +281,7 @@ it("sorts based on requirements", () => {
 
 // eslint-disable-next-line unused-imports/no-unused-vars
 const matched = matchAll({ router })
-expectTypeOf({} as Layer.Context<typeof matched>).toEqualTypeOf<SomeService | Some | "str">()
+expectTypeOf({} as Layer.Context<typeof matched>).toEqualTypeOf<SomeService | "str">()
 
 type makeContext = MakeContext<typeof router.make>
 expectTypeOf({} as MakeErrors<typeof router.make>).toEqualTypeOf<InvalidStateError>()
@@ -307,7 +342,7 @@ 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 | "str">()
+expectTypeOf({} as Layer.Context<typeof matched2>).toEqualTypeOf<SomeService | "str">()
 
 type makeContext2 = MakeContext<typeof router2.make>
 expectTypeOf({} as MakeErrors<typeof router2.make>).toEqualTypeOf<InvalidStateError>()

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

@@ -1 +1 @@
-{"version":3,"file":"contextProvider.test.d.ts","sourceRoot":"","sources":["../contextProvider.test.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAEnD,OAAO,EAAE,YAAY,EAAE,IAAI,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AA8EzE,eAAO,MAAM,mBAAmB;;CAkB9B,CAAA;AACF,eAAO,MAAM,sBAAsB;;CAkBjC,CAAA;AAMF,eAAO,MAAM,gBAAgB;;CAA0B,CAAA;AACvD,eAAO,MAAM,gBAAgB,kMAA2C,CAAA;AAIxE,eAAO,MAAM,mBAAmB;;CAA6B,CAAA;AAC7D,eAAO,MAAM,mBAAmB,kMAA8C,CAAA;AAQ9E,eAAO,MAAM,iBAAiB;;CAA2B,CAAA;AACzD,eAAO,MAAM,iBAAiB,6MAA+D,CAAA;AAI7F,eAAO,MAAM,oBAAoB;;CAA8B,CAAA;AAC/D,eAAO,MAAM,oBAAoB,6MAAqE,CAAA"}
+{"version":3,"file":"contextProvider.test.d.ts","sourceRoot":"","sources":["../contextProvider.test.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAEnD,OAAO,EAAE,YAAY,EAAE,IAAI,EAAY,WAAW,EAAE,MAAM,eAAe,CAAA;AA8EzE,eAAO,MAAM,mBAAmB;;CAkB9B,CAAA;AACF,eAAO,MAAM,sBAAsB;;CAkBjC,CAAA"}

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,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"}
+{"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,iBAAiB,EAAE,YAAY,EAAE,IAAI,EAAE,QAAQ,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,eAAe,CAAA;;;;;;AAgChI,cAAM,kBAAmB,SAAQ,uBAU/B;CAAG;;;;;;AAML,qBAAa,eAAgB,SAAQ,oBAYnC;CACD;AA4DD,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"}