@effect-app/infra 2.87.2 → 2.89.0

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

@@ -1,199 +1,230 @@
-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 MiddlewareMakerId, 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>
-  >
+/* 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
+>(rcm: RequestContextMap, key: Key): RpcDynamic<Key, RequestContextMap[Key]> => ({
+  key,
+  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"))
 }
 
-type GetDependsOnKeys<MW extends GenericMiddlewareMaker> = MW extends { dependsOn: NonEmptyReadonlyArray<TagClassAny> }
-  ? {
+// 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 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
 
-export interface MiddlewareDynamic<
-  RequestContext extends Record<string, RPCContextMap.Any>,
-  Provided extends keyof RequestContext,
-  Middlewares extends ReadonlyArray<GenericMiddlewareMaker>,
+type FilterInDynamicMiddlewares<
+  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]
+    : never
+}
+
+type RecursiveHandleMWsSideways<
+  MWs,
+  R extends {
+    rcm: Record<string, RPCContextMap.Any>
+    provided: keyof R["rcm"] // that's fine
+    middlewares: ReadonlyArray<MiddlewareMaker>
+    dmp: any
+    middlewareR: any
+  }
+> = MWs extends [
+  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
+    // (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: MiddlewareMaker.ApplyManyServices<[F], R["middlewareR"]>
+  }>
+  : R
+
+export interface BuildingMiddleware<
+  RequestContextMap extends Record<string, RPCContextMap.Any>,
+  Provided extends keyof RequestContextMap,
+  Middlewares extends ReadonlyArray<MiddlewareMaker>,
   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<MiddlewareMaker>>(
+    ...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<MiddlewareMaker>
+    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,
-  Middlewares extends ReadonlyArray<GenericMiddlewareMaker> = [],
+export type MiddlewaresBuilder<
+  RequestContextMap extends Record<string, RPCContextMap.Any>,
+  Provided extends keyof RequestContextMap = never,
+  Middlewares extends ReadonlyArray<MiddlewareMaker> = [],
   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> = () => {
-  let allMiddleware: GenericMiddlewareMaker[] = []
+>(rcm: RequestContextMap) => MiddlewaresBuilder<RequestContextMap> = (rcm) => {
+  let allMiddleware: MiddlewareMaker[] = []
   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 interface MiddlewareMakerId {
+  readonly _id: unique symbol
+}
+
+// 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>,
-    // RequestContextProviders extends RequestContextMapProvider<RequestContextMap>, // how to resolve the dynamic middleware
-    GenericMiddlewareProviders extends ReadonlyArray<GenericMiddlewareMaker>
+    MiddlewareProviders extends ReadonlyArray<MiddlewareMaker>
   >(
-    ...make: GenericMiddlewareProviders
+    _rcm: RequestContextMap,
+    ...make: MiddlewareProviders
   ) => {
-    const MiddlewareMaker = Context.GenericTag<
-      MiddlewareMakerId,
-      {
-        effect: RPCHandlerFactory<
-          RequestContextMap,
-          GenericMiddlewareMaker.Provided<GenericMiddlewareProviders[number]>
+    // reverse middlewares and wrap one after the other
+    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"]>
         >
-        _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 })
+    // add to the tag a default implementation
+    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/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/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

@@ -1,8 +1,8 @@
 /* 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 { ContextProvider, mergeContextProviders, MergedContextProvider } from "../src/api/ContextProvider.js"
 import { CustomError1, Some, SomeElse, SomeService } from "./fixtures.js"
 
 // @effect-diagnostics-next-line missingEffectServiceDependency:off
@@ -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>()
+})