@effect-app/infra 2.1.2 → 2.3.0

package/src/api/routing.ts

@@ -7,13 +7,26 @@ TODO: uninteruptible commands! was for All except GET.
 */
 import type * as HttpApp from "@effect/platform/HttpApp"
 import { Rpc, RpcRouter } from "@effect/rpc"
-import { Cause, Chunk, Context, Effect, FiberRef, Predicate, S, Schema, Stream } from "effect-app"
+import type { NonEmptyArray } from "effect-app"
+import {
+  Cause,
+  Chunk,
+  Context,
+  Effect,
+  FiberRef,
+  flow,
+  Layer,
+  Predicate,
+  S,
+  Schema,
+  Scope,
+  Stream,
+  Tracer
+} from "effect-app"
 import type { GetEffectContext, RPCContextMap } from "effect-app/client/req"
-import { allLower, type EffectUnunified, type LowerServices } from "effect-app/Effect"
 import type { HttpServerError } from "effect-app/http"
-import { HttpRouter, HttpServerRequest, HttpServerResponse } from "effect-app/http"
-import { pretty, typedKeysOf } from "effect-app/utils"
-import type { Compute } from "effect-app/utils"
+import { HttpMiddleware, HttpRouter, HttpServerRequest, HttpServerResponse } from "effect-app/http"
+import { pretty, typedKeysOf, typedValuesOf } from "effect-app/utils"
 import { logError, reportError } from "../errorReporter.js"
 import { InfraLogger } from "../logger.js"
 import type { Middleware } from "./routing/DynamicMiddleware.js"
@@ -79,39 +92,6 @@ export const toHttpApp = <R extends RpcRouter.RpcRouter<any, any>>(self: R, opti
   })
 }
 
-type GetRouteContext<CTXMap extends Record<string, RPCContextMap.Any>, T> =
-  // & CTX
-  // inverted
-  & {
-    [
-      key in keyof CTXMap as CTXMap[key][3] extends true ? never
-        : key extends keyof T ? T[key] extends true ? CTXMap[key][0] : never
-        : never
-    ]?: CTXMap[key][1]
-  }
-  & {
-    [
-      key in keyof CTXMap as CTXMap[key][3] extends true ? never
-        : key extends keyof T ? T[key] extends false ? CTXMap[key][0] : never
-        : CTXMap[key][0]
-    ]: CTXMap[key][1]
-  }
-  // normal
-  & {
-    [
-      key in keyof CTXMap as CTXMap[key][3] extends false ? never
-        : key extends keyof T ? T[key] extends true ? CTXMap[key][0] : never
-        : never
-    ]: CTXMap[key][1]
-  }
-  & {
-    [
-      key in keyof CTXMap as CTXMap[key][3] extends false ? never
-        : key extends keyof T ? T[key] extends false ? CTXMap[key][0] : never
-        : CTXMap[key][0]
-    ]?: CTXMap[key][1]
-  }
-
 export interface Hint<Err extends string> {
   Err: Err
 }
@@ -129,7 +109,7 @@ type GetSuccessShape<Action extends { success?: S.Schema.Any }, RT extends "d" |
   : S.Schema.Type<GetSuccess<Action>>
 type GetFailure<T extends { failure?: S.Schema.Any }> = T["failure"] extends never ? typeof S.Never : T["failure"]
 
