@effect-app/infra 2.92.3 → 2.93.0

package/src/adapters/ServiceBus.ts

@@ -1,5 +1,5 @@
 /* eslint-disable @typescript-eslint/prefer-promise-reject-errors */
-import { type OperationOptionsBase, type ProcessErrorArgs, ServiceBusClient, type ServiceBusMessage, type ServiceBusMessageBatch, type ServiceBusReceivedMessage, type ServiceBusReceiver, type ServiceBusSender } from "@azure/service-bus"
+import { type OperationOptionsBase, type ProcessErrorArgs, ServiceBusClient, type ServiceBusMessage, type ServiceBusMessageBatch, type ServiceBusReceivedMessage, type ServiceBusReceiver } from "@azure/service-bus"
 import { Cause, Context, Effect, Exit, FiberSet, Layer, type Scope } from "effect-app"
 import { InfraLogger } from "../logger.js"
 
@@ -18,12 +18,13 @@ function makeClient(url: string) {
   )
 }
 
-const Client = Context.GenericTag<ServiceBusClient>("@services/Client")
-export const LiveServiceBusClient = (url: string) => Layer.scoped(Client)(makeClient(url))
+export class ServiceBusClientTag extends Context.Tag("@services/Client")<ServiceBusClientTag, ServiceBusClient>() {
+  static readonly layer = (url: string) => Layer.scoped(this, makeClient(url))
+}
 
