@effect-app/infra 2.88.0 → 2.89.1

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,37 +112,32 @@ 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
 > =
-  //  keyof Omit<RequestContextMap, Provided> extends never is true when all the dynamic middlewares are provided
+  & BuildingMiddleware<
+    RequestContextMap,
+    Provided,
+    Middlewares,
+    DynamicMiddlewareProviders,
+    MiddlewareR
+  >
+  & //  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<
+  (keyof Omit<RequestContextMap, Provided> extends never ? [MiddlewareR] extends [never] ? ReturnType<
         typeof makeMiddlewareBasic<
           RequestContextMap,
           Middlewares
         >
       >
-    : BuildingMiddleware<
-      RequestContextMap,
-      Provided,
-      Middlewares,
-      DynamicMiddlewareProviders,
-      MiddlewareR
-    >
-    : BuildingMiddleware<
-      RequestContextMap,
-      Provided,
-      Middlewares,
-      DynamicMiddlewareProviders,
-      MiddlewareR
-    >
+    : {}
+    : {})
 
 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 +155,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/controller.test.ts

@@ -76,23 +76,22 @@ const genericMiddlewares = [
 ] as const
 
 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(MyContextProvider)
   .middleware(...genericMiddlewares)
 
 const middlewareBis = makeMiddleware<RequestContextMap>(RequestContextMap)
-  .middleware(MyContextProvider)
   .middleware(
     RequireRoles,
     Test
   )
   // testing sideways elimination
-  .middleware(AllowAnonymous, ...genericMiddlewares)
+  .middleware(AllowAnonymous, MyContextProvider, ...genericMiddlewares)
 
 expectTypeOf(middleware).toEqualTypeOf<typeof middlewareBis>()
 
@@ -112,10 +111,10 @@ expectTypeOf(middlewareTrisWip).toEqualTypeOf<{
 // testing more sideways elimination]
 const middlewareQuater = makeMiddleware<RequestContextMap>(RequestContextMap)
   .middleware(
-    MyContextProvider,
     RequireRoles,
     Test,
     AllowAnonymous,
+    MyContextProvider,
     ...genericMiddlewares
   )
 

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,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"}
+{"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;AA2DD,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

@@ -37,7 +37,7 @@ declare const Some_base: (abstract new (service: {
 } & {
     use: <X>(body: (_: {
         a: number;
-    }) => X) => X extends Effect.Effect<infer A, infer E_1, infer R_3> ? Effect.Effect<A, E_1, Some | R_3> : Effect.Effect<X, never, Some>;
+    }) => X) => X extends Effect.Effect<infer A, infer E_1, infer R_3> ? Effect.Effect<A, E_1, R_3 | Some> : Effect.Effect<X, never, Some>;
 };
 export declare class Some extends Some_base {
 }
@@ -63,7 +63,7 @@ declare const SomeElse_base: (abstract new (service: {
 } & {
     use: <X>(body: (_: {
         b: number;
-    }) => X) => X extends Effect.Effect<infer A, infer E_1, infer R_3> ? Effect.Effect<A, E_1, R_3 | SomeElse> : Effect.Effect<X, never, SomeElse>;
+    }) => X) => X extends Effect.Effect<infer A, infer E_1, infer R_3> ? Effect.Effect<A, E_1, SomeElse | R_3> : Effect.Effect<X, never, SomeElse>;
 };
 export declare class SomeElse extends SomeElse_base {
 }

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"}