-export interface Handler<Action extends AnyRequestModule, RT extends "raw" | "d", A, E, R> {
+type HandlerFull<Action extends AnyRequestModule, RT extends "raw" | "d", A, E, R> = {
   new(): {}
   _tag: RT
   stack: string
@@ -142,43 +122,126 @@ export interface Handler<Action extends AnyRequestModule, RT extends "raw" | "d"
   >
 }
 
-// Separate "raw" vs "d" to verify A (Encoded for "raw" vs Type for "d")
-type AHandler<Action extends AnyRequestModule> =
-  | Handler<
+export interface Handler<Action extends AnyRequestModule, RT extends "raw" | "d", R> extends
+  HandlerFull<
     Action,
-    "raw",
-    S.Schema.Encoded<GetSuccess<Action>>,
+    RT,
+    GetSuccessShape<Action, RT>,
     S.Schema.Type<GetFailure<Action>> | S.ParseResult.ParseError,
-    any
-  >
-  | Handler<
-    Action,
-    "d",
-    S.Schema.Type<GetSuccess<Action>>,
-    S.Schema.Type<GetFailure<Action>> | S.ParseResult.ParseError,
-    any
+    R
   >
+{
+}
+
+type AHandler<Action extends AnyRequestModule> = Handler<
+  Action,
+  any,
+  any
+>
 
 type Filter<T> = {
   [K in keyof T as T[K] extends S.Schema.All & { success: S.Schema.Any; failure: S.Schema.Any } ? K : never]: T[K]
 }
 
-export interface ExtendedMiddleware<Context, CTXMap extends Record<string, RPCContextMap.Any>>
-  extends Middleware<Context, CTXMap>
-{
-  // TODO
-  makeContext: Effect<
-    { [K in keyof CTXMap as CTXMap[K][1] extends never ? never : CTXMap[K][0]]: CTXMap[K][1] },
-    never,
-    never
+export const RouterSymbol = Symbol()
+export interface RouterShape<Rsc> {
+  [RouterSymbol]: Rsc
+}
+
+type RPCRouteR<T extends Rpc.Rpc<any, any>> = [T] extends [
+  Rpc.Rpc<any, infer R>
+] ? R
+  : never
+
+type RPCRouteReq<T extends Rpc.Rpc<any, any>> = [T] extends [
+  Rpc.Rpc<infer Req, any>
+] ? Req
+  : never
+
+type Match<
+  Rsc extends Record<string, any>,
+  CTXMap extends Record<string, any>,
+  RT extends "raw" | "d",
+  Key extends keyof Rsc,
+  Context
+> = {
+  // TODO: deal with HandleVoid and ability to extends from GetSuccessShape...
+  // aka we want to make sure that the return type is void if the success is void,
+  // and make sure A is the actual expected type
+
+  // note: the defaults of = never prevent the whole router to error
+  <A extends GetSuccessShape<Rsc[Key], RT>, R2 = never, E = never>(
+    f: Effect<A, E, R2>
+  ): HandleVoid<
+    GetSuccessShape<Rsc[Key], RT>,
+    A,
+    Handler<
+      Rsc[Key],
+      RT,
+      Exclude<
+        Context | Exclude<R2, GetEffectContext<CTXMap, Rsc[Key]["config"]>>,
+        HttpRouter.HttpRouter.Provided
+      >
+    >
+  >
+
+  <A extends GetSuccessShape<Rsc[Key], RT>, R2 = never, E = never>(
+    f: (req: S.Schema.Type<Rsc[Key]>) => Effect<A, E, R2>
+  ): HandleVoid<
+    GetSuccessShape<Rsc[Key], RT>,
+    A,
+    Handler<
+      Rsc[Key],
+      RT,
+      Exclude<
+        Context | Exclude<R2, GetEffectContext<CTXMap, Rsc[Key]["config"]>>,
+        HttpRouter.HttpRouter.Provided
+      >
+    >
   >
 }
 
-export const makeRouter = <Context, CTXMap extends Record<string, RPCContextMap.Any>>(
-  middleware: ExtendedMiddleware<Context, CTXMap>,
+export type RouteMatcher<
+  CTXMap extends Record<string, any>,
+  Rsc extends Record<string, any>,
+  Context
+> = {
+  // use Rsc as Key over using Keys, so that the Go To on X.Action remain in tact in Controllers files
+  /**
+   * Requires the Type shape
+   */
+  [Key in keyof Filter<Rsc>]: Match<Rsc, CTXMap, "d", Key, Context> & {
+    success: Rsc[Key]["success"]
+    successRaw: S.SchemaClass<S.Schema.Encoded<Rsc[Key]["success"]>>
+    failure: Rsc[Key]["failure"]
+    /**
+     * Requires the Encoded shape (e.g directly undecoded from DB, so that we don't do multiple Decode/Encode)
+     */
+    raw: Match<Rsc, CTXMap, "raw", Key, Context>
+  }
+}
+// export interface RouteMatcher<
+//   Filtered extends Record<string, any>,
+//   CTXMap extends Record<string, any>,
+//   Rsc extends Filtered
+// > extends RouteMatcherInt<Filtered, CTXMap, Rsc> {}
+
+export const makeMiddleware = <
+  Context,
+  CTXMap extends Record<string, RPCContextMap.Any>,
+  RMW,
+  Layers extends Array<Layer.Layer.Any>
+>(content: Middleware<Context, CTXMap, RMW, Layers>): Middleware<Context, CTXMap, RMW, Layers> => content
+
+export const makeRouter = <
+  Context,
+  CTXMap extends Record<string, RPCContextMap.Any>,
+  RMW,
+  Layers extends Array<Layer.Layer.Any>
+>(
+  middleware: Middleware<Context, CTXMap, RMW, Layers>,
   devMode: boolean
 ) => {
-  const rpc = makeRpc(middleware)
   function matchFor<
     const ModuleName extends string,
     const Rsc extends Record<string, any>
@@ -186,7 +249,6 @@ export const makeRouter = <Context, CTXMap extends Record<string, RPCContextMap.
     rsc: Rsc & { meta: { moduleName: ModuleName } }
   ) {
     const meta = rsc.meta
-
     type Filtered = Filter<Rsc>
     const filtered = typedKeysOf(rsc).reduce((acc, cur) => {
       if (Predicate.isObject(rsc[cur]) && rsc[cur]["success"]) {
@@ -195,311 +257,272 @@ export const makeRouter = <Context, CTXMap extends Record<string, RPCContextMap.
       return acc
     }, {} as Filtered)
 
-    const matchWithServices = <Key extends keyof Filtered>(action: Key) => {
-      return <
-        SVC extends Record<
-          string,
-          Effect<any, any, any>
-        >,
-        R2,
-        E,
-        A
-      >(
-        services: SVC,
-        f: (
-          req: S.Schema.Type<Rsc[Key]>,
-          ctx: Compute<
-            LowerServices<EffectDeps<SVC>> & GetRouteContext<CTXMap, Rsc[Key]["config"]> & {
-              Response: Rsc[Key]["success"]
-            },
-            "flat"
-          >
-        ) => Effect<A, E, R2>
-      ) =>
-      (req: any) =>
-        Effect.andThen(
-          Effect.all({ svc: allLower(services), ctx: middleware.makeContext }),
-          ({ ctx, svc }) => f(req, { ...svc, ...ctx, Response: rsc[action].success } as any)
-        )
-    }
-
-    type MatchWithServicesNew<RT extends "raw" | "d", Key extends keyof Rsc> = {
-      <R2, E, A>(
-        f: Effect<A, E, R2>
-      ): HandleVoid<
-        GetSuccessShape<Rsc[Key], RT>,
-        A,
-        Handler<
-          Rsc[Key],
-          RT,
-          A,
-          E,
-          Exclude<R2, GetEffectContext<CTXMap, Rsc[Key]["config"]>>
-        >
-      >
-
-      <R2, E, A>(
-        f: (
-          req: S.Schema.Type<Rsc[Key]>,
-          ctx: GetRouteContext<CTXMap, Rsc[Key]["config"]> & { Response: Rsc[Key]["success"] }
-        ) => Effect<A, E, R2>
-      ): HandleVoid<
-        GetSuccessShape<Rsc[Key], RT>,
-        A,
-        Handler<
-          Rsc[Key],
-          RT,
-          A,
-          E,
-          Exclude<R2, GetEffectContext<CTXMap, Rsc[Key]["config"]>>
-        >
-      >
-
-      <
-        SVC extends Record<
-          string,
-          EffectUnunified<any, any, any>
-        >,
-        R2,
-        E,
-        A
-      >(
-        services: SVC,
-        f: (
-          req: S.Schema.Type<Rsc[Key]>,
-          ctx: Compute<
-            LowerServices<EffectDeps<SVC>> & GetRouteContext<CTXMap, Rsc[Key]["config"]> & {
-              Response: Rsc[Key]["success"]
-            },
-            "flat"
-          >
-        ) => Effect<A, E, R2>
-      ): HandleVoid<
-        GetSuccessShape<Rsc[Key], RT>,
-        A,
-        Handler<
-          Rsc[Key],
-          RT,
-          A,
-          E,
-          Exclude<R2, GetEffectContext<CTXMap, Rsc[Key]["config"]>>
-        >
-      >
-    }
+    const items = typedKeysOf(filtered).reduce(
+      (prev, cur) => {
+        ;(prev as any)[cur] = Object.assign((fnOrEffect: any) => {
+          const stack = new Error().stack?.split("\n").slice(2).join("\n")
+          return Effect.isEffect(fnOrEffect)
+            ? class {
+              static stack = stack
+              static _tag = "d"
+              static handler = () => fnOrEffect
+            }
+            : class {
+              static stack = stack
+              static _tag = "d"
+              static handler = fnOrEffect
+            }
+        }, {
+          success: rsc[cur].success,
+          successRaw: S.encodedSchema(rsc[cur].success),
+          failure: rsc[cur].failure,
+          raw: // "Raw" variations are for when you don't want to decode just to encode it again on the response
+            // e.g for direct projection from DB
+            // but more importantly, to skip Effectful decoders, like to resolve relationships from the database or remote client.
+            (fnOrEffect: any) => {
+              const stack = new Error().stack?.split("\n").slice(2).join("\n")
+              return Effect.isEffect(fnOrEffect)
+                ? class {
+                  static stack = stack
+                  static _tag = "raw"
+                  static handler = () => fnOrEffect
+                }
+                : class {
+                  static stack = stack
+                  static _tag = "raw"
+                  static handler = (req: any, ctx: any) => fnOrEffect(req, { ...ctx, Response: rsc[cur].success })
+                }
+            }
+        })
+        return prev
+      },
+      {} as RouteMatcher<CTXMap, Rsc, Context>
+    )
 
     type Keys = keyof Filtered
 
-    const controllers = <
+    const effect = <
+      E,
+      R,
       THandlers extends {
         // import to keep them separate via | for type checking!!
         [K in Keys]: AHandler<Rsc[K]>
-      }
+      },
+      TLayers extends NonEmptyArray<Layer.Layer.Any>
     >(
-      controllers: THandlers
+      layers: TLayers,
+      make: (requests: typeof items) => Effect<THandlers, E, R>
     ) => {
-      const mapped = typedKeysOf(filtered).reduce((acc, cur) => {
-        const handler = controllers[cur as keyof typeof controllers]
-        const req = rsc[cur]
-
-        acc[cur] = rpc.effect(
-          handler._tag === "raw"
-            ? class extends (req as any) {
-              static success = S.encodedSchema(req.success)
-              get [Schema.symbolSerializable]() {
-                return this.constructor
-              }
-              get [Schema.symbolWithResult]() {
-                return {
-                  failure: req.failure,
-                  success: S.encodedSchema(req.success)
-                }
-              }
-            } as any
-            : req,
-          (req) =>
-            Effect
-              .annotateCurrentSpan(
-                "requestInput",
-                Object.entries(req).reduce((prev, [key, value]: [string, unknown]) => {
-                  prev[key] = key === "password"
-                    ? "<redacted>"
-                    : typeof value === "string" || typeof value === "number" || typeof value === "boolean"
-                    ? typeof value === "string" && value.length > 256
-                      ? (value.substring(0, 253) + "...")
-                      : value
-                    : Array.isArray(value)
-                    ? `Array[${value.length}]`
-                    : value === null || value === undefined
-                    ? `${value}`
-                    : typeof value === "object" && value
-                    ? `Object[${Object.keys(value).length}]`
-                    : typeof value
-                  return prev
-                }, {} as Record<string, string | number | boolean>)
-              )
-              .pipe(
-                // can't use andThen due to some being a function and effect
-                Effect.zipRight(handler.handler(req as any) as any),
-                Effect.tapErrorCause((cause) => Cause.isFailure(cause) ? logRequestError(cause) : Effect.void),
-                Effect.tapDefect((cause) =>
-                  Effect
-                    .all([
-                      reportRequestError(cause, {
-                        action: `${meta.moduleName}.${req._tag}`
-                      }),
-                      Rpc.currentHeaders.pipe(Effect.andThen((headers) => {
-                        return InfraLogger
-                          .logError("Finished request", cause)
-                          .pipe(Effect.annotateLogs({
-                            action: `${meta.moduleName}.${req._tag}`,
-                            req: pretty(req),
-                            headers: pretty(headers)
-                            // resHeaders: pretty(
-                            //   Object
-                            //     .entries(headers)
-                            //     .reduce((prev, [key, value]) => {
-                            //       prev[key] = value && typeof value === "string" ? snipString(value) : value
-                            //       return prev
-                            //     }, {} as Record<string, any>)
-                            // )
-                          }))
-                      }))
-                    ])
-                ),
-                devMode ? (_) => _ : Effect.catchAllDefect(() => Effect.die("Internal Server Error")),
-                Effect.withSpan("Request." + meta.moduleName + "." + req._tag, {
-                  captureStackTrace: () => handler.stack
-                })
-              ),
-          meta.moduleName
-        ) // TODO
-        return acc
-      }, {} as any) as {
-        [K in Keys]: Rpc.Rpc<
-          Rsc[K],
-          _R<ReturnType<THandlers[K]["handler"]>>
+      type ProvidedLayers =
+        | { [k in keyof Layers]: Layer.Layer.Success<Layers[k]> }[number]
+        | { [k in keyof TLayers]: Layer.Layer.Success<TLayers[k]> }[number]
+      type Router = RouterShape<Rsc>
+      const r: HttpRouter.HttpRouter.TagClass<
+        Router,
+        `${typeof meta.moduleName}Router`,
+        never,
+        Exclude<
+          | Context
+          | RPCRouteR<
+            { [K in keyof Filter<Rsc>]: Rpc.Rpc<Rsc[K], _R<ReturnType<THandlers[K]["handler"]>>> }[keyof Filter<Rsc>]
+          >,
+          | ProvidedLayers
+          | HttpRouter.HttpRouter.Provided
         >
-      }
-
-      type RPCRouteR<T extends Rpc.Rpc<any, any>> = [T] extends [
-        Rpc.Rpc<any, infer R>
-      ] ? R
-        : never
+      > = (class Router extends HttpRouter.Tag(`${meta.moduleName}Router`)<Router>() {}) as any
+
+      const layer = r.use((router) =>
+        Effect.gen(function*() {
+          const controllers = yield* make(items)
+          const rpc = yield* makeRpc(middleware)
+
+          // return make.pipe(Effect.map((c) => controllers(c, layers)))
+          const mapped = typedKeysOf(filtered).reduce((acc, cur) => {
+            const handler = controllers[cur as keyof typeof controllers]
+            const req = rsc[cur]
+
+            acc[cur] = rpc.effect(
+              handler._tag === "raw"
+                ? class extends (req as any) {
+                  static success = S.encodedSchema(req.success)
+                  get [Schema.symbolSerializable]() {
+                    return this.constructor
+                  }
+                  get [Schema.symbolWithResult]() {
+                    return {
+                      failure: req.failure,
+                      success: S.encodedSchema(req.success)
+                    }
+                  }
+                } as any
+                : req,
+              (req) =>
+                Effect
+                  .annotateCurrentSpan(
+                    "requestInput",
+                    Object.entries(req).reduce((prev, [key, value]: [string, unknown]) => {
+                      prev[key] = key === "password"
+                        ? "<redacted>"
+                        : typeof value === "string" || typeof value === "number" || typeof value === "boolean"
+                        ? typeof value === "string" && value.length > 256
+                          ? (value.substring(0, 253) + "...")
+                          : value
+                        : Array.isArray(value)
+                        ? `Array[${value.length}]`
+                        : value === null || value === undefined
+                        ? `${value}`
+                        : typeof value === "object" && value
+                        ? `Object[${Object.keys(value).length}]`
+                        : typeof value
+                      return prev
+                    }, {} as Record<string, string | number | boolean>)
+                  )
+                  .pipe(
+                    // can't use andThen due to some being a function and effect
+                    Effect.zipRight(handler.handler(req as any) as any),
+                    Effect.tapErrorCause((cause) => Cause.isFailure(cause) ? logRequestError(cause) : Effect.void),
+                    Effect.tapDefect((cause) =>
+                      Effect
+                        .all([
+                          reportRequestError(cause, {
+                            action: `${meta.moduleName}.${req._tag}`
+                          }),
+                          Rpc.currentHeaders.pipe(Effect.andThen((headers) => {
+                            return InfraLogger
+                              .logError("Finished request", cause)
+                              .pipe(Effect.annotateLogs({
+                                action: `${meta.moduleName}.${req._tag}`,
+                                req: pretty(req),
+                                headers: pretty(headers)
+                                // resHeaders: pretty(
+                                //   Object
+                                //     .entries(headers)
+                                //     .reduce((prev, [key, value]) => {
+                                //       prev[key] = value && typeof value === "string" ? snipString(value) : value
+                                //       return prev
+                                //     }, {} as Record<string, any>)
+                                // )
+                              }))
+                          }))
+                        ])
+                    ),
+                    devMode ? (_) => _ : Effect.catchAllDefect(() => Effect.die("Internal Server Error")),
+                    Effect.withSpan("Request." + meta.moduleName + "." + req._tag, {
+                      captureStackTrace: () => handler.stack
+                    })
+                  ),
+              meta.moduleName
+            ) // TODO
+            return acc
+          }, {} as any) as {
+            [K in Keys]: Rpc.Rpc<
+              Rsc[K],
+              Context | _R<ReturnType<THandlers[K]["handler"]>>
+            >
+          }
 
-      type RPCRouteReq<T extends Rpc.Rpc<any, any>> = [T] extends [
-        Rpc.Rpc<infer Req, any>
-      ] ? Req
-        : never
+          const rpcRouter = RpcRouter.make(...Object.values(mapped) as any) as RpcRouter.RpcRouter<
+            RPCRouteReq<typeof mapped[keyof typeof mapped]>,
+            RPCRouteR<typeof mapped[keyof typeof mapped]>
+          >
+          const httpApp = toHttpApp(rpcRouter, {
+            spanPrefix: rsc
+              .meta
+              .moduleName + "."
+          })
+          const services = (yield* Effect.context<never>()).pipe(
+            Context.omit(Scope.Scope as never),
+            Context.omit(Tracer.ParentSpan as never)
+          )
+          yield* router
+            .all(
+              "/",
+              (httpApp
+                .pipe(HttpMiddleware.make(Effect.provide(services)))) as any,
+              // TODO: not queries.
+              { uninterruptible: true }
+            )
+        })
+      )
 
-      const router = RpcRouter.make(...Object.values(mapped) as any) as RpcRouter.RpcRouter<
-        RPCRouteReq<typeof mapped[keyof typeof mapped]>,
-        RPCRouteR<typeof mapped[keyof typeof mapped]>
+      // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
+      const routes = layer.pipe(
+        Layer.provideMerge(r.Live),
+        layers ? Layer.provide(layers) as any : (_) => _,
+        Layer.provide(middleware.dependencies as any)
+      ) as Layer.Layer<
+        Router,
+        { [k in keyof TLayers]: Layer.Layer.Error<TLayers[k]> }[number] | E,
+        | { [k in keyof TLayers]: Layer.Layer.Context<TLayers[k]> }[number]
+        | Exclude<
+          RMW | R,
+          ProvidedLayers
+        >
       >
 
-      return HttpRouter.empty.pipe(
-        HttpRouter.all(
-          ("/rpc/" + rsc.meta.moduleName) as any,
-          toHttpApp(router, { spanPrefix: rsc.meta.moduleName + "." }),
-          // TODO: not queries.
-          { uninterruptible: true }
-        )
-      )
-    }
+      // Effect.Effect<HttpRouter.HttpRouter<unknown, HttpRouter.HttpRouter.DefaultServices>, never, UserRouter>
 
-    const r = {
-      controllers,
-      ...typedKeysOf(filtered).reduce(
-        (prev, cur) => {
-          ;(prev as any)[cur] = (svcOrFnOrEffect: any, fnOrNone: any) => {
-            const stack = new Error().stack?.split("\n").slice(2).join("\n")
-            return Effect.isEffect(svcOrFnOrEffect)
-              ? class {
-                static stack = stack
-                static _tag = "d"
-                static handler = () => svcOrFnOrEffect
-              }
-              : typeof svcOrFnOrEffect === "function"
-              ? class {
-                static stack = stack
-                static _tag = "d"
-                static handler = (req: any) =>
-                  Effect.andThen(
-                    Effect.all({ ctx: middleware.makeContext }),
-                    ({ ctx }) => svcOrFnOrEffect(req, { ...ctx, Response: rsc[cur].success })
-                  )
-              }
-              : class {
-                static stack = stack
-                static _tag = "d"
-                static handler = matchWithServices(cur)(svcOrFnOrEffect, fnOrNone)
-              }
-          } // "Raw" variations are for when you don't want to decode just to encode it again on the response
-           // e.g for direct projection from DB
-          // but more importantly, to skip Effectful decoders, like to resolve relationships from the database or remote client.
-          ;(prev as any)[(cur as any) + "Raw"] = (svcOrFnOrEffect: any, fnOrNone: any) => {
-            const stack = new Error().stack?.split("\n").slice(2).join("\n")
-            return Effect.isEffect(svcOrFnOrEffect)
-              ? class {
-                static stack = stack
-                static _tag = "raw"
-                static handler = () => svcOrFnOrEffect
-              }
-              : typeof svcOrFnOrEffect === "function"
-              ? class {
-                static stack = stack
-                static _tag = "raw"
-                static handler = (req: any, ctx: any) => svcOrFnOrEffect(req, { ...ctx, Response: rsc[cur].success })
-              }
-              : class {
-                static stack = stack
-                static _tag = "raw"
-                static handler = matchWithServices(cur)(svcOrFnOrEffect, fnOrNone)
-              }
-          }
-          return prev
-        },
-        {} as
-          & {
-            // use Rsc as Key over using Keys, so that the Go To on X.Action remain in tact in Controllers files
-            /**
-             * Requires the Type shape
-             */
-            [Key in keyof Filtered]: MatchWithServicesNew<"d", Key>
-          }
-          & {
-            // use Rsc as Key over using Keys, so that the Go To on X.Action remain in tact in Controllers files
-            /**
-             * Requires the Encoded shape (e.g directly undecoded from DB, so that we don't do multiple Decode/Encode)
-             */
-            [Key in keyof Filtered as Key extends string ? `${Key}Raw` : never]: MatchWithServicesNew<"raw", Key>
-          }
-      )
+      return {
+        moduleName: meta.moduleName,
+        Router: r,
+        routes
+      }
     }
-    return r
+
+    return effect
   }
 
+  type HR<T> = T extends HttpRouter.HttpRouter<any, infer R> ? R : never
+  type HE<T> = T extends HttpRouter.HttpRouter<infer E, any> ? E : never
+
   type RequestHandlersTest = {
-    [key: string]: HttpRouter.HttpRouter<any, any>
+    [key: string]: {
+      Router: { router: Effect<HttpRouter.HttpRouter<any, any>, any, any> }
+      routes: Layer.Layer<any, any, any>
+      moduleName: string
+    }
   }
-  function matchAll<T extends RequestHandlersTest>(handlers: T) {
-    const r = typedKeysOf(handlers).reduce((acc, cur) => {
-      return HttpRouter.concat(acc, handlers[cur] as any)
-    }, HttpRouter.empty)
-
-    type _RRouter<T extends HttpRouter.HttpRouter<any, any>> = [T] extends [
-      HttpRouter.HttpRouter<any, infer R>
-    ] ? R
-      : never
-
-    type _ERouter<T extends HttpRouter.HttpRouter<any, any>> = [T] extends [
-      HttpRouter.HttpRouter<infer E, any>
-    ] ? E
-      : never
-
-    return r as HttpRouter.HttpRouter<
-      _ERouter<typeof handlers[keyof typeof handlers]>,
-      _RRouter<typeof handlers[keyof typeof handlers]>
-    >
+  function matchAll<T extends RequestHandlersTest, A, E, R>(
+    handlers: T,
+    requestLayer: Layer.Layer<A, E, R>
+  ) {
+    const routers = typedValuesOf(handlers)
+
+    const rootRouter = class extends HttpRouter.Tag("RootRouter")<
+      "RootRouter",
+      HR<Effect.Success<typeof handlers[keyof typeof handlers]["Router"]["router"]>>,
+      HE<Effect.Success<typeof handlers[keyof typeof handlers]["Router"]["router"]>>
+    >() {}
+
+    const r = rootRouter
+      .use((router) =>
+        Effect.gen(function*() {
+          for (const route of routers) {
+            yield* router.mount(
+              ("/rpc/" + route.moduleName) as any,
+              yield* route
+                .Router
+                .router
+                .pipe(Effect.map(HttpRouter.use(flow(Effect.provide(requestLayer))))) as any
+            )
+          }
+        })
+      )
+      .pipe(Layer.provide(routers.map((r) => r.routes).flat() as unknown as NonEmptyArray<Layer.Layer.Any>))
+
+    return {
+      layer: r as Layer.Layer<
+        never,
+        Layer.Layer.Error<typeof handlers[keyof typeof handlers]["routes"]>,
+        Layer.Layer.Context<typeof handlers[keyof typeof handlers]["routes"]>
+      >,
+      Router: rootRouter as any as HttpRouter.HttpRouter.TagClass<
+        "RootRouter",
+        "RootRouter",
+        HE<Effect.Success<typeof handlers[keyof typeof handlers]["Router"]["router"]>>,
+        R | Exclude<HR<Effect.Success<typeof handlers[keyof typeof handlers]["Router"]["router"]>>, A>
+      >
+    }
   }
 
   return { matchAll, matchFor }