-function makeSender(queueName: string) {
+function makeSender_(queueName: string) {
   return Effect.gen(function*() {
-    const serviceBusClient = yield* Client
+    const serviceBusClient = yield* ServiceBusClientTag
 
     return yield* Effect.acquireRelease(
       Effect.sync(() => serviceBusClient.createSender(queueName)).pipe(
@@ -33,112 +34,159 @@ function makeSender(queueName: string) {
     )
   })
 }
-export const Sender = Context.GenericTag<ServiceBusSender>("@services/Sender")
 
-export function LiveSender(queueName: string) {
-  return Layer
-    .scoped(Sender, makeSender(queueName))
+const makeSender = (name: string) =>
+  Effect.gen(function*() {
+    const sender = yield* makeSender_(name)
+    const sendMessages = Effect.fnUntraced(function*(
+      messages: ServiceBusMessage | ServiceBusMessage[] | ServiceBusMessageBatch,
+      options?: Omit<OperationOptionsBase, "abortSignal">
+    ) {
+      return yield* Effect.promise((abortSignal) => sender.sendMessages(messages, { ...options, abortSignal }))
+    })
+
+    return { name, sendMessages }
+  })
+
+export class Sender extends Context.TagId("Sender")<Sender, {
+  name: string
+  sendMessages: (
+    messages: ServiceBusMessage | ServiceBusMessage[] | ServiceBusMessageBatch,
+    options?: Omit<OperationOptionsBase, "abortSignal"> | undefined
+  ) => Effect.Effect<void, never, never>
+}>() {
+  static readonly layer = (name: string) => this.toLayerScoped(makeSender(name))
 }
 
-function makeReceiver(queueName: string, waitTillEmpty: Effect<void>, sessionId?: string) {
-  return Effect.gen(function*() {
-    const serviceBusClient = yield* Client
+export const SenderTag = <Id>() => <Key extends string>(queueName: Key) => {
+  const tag = Context.Tag(`ServiceBus.Sender.${queueName}`)<
+    Id,
+    Sender
+  >()
 
-    return yield* Effect.acquireRelease(
-      (sessionId
-        ? Effect.promise(() => serviceBusClient.acceptSession(queueName, sessionId))
-        : Effect.sync(() => serviceBusClient.createReceiver(queueName)))
-        .pipe(withSpanAndLog(`ServiceBus.receiver.create ${queueName}.${sessionId}`)),
-      (r) =>
-        waitTillEmpty.pipe(
-          withSpanAndLog(`ServiceBus.receiver.waitTillEmpty ${queueName}.${sessionId}`),
-          Effect.andThen(
-            Effect.promise(() => r.close()).pipe(withSpanAndLog(`ServiceBus.receiver.close ${queueName}.${sessionId}`))
-          ),
-          withSpanAndLog(`ServiceBus.receiver.release ${queueName}.${sessionId}`)
-        )
+  return Object.assign(tag, {
+    layer: Layer.scoped(
+      tag,
+      makeSender(queueName).pipe(Effect.map((_) => Sender.of(_)))
     )
   })
 }
 
-export class ServiceBusReceiverFactory extends Context.TagId(
-  "ServiceBusReceiverFactory"
-)<ServiceBusReceiverFactory, {
+const makeReceiver = (name: string) =>
+  Effect.gen(function*() {
+    const serviceBusClient = yield* ServiceBusClientTag
+
+    const makeReceiver = Effect.fnUntraced(
+      function*(queueName: string, waitTillEmpty: Effect<void>, sessionId?: string) {
+        return yield* Effect.acquireRelease(
+          (sessionId
+            ? Effect.promise(() => serviceBusClient.acceptSession(queueName, sessionId))
+            : Effect.sync(() => serviceBusClient.createReceiver(queueName)))
+            .pipe(withSpanAndLog(`ServiceBus.receiver.create ${queueName}.${sessionId}`)),
+          (r) =>
+            waitTillEmpty.pipe(
+              withSpanAndLog(`ServiceBus.receiver.waitTillEmpty ${queueName}.${sessionId}`),
+              Effect.andThen(
+                Effect.promise(() => r.close()).pipe(
+                  withSpanAndLog(`ServiceBus.receiver.close ${queueName}.${sessionId}`)
+                )
+              ),
+              withSpanAndLog(`ServiceBus.receiver.release ${queueName}.${sessionId}`)
+            )
+        )
+      }
+    )
+
+    const make = (waitTillEmpty: Effect<void>) => makeReceiver(name, waitTillEmpty)
+
+    const makeSession = (sessionId: string, waitTillEmpty: Effect<void>) => makeReceiver(name, waitTillEmpty, sessionId)
+
+    return {
+      name,
+      make,
+      makeSession,
+      subscribe: Effect.fnUntraced(function*<RMsg, RErr>(hndlr: MessageHandlers<RMsg, RErr>, sessionId?: string) {
+        const fs = yield* FiberSet.make()
+        const fr = yield* FiberSet.runtime(fs)<RMsg | RErr>()
+        const wait = Effect
+          .gen(function*() {
+            if ((yield* FiberSet.size(fs)) > 0) {
+              yield* InfraLogger.logDebug("Waiting ServiceBusFiberSet to be empty: " + (yield* FiberSet.size(fs)))
+            }
+            while ((yield* FiberSet.size(fs)) > 0) yield* Effect.sleep("250 millis")
+          })
+        const r = yield* sessionId
+          ? makeSession(
+            sessionId,
+            wait
+          )
+          : make(wait)
+
+        const runEffect = <E>(effect: Effect<void, E, RMsg | RErr>) =>
+          new Promise<void>((resolve, reject) =>
+            fr(effect)
+              .addObserver((exit) => {
+                if (Exit.isSuccess(exit)) {
+                  resolve(exit.value)
+                } else {
+                  // disable @typescript-eslint/prefer-promise-reject-errors
+                  reject(Cause.pretty(exit.cause, { renderErrorCause: true }))
+                }
+              })
+          )
+        yield* Effect.acquireRelease(
+          Effect
+            .sync(() =>
+              r
+                .subscribe({
+                  processError: (err) =>
+                    runEffect(
+                      hndlr
+                        .processError(err)
+                        .pipe(
+                          Effect.catchAllCause((cause) => Effect.logError(`ServiceBus Error ${sessionId}`, cause))
+                        )
+                    ),
+                  processMessage: (msg) => runEffect(hndlr.processMessage(msg))
+                  // DO NOT CATCH ERRORS here as they should return to the queue!
+                })
+            )
+            .pipe(withSpanAndLog(`ServiceBus.subscription.create ${sessionId}`)),
+          (subscription) =>
+            Effect.promise(() => subscription.close()).pipe(
+              withSpanAndLog(`ServiceBus.subscription.close ${sessionId}`)
+            )
+        )
+      })
+    }
+  })
+
+export class Receiver extends Context.TagId("Receiver")<Receiver, {
+  name: string
   make: (waitTillEmpty: Effect<void>) => Effect<ServiceBusReceiver, never, Scope>
   makeSession: (sessionId: string, waitTillEmpty: Effect<void>) => Effect<ServiceBusReceiver, never, Scope>
+  subscribe<RMsg, RErr>(
+    hndlr: MessageHandlers<RMsg, RErr>,
+    sessionId?: string
+  ): Effect.Effect<void, never, Scope.Scope | RMsg | RErr>
 }>() {
-  static readonly Live = (queueName: string) =>
-    this.toLayer(Client.pipe(Effect.andThen((cl) => ({
-      make: (waitTillEmpty: Effect<void>) =>
-        makeReceiver(queueName, waitTillEmpty).pipe(Effect.provideService(Client, cl)),
-      makeSession: (sessionId: string, waitTillEmpty: Effect<void>) =>
-        makeReceiver(queueName, waitTillEmpty, sessionId).pipe(Effect.provideService(Client, cl))
-    }))))
+  static readonly layer = (name: string) => this.toLayer(makeReceiver(name))
 }
 
-export function sendMessages(
-  messages: ServiceBusMessage | ServiceBusMessage[] | ServiceBusMessageBatch,
-  options?: OperationOptionsBase
-) {
-  return Effect.gen(function*() {
-    const s = yield* Sender
-    return yield* Effect.promise(() => s.sendMessages(messages, options))
-  })
-}
+export const ReceiverTag = <Id>() => <Key extends string>(queueName: Key) => {
+  const tag = Context.Tag(`ServiceBus.Receiver.${queueName}`)<Id, Receiver>()
 
-export function subscribe<RMsg, RErr>(hndlr: MessageHandlers<RMsg, RErr>, sessionId?: string) {
-  return Effect.gen(function*() {
-    const rf = yield* ServiceBusReceiverFactory
-    const fs = yield* FiberSet.make()
-    const fr = yield* FiberSet.runtime(fs)<RMsg | RErr>()
-    const wait = Effect
-      .gen(function*() {
-        if ((yield* FiberSet.size(fs)) > 0) {
-          yield* InfraLogger.logDebug("Waiting ServiceBusFiberSet to be empty: " + (yield* FiberSet.size(fs)))
-        }
-        while ((yield* FiberSet.size(fs)) > 0) yield* Effect.sleep("250 millis")
-      })
-    const r = yield* sessionId
-      ? rf.makeSession(
-        sessionId,
-        wait
-      )
-      : rf.make(wait)
-
-    const runEffect = <E>(effect: Effect<void, E, RMsg | RErr>) =>
-      new Promise<void>((resolve, reject) =>
-        fr(effect)
-          .addObserver((exit) => {
-            if (Exit.isSuccess(exit)) {
-              resolve(exit.value)
-            } else {
-              // disable @typescript-eslint/prefer-promise-reject-errors
-              reject(Cause.pretty(exit.cause, { renderErrorCause: true }))
-            }
-          })
-      )
-    yield* Effect.acquireRelease(
-      Effect
-        .sync(() =>
-          r
-            .subscribe({
-              processError: (err) =>
-                runEffect(
-                  hndlr
-                    .processError(err)
-                    .pipe(Effect.catchAllCause((cause) => Effect.logError(`ServiceBus Error ${sessionId}`, cause)))
-                ),
-              processMessage: (msg) => runEffect(hndlr.processMessage(msg))
-              // DO NOT CATCH ERRORS here as they should return to the queue!
-            })
-        )
-        .pipe(withSpanAndLog(`ServiceBus.subscription.create ${sessionId}`)),
-      (subscription) =>
-        Effect.promise(() => subscription.close()).pipe(withSpanAndLog(`ServiceBus.subscription.close ${sessionId}`))
+  return Object.assign(tag, {
+    layer: Layer.effect(
+      tag,
+      makeReceiver(queueName).pipe(Effect.map((_) => Receiver.of(_)))
     )
   })
 }
 
+export const SenderReceiver = (queue: string, queueDrain?: string) =>
+  Layer.mergeAll(Sender.layer(queue), Receiver.layer(queueDrain ?? queue))
+
 export interface MessageHandlers<RMsg, RErr> {
   /**
    * Handler that processes messages from service bus.

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

@@ -2,6 +2,7 @@
 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 TypeTestId } from "../../routing.js"
 import { type MiddlewareMaker, middlewareMaker } from "./generic-middleware.js"
 import { type AnyDynamic, type RpcDynamic, Tag, type TagClassAny } from "./RpcMiddleware.js"
 
@@ -103,7 +104,7 @@ export interface BuildingMiddleware<
     : never
 
   // helps debugging what are the missing requirements (type only)
-  missing: {
+  readonly [TypeTestId]: {
     missingDynamicMiddlewares: Exclude<keyof RequestContextMap, Provided>
     missingContext: MiddlewareR
   }

package/src/api/routing/middleware.ts

@@ -1,5 +1,4 @@
 // codegen:start {preset: barrel, include: ./middleware/*.ts, nodir: false }
-export * from "./middleware/dynamic-middleware.js"
 export * from "./middleware/generic-middleware.js"
 export * from "./middleware/middleware-api.js"
 export * from "./middleware/middleware.js"

package/src/api/routing.ts

@@ -2,7 +2,7 @@
 /* eslint-disable @typescript-eslint/no-unsafe-argument */
 /* eslint-disable @typescript-eslint/no-empty-object-type */
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { Rpc, RpcGroup, RpcServer } from "@effect/rpc"
+import { Rpc, RpcGroup, type RpcSerialization, RpcServer } from "@effect/rpc"
 import { type Array, Effect, Layer, type NonEmptyReadonlyArray, Predicate, S, Schema, type Scope } from "effect-app"
 import type { GetEffectContext, GetEffectError, RPCContextMap } from "effect-app/client/req"
 import { type HttpHeaders, HttpRouter } from "effect-app/http"
@@ -15,6 +15,14 @@ import { DevMode, type RouterMiddleware } from "./routing/middleware.js"
 
 export * from "./routing/middleware.js"
 
+// Nice way to underline types that are only there for type testing, not for production use
+// sadly with unique symbols we get weird issues in app projects.
+// api/src/X/PackList.Controllers.ts:21:1 - error TS4082: Default export of the module has or is using private name 'TypeTestId'
+// export const TypeTestId: unique symbol = Symbol.for("@effect/infra/type-test")
+// export type TypeTestId = typeof TypeTestId
+export const TypeTestId = "@effect-app/infra/type-test" as const
+export type TypeTestId = typeof TypeTestId
+
 // it's the result of extending S.Req setting success, config
 // it's a schema plus some metadata
 export type AnyRequestModule = S.Schema.Any & {
@@ -91,11 +99,6 @@ type FilterRequestModules<T> = {
   [K in keyof T as T[K] extends AnyRequestModule ? K : never]: T[K]
 }
 
-export const RouterSymbol = Symbol()
-export interface RouterShape<Resource> {
-  [RouterSymbol]: Resource
-}
-
 type RPCRouteR<
   T extends [any, (req: any, headers: HttpHeaders.Headers) => Effect<any, any, any>]
 > = T extends [
@@ -352,7 +355,12 @@ export const makeRouter = <
         match: any
       ) => Effect<THandlers, MakeE, MakeR> | Generator<YieldWrap<Effect<any, MakeE, MakeR>>, THandlers, any>
     ) => {
-      type Router = RouterShape<Resource>
+      const dependenciesL = Layer.mergeAll(...dependencies as any) as Layer.Layer<
+        LayerUtils.GetLayersSuccess<MakeDependencies>,
+        LayerUtils.GetLayersError<MakeDependencies>,
+        LayerUtils.GetLayersContext<MakeDependencies>
+      >
+
       const layer = Effect
         .gen(function*() {
           const finalMake = ((make as any)[Symbol.toStringTag] === "GeneratorFunction"
@@ -410,28 +418,29 @@ export const makeRouter = <
           const rpcs = RpcGroup
             .make(
               ...typedValuesOf(mapped).map(([resource]) => {
-                return Rpc.fromTaggedRequest(resource).annotate(middleware.requestContext, resource.config ?? {})
+                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[`${meta.moduleName}.${resource._tag}`] = handler
-              return acc
-            }, {} as Record<string, any>) as any // TODO
-          })) as unknown as Layer<
-            { [K in keyof RequestModules]: Rpc.Handler<K> },
-            | Layer.Error<typeof middleware.Default>
-            | LayerUtils.GetLayersError<MakeDependencies>,
-            | RPCRouteR<typeof mapped[keyof typeof mapped]>
-            | Layer.Context<typeof middleware.Default>
-            | LayerUtils.GetLayersContext<MakeDependencies>
-          >
+
+          const rpc = rpcs
+            .toLayer(Effect.gen(function*() {
+              return typedValuesOf(mapped).reduce((acc, [resource, handler]) => {
+                acc[`${meta.moduleName}.${resource._tag}`] = handler
+                return acc
+              }, {} as Record<string, any>) as any // TODO
+            })) as unknown as Layer<
+              { [K in keyof RequestModules]: Rpc.Handler<K> },
+              MakeE,
+              RPCRouteR<typeof mapped[keyof typeof mapped]>
+            >
 
           return RpcServer
             .layer(rpcs, { spanPrefix: "RpcServer." + meta.moduleName })
-            .pipe(Layer.provide(rpcLayer))
+            .pipe(Layer.provide(rpc))
             .pipe(
               Layer.provideMerge(
                 RpcServer.layerProtocolHttp(
@@ -442,24 +451,13 @@ export const makeRouter = <
         })
         .pipe(Layer.unwrapEffect)
 
-      // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
-      const routes = (
-        layer.pipe(
-          Layer.provide([
-            ...dependencies ?? [],
-            middleware.Default
-          ] as any) as any,
-          Layer.provide(Layer.succeed(DevMode, devMode))
-        )
-      ) as (Layer.Layer<
-        Router,
-        | LayerUtils.GetLayersError<MakeDependencies>
-        | MakeE
-        | Layer.Error<typeof middleware.Default>,
-        | LayerUtils.GetLayersContext<MakeDependencies>
-        | Layer.Context<typeof middleware.Default>
-        | Exclude<MakeR, LayerUtils.GetLayersSuccess<MakeDependencies>>
-      >)
+      const routes = layer.pipe(
+        Layer.provide([
+          dependenciesL,
+          middleware.Default
+        ]),
+        Layer.provide(Layer.succeed(DevMode, devMode))
+      )
 
       // Effect.Effect<HttpRouter.HttpRouter<unknown, HttpRouter.HttpRouter.DefaultServices>, never, UserRouter>
 
@@ -494,7 +492,7 @@ export const makeRouter = <
         moduleName: ModuleName
 
         routes: Layer.Layer<
-          RouterShape<Resource>,
+          never,
           | MakeErrors<Make>
           | Service.MakeDepsE<Make>
           | Layer.Error<typeof middleware.Default>,
@@ -504,169 +502,12 @@ export const makeRouter = <
             MakeContext<Make>,
             MakeDepsOut<Make>
           >
+          | RpcSerialization.RpcSerialization
         >
 
         // just for type testing purposes
-        make: Make
+        [TypeTestId]: Make
       }
-      // <
-      //   const Make extends {
-      //     dependencies?: Array<Layer.Layer.Any>
-      //     effect: (match: typeof router3) => Effect<
-      //       { [K in keyof FilterRequestModules<Resource>]: AnyHandler<Resource[K]> },
-      //       any,
-      //       any
-      //     >
-      //     /** @deprecated */
-      //     readonly ಠ_ಠ: never
-      //   }
-      // >(
-      //   make: Make
-      // ): {
-      //   moduleName: ModuleName
-
-      //   routes: Layer.Layer<
-      //     RouterShape<Resource>,
-      //     | MakeErrors<Make>
-      //     | Service.MakeDepsE<Make>
-      //     | Layer.Error<typeof middleware.Default>,
-      //     | Service.MakeDepsIn<Make>
-      //     | Layer.Context<typeof middleware.Default>
-      //     | Exclude<
-      //       MakeContext<Make>,
-      //       MakeDepsOut<Make>
-      //     >
-      //   >
-
-      //   // just for type testing purposes
-      //   make: Make
-      // }
-      // <
-      //   const Make extends {
-      //     dependencies?: Array<Layer.Layer.Any>
-      //     effect: (match: typeof router3) => Effect<
-      //       { [K in keyof FilterRequestModules<Resource>]: AnyHandler<Resource[K]> },
-      //       any,
-      //       any
-      //     >
-      //     /** @deprecated */
-      //     readonly ಠ_ಠ: never
-      //   }
-      // >(
-      //   make: Make
-      // ): {
-      //   moduleName: ModuleName
-
-      //   routes: Layer.Layer<
-      //     RouterShape<Resource>,
-      //     | MakeErrors<Make>
-      //     | Service.MakeDepsE<Make>
-      //     | Layer.Error<typeof middleware.Default>,
-      //     | Service.MakeDepsIn<Make>
-      //     | Layer.Context<typeof middleware.Default>
-      //     | Exclude<
-      //       MakeContext<Make>,
-      //       MakeDepsOut<Make>
-      //     >
-      //   >
-
-      //   // just for type testing purposes
-      //   make: Make
-      // }
-      // <
-      //   const Make extends {
-      //     dependencies?: Array<Layer.Layer.Any>
-      //     effect: (match: typeof router3) => Effect<
-      //       { [K in keyof FilterRequestModules<Resource>]: AnyHandler<Resource[K]> },
-      //       any,
-      //       any
-      //     >
-      //     /** @deprecated */
-      //     readonly ಠ_ಠ: never
-      //   }
-      // >(
-      //   make: Make
-      // ): {
-      //   moduleName: ModuleName
-
-      //   routes: Layer.Layer<
-      //     RouterShape<Resource>,
-      //     | MakeErrors<Make>
-      //     | Service.MakeDepsE<Make>
-      //     | Layer.Error<typeof middleware.Default>,
-      //     | Service.MakeDepsIn<Make>
-      //     | Layer.Context<typeof middleware.Default>
-      //     | Exclude<
-      //       MakeContext<Make>,
-      //       MakeDepsOut<Make>
-      //     >
-      //   >
-
-      //   // just for type testing purposes
-      //   make: Make
-      // }
-      // <
-      //   const Make extends {
-      //     dependencies?: Array<Layer.Layer.Any>
-      //     effect: (match: typeof router3) => Effect<
-      //       { [K in keyof FilterRequestModules<Resource>]: AnyHandler<Resource[K]> },
-      //       any,
-      //       any
-      //     >
-      //     /** @deprecated */
-      //     readonly ಠ_ಠ: never
-      //   }
-      // >(
-      //   make: Make
-      // ): {
-      //   moduleName: ModuleName
-
-      //   routes: Layer.Layer<
-      //     RouterShape<Resource>,
-      //     | MakeErrors<Make>
-      //     | Service.MakeDepsE<Make>
-      //     | Layer.Error<typeof middleware.Default>,
-      //     | Service.MakeDepsIn<Make>
-      //     | Layer.Context<typeof middleware.Default>
-      //     | Exclude<
-      //       MakeContext<Make>,
-      //       MakeDepsOut<Make>
-      //     >
-      //   >
-
-      //   // just for type testing purposes
-      //   make: Make
-      // }
-      // <
-      //   const Make extends {
-      //     dependencies?: Array<Layer.Layer.Any>
-      //     effect: (match: typeof router3) => Effect<
-      //       { [K in keyof FilterRequestModules<Resource>]: AnyHandler<Resource[K]> },
-      //       any,
-      //       any
-      //     >
-      //   }
-      // >(
-      //   make: Make
-      // ): {
-      //   moduleName: ModuleName
-
-      //   routes: Layer.Layer<
-      //     RouterShape<Resource>,
-      //     | MakeErrors<Make>
-      //     | Service.MakeDepsE<Make>
-      //     | Layer.Error<typeof middleware.Default>,
-      //     | Service.MakeDepsIn<Make>
-      //     | Layer.Context<typeof middleware.Default>
-      //     | Exclude<
-      //       MakeContext<Make>,
-      //       MakeDepsOut<Make>
-      //     >
-      //   >
-
-      //   // just for type testing purposes
-      //   make: Make
-      // }
       <
         const Make extends {
           dependencies?: Array<Layer.Layer.Any>
@@ -688,7 +529,7 @@ export const makeRouter = <
         moduleName: ModuleName
 
         routes: Layer.Layer<
-          RouterShape<Resource>,
+          never,
           | MakeErrors<Make>
           | Service.MakeDepsE<Make>
           | Layer.Error<typeof middleware.Default>,
@@ -698,39 +539,12 @@ export const makeRouter = <
             MakeContext<Make>,
             MakeDepsOut<Make>
           >
+          | RpcSerialization.RpcSerialization
         >
 
         // just for type testing purposes
-        make: Make
+        readonly [TypeTestId]: Make
       }
-      // <
-      //   const Make extends {
-      //     dependencies: [
-      //       ...Make["dependencies"],
-      //       ...Exclude<Effect.Context<ReturnType<Make["effect"]>>, MakeDepsOut<Make>> extends never ? []
-      //         : [Layer.Layer<Exclude<Effect.Context<ReturnType<Make["effect"]>>, MakeDepsOut<Make>>, never, never>]
-      //     ]
-      //     effect: (match: typeof router3) => Effect<
-      //       { [K in keyof FilterRequestModules<Resource>]: AnyHandler<Resource[K]> },
-      //       any,
-      //       any
-      //     >
-      //   }
-      // >(
-      //   make: Make
-      // ): {
-      //   moduleName: ModuleName
-      //   Router: HttpRouter.HttpRouter.TagClass<
-      //     RouterShape<Resource>,
-      //     `${ModuleName}Router`,
-      //     never,
-      //     never
-      //   >
-      //   routes: any
-
-      //   // just for type testing purposes
-      //   make: Make
-      // }
     } =
       ((make: { dependencies: any; effect: any }) =>
         Object.assign(makeRoutes(make.dependencies, make.effect), { make })) as any
@@ -741,8 +555,7 @@ export const makeRouter = <
   function matchAll<
     T extends {
       [key: string]: {
-        //      Router: { router: Effect<HttpRouter.HttpRouter<any, any>, any, any> }
-        routes: Layer.Layer<any, any, any>
+        routes: Layer.Layer<never, any, any>
         moduleName: string
       }
     }
@@ -755,7 +568,7 @@ export const makeRouter = <
       never,
       Layer.Layer.Error<typeof handlers[keyof typeof handlers]["routes"]>,
       Layer.Layer.Context<typeof handlers[keyof typeof handlers]["routes"]>
-    > // TODO
+    >
   }
 
   return {