@effect-app/infra 2.87.1 → 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/src/api/routing.ts

@@ -8,6 +8,7 @@ import { type Array, Effect, Layer, type NonEmptyReadonlyArray, Predicate, S, Sc
 import type { GetEffectContext, GetEffectError, RPCContextMap } from "effect-app/client/req"
 import { type HttpHeaders, HttpRouter } from "effect-app/http"
 import { typedKeysOf, typedValuesOf } from "effect-app/utils"
+import { type Service } from "effect/Effect"
 import type { Contravariant } from "effect/Types"
 import { type YieldWrap } from "effect/Utils"
 import { type LayerUtils } from "./layerUtils.js"
@@ -493,10 +494,16 @@ export const makeRouter = <
       // Multiple times duplicated the "good" overload, so that errors will only mention the last overload when failing
       <
         const Make extends {
-          dependencies: Array<Layer.Layer.Any>
+          dependencies?: Array<Layer.Layer.Any>
           effect: (match: typeof router3) => Generator<
             YieldWrap<
-              Effect<any, any, Make["strict"] extends false ? any : LayerUtils.GetLayersSuccess<Make["dependencies"]>>
+              Effect<
+                any,
+                any,
+                Make["strict"] extends false ? any
+                  : Make extends { dependencies: Array<Layer.Layer.Any> } ? MakeDepsOut<Make>
+                  : any
+              >
             >,
             { [K in keyof FilterRequestModules<Resource>]: AnyHandler<Resource[K]> },
             any
@@ -514,13 +521,13 @@ export const makeRouter = <
         routes: Layer.Layer<
           RouterShape<Resource>,
           | MakeErrors<Make>
-          | LayerUtils.GetLayersError<Make["dependencies"]>
+          | Service.MakeDepsE<Make>
           | Layer.Error<typeof middleware.Default>,
-          | LayerUtils.GetLayersContext<Make["dependencies"]>
+          | Service.MakeDepsIn<Make>
           | Layer.Context<typeof middleware.Default>
           | Exclude<
             MakeContext<Make>,
-            LayerUtils.GetLayersSuccess<Make["dependencies"]>
+            MakeDepsOut<Make>
           >
         >
 
@@ -529,11 +536,13 @@ export const makeRouter = <
       }
       <
         const Make extends {
-          dependencies: Array<Layer.Layer.Any>
+          dependencies?: Array<Layer.Layer.Any>
           effect: Effect<
             { [K in keyof FilterRequestModules<Resource>]: AnyHandler<Resource[K]> },
             any,
-            Make["strict"] extends false ? any : LayerUtils.GetLayersSuccess<Make["dependencies"]>
+            Make["strict"] extends false ? any
+              : Make extends { dependencies: Array<Layer.Layer.Any> } ? MakeDepsOut<Make>
+              : any
           >
           strict?: boolean
           /** @deprecated */
@@ -547,13 +556,13 @@ export const makeRouter = <
         routes: Layer.Layer<
           RouterShape<Resource>,
           | MakeErrors<Make>
-          | LayerUtils.GetLayersError<Make["dependencies"]>
+          | Service.MakeDepsE<Make>
           | Layer.Error<typeof middleware.Default>,
-          | LayerUtils.GetLayersContext<Make["dependencies"]>
+          | Service.MakeDepsIn<Make>
           | Layer.Context<typeof middleware.Default>
           | Exclude<
             MakeContext<Make>,
-            LayerUtils.GetLayersSuccess<Make["dependencies"]>
+            MakeDepsOut<Make>
           >
         >
 
@@ -562,11 +571,11 @@ export const makeRouter = <
       }
       <
         const Make extends {
-          dependencies: Array<Layer.Layer.Any>
+          dependencies?: Array<Layer.Layer.Any>
           effect: Effect<
             { [K in keyof FilterRequestModules<Resource>]: AnyHandler<Resource[K]> },
             any,
-            Make["strict"] extends false ? any : LayerUtils.GetLayersSuccess<Make["dependencies"]>
+            Make["strict"] extends false ? any : MakeDepsOut<Make>
           >
           strict?: boolean
           /** @deprecated */
@@ -580,13 +589,13 @@ export const makeRouter = <
         routes: Layer.Layer<
           RouterShape<Resource>,
           | MakeErrors<Make>
-          | LayerUtils.GetLayersError<Make["dependencies"]>
+          | Service.MakeDepsE<Make>
           | Layer.Error<typeof middleware.Default>,
-          | LayerUtils.GetLayersContext<Make["dependencies"]>
+          | Service.MakeDepsIn<Make>
           | Layer.Context<typeof middleware.Default>
           | Exclude<
             MakeContext<Make>,
-            LayerUtils.GetLayersSuccess<Make["dependencies"]>
+            MakeDepsOut<Make>
           >
         >
 
@@ -595,11 +604,11 @@ export const makeRouter = <
       }
       <
         const Make extends {
-          dependencies: Array<Layer.Layer.Any>
+          dependencies?: Array<Layer.Layer.Any>
           effect: Effect<
             { [K in keyof FilterRequestModules<Resource>]: AnyHandler<Resource[K]> },
             any,
-            Make["strict"] extends false ? any : LayerUtils.GetLayersSuccess<Make["dependencies"]>
+            Make["strict"] extends false ? any : MakeDepsOut<Make>
           >
           strict?: boolean
           /** @deprecated */
@@ -613,13 +622,13 @@ export const makeRouter = <
         routes: Layer.Layer<
           RouterShape<Resource>,
           | MakeErrors<Make>
-          | LayerUtils.GetLayersError<Make["dependencies"]>
+          | Service.MakeDepsE<Make>
           | Layer.Error<typeof middleware.Default>,
-          | LayerUtils.GetLayersContext<Make["dependencies"]>
+          | Service.MakeDepsIn<Make>
           | Layer.Context<typeof middleware.Default>
           | Exclude<
             MakeContext<Make>,
-            LayerUtils.GetLayersSuccess<Make["dependencies"]>
+            MakeDepsOut<Make>
           >
         >
 
@@ -628,11 +637,11 @@ export const makeRouter = <
       }
       <
         const Make extends {
-          dependencies: Array<Layer.Layer.Any>
+          dependencies?: Array<Layer.Layer.Any>
           effect: Effect<
             { [K in keyof FilterRequestModules<Resource>]: AnyHandler<Resource[K]> },
             any,
-            LayerUtils.GetLayersSuccess<Make["dependencies"]>
+            MakeDepsOut<Make>
           >
           strict?: boolean
           /** @deprecated */
@@ -646,13 +655,13 @@ export const makeRouter = <
         routes: Layer.Layer<
           RouterShape<Resource>,
           | MakeErrors<Make>
-          | LayerUtils.GetLayersError<Make["dependencies"]>
+          | Service.MakeDepsE<Make>
           | Layer.Error<typeof middleware.Default>,
-          | LayerUtils.GetLayersContext<Make["dependencies"]>
+          | Service.MakeDepsIn<Make>
           | Layer.Context<typeof middleware.Default>
           | Exclude<
             MakeContext<Make>,
-            LayerUtils.GetLayersSuccess<Make["dependencies"]>
+            MakeDepsOut<Make>
           >
         >
 
@@ -661,11 +670,11 @@ export const makeRouter = <
       }
       <
         const Make extends {
-          dependencies: Array<Layer.Layer.Any>
+          dependencies?: Array<Layer.Layer.Any>
           effect: Effect<
             { [K in keyof FilterRequestModules<Resource>]: AnyHandler<Resource[K]> },
             any,
-            LayerUtils.GetLayersSuccess<Make["dependencies"]>
+            MakeDepsOut<Make>
           >
           strict?: boolean
         }
@@ -677,13 +686,13 @@ export const makeRouter = <
         routes: Layer.Layer<
           RouterShape<Resource>,
           | MakeErrors<Make>
-          | LayerUtils.GetLayersError<Make["dependencies"]>
+          | Service.MakeDepsE<Make>
           | Layer.Error<typeof middleware.Default>,
-          | LayerUtils.GetLayersContext<Make["dependencies"]>
+          | Service.MakeDepsIn<Make>
           | Layer.Context<typeof middleware.Default>
           | Exclude<
             MakeContext<Make>,
-            LayerUtils.GetLayersSuccess<Make["dependencies"]>
+            MakeDepsOut<Make>
           >
         >
 
@@ -692,10 +701,16 @@ export const makeRouter = <
       }
       <
         const Make extends {
-          dependencies: Array<Layer.Layer.Any>
+          dependencies?: Array<Layer.Layer.Any>
           effect: (match: typeof router3) => Generator<
             YieldWrap<
-              Effect<any, any, Make["strict"] extends false ? any : LayerUtils.GetLayersSuccess<Make["dependencies"]>>
+              Effect<
+                any,
+                any,
+                Make["strict"] extends false ? any
+                  : Make extends { dependencies: Array<Layer.Layer.Any> } ? MakeDepsOut<Make>
+                  : any
+              >
             >,
             { [K in keyof FilterRequestModules<Resource>]: AnyHandler<Resource[K]> },
             any
@@ -711,13 +726,13 @@ export const makeRouter = <
         routes: Layer.Layer<
           RouterShape<Resource>,
           | MakeErrors<Make>
-          | LayerUtils.GetLayersError<Make["dependencies"]>
+          | Service.MakeDepsE<Make>
           | Layer.Error<typeof middleware.Default>,
-          | LayerUtils.GetLayersContext<Make["dependencies"]>
+          | Service.MakeDepsIn<Make>
           | Layer.Context<typeof middleware.Default>
           | Exclude<
             MakeContext<Make>,
-            LayerUtils.GetLayersSuccess<Make["dependencies"]>
+            MakeDepsOut<Make>
           >
         >