Function makeRouter

packages/infra/src/routing.ts:238–790

(
  middlewareLive?: Live
)

  : never

export const makeRouter = <Live extends Layer.Layer<any, any, any> = Layer.Layer<any, never, never>>(
  middlewareLive?: Live
) => {
  type ResourceMWDefault = LayerNormalize<Live>

  /**
   * Create a Router for specified resource.
   * Middleware schema/tag is read from the request classes (stored via `makeRpcClient`).
   * The middleware **Live** layer is the one passed to `makeRouter`.
   * If `check` is provided, the router will only be created if the effect succeeds with true.
   */
  function matchFor<
    const Resource extends Record<string, any>,
    MW = MiddlewareOf<Resource>
  >(
    rsc: Resource & EnsureMiddlewareProvided<Live, MW>,
    options?: { check?: Effect.Effect<boolean> }
  ) {
    // MW is a defaulted type parameter so TypeScript evaluates MiddlewareOf<Resource>
    // eagerly at each call site, producing a concrete type instead of a deferred conditional.
    type ResourceRequestContextMap = RequestContextMapOf<MW>
    type ResourceContextProviderA = ProvidesOf<MW>

    type HandlerContext<Action extends AnyRequestModule> =
      | SafeGetEffectContext<ResourceRequestContextMap, Action["config"]>
      | ResourceContextProviderA

    type HandlerWithInputGen<
      Action extends AnyRequestModule,
      RT extends RequestType
    > = (
      req: Action["Type"]
    ) => Generator<
      Effect.Effect<
        any,
        GetFailure<Action>["Type"] | S.SchemaError,
        // the actual implementation of the handler may just require the dynamic context provided by the middleware
        // and the per request context provided by the context provider
        HandlerContext<Action>
      >,
      GetSuccessShape<Action, RT>,
      never
    >

    type HandlerWithInputEff<
      Action extends AnyRequestModule,
      RT extends RequestType
    > = (
      req: Action["Type"]
    ) => Effect.Effect<
      GetSuccessShape<Action, RT>,
      GetFailure<Action>["Type"] | S.SchemaError,
      // the actual implementation of the handler may just require the dynamic context provided by the middleware
      // and the per request context provided by the context provider
      HandlerContext<Action>
    >

    type HandlerWithInputStream<