@effect-app/infra 2.93.0 → 3.0.0

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

@@ -1,10 +1,15 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
+import { Rpc, type RpcGroup, type RpcMiddleware, type RpcSchema } from "@effect/rpc"
 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 HandlersFrom } from "@effect/rpc/RpcGroup"
+import { Tag } from "@effect/rpc/RpcMiddleware"
+import { Context, type Effect, Layer, type NonEmptyArray, type NonEmptyReadonlyArray, S, type Schema, type Scope, type Stream } from "effect-app"
+import { type GetContextConfig, type GetEffectContext, type RPCContextMap } from "effect-app/client"
+import { typedValuesOf } from "effect-app/utils"
+import { type ReadonlyMailbox } from "effect/Mailbox"
 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"
+import { type MiddlewareMaker, middlewareMaker, type RequestContextTag } from "./generic-middleware.js"
+import { type AnyDynamic, type RpcDynamic, type TagClassAny } from "./RpcMiddleware.js"
 
 /** Adapter used when setting the dynamic prop on a middleware implementation */
 export const contextMap = <
@@ -15,26 +20,27 @@ export const contextMap = <
   settings: { service: rcm[key]!["service"] } as RequestContextMap[Key]
 })
 
+const tag = Context.GenericTag("RequestContextConfig")
 /** 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"))
+  return Context.getOrElse(rpc.annotations, tag as any, () => ({}))
 }
 
 // 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 MiddlewareMaker> = MW extends { dependsOn: NonEmptyReadonlyArray<TagClassAny> } ? {
+type GetDependsOnKeys<MW extends MiddlewareMaker.Any> = 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<MiddlewareMaker>,
+  MWs extends ReadonlyArray<MiddlewareMaker.Any>,
   RequestContextMap extends Record<string, RPCContextMap.Any>
 > = {
   [K in keyof MWs]: MWs[K] extends { dynamic: RpcDynamic<any, RequestContextMap[keyof RequestContextMap]> } ? MWs[K]
@@ -46,13 +52,13 @@ type RecursiveHandleMWsSideways<
   R extends {
     rcm: Record<string, RPCContextMap.Any>
     provided: keyof R["rcm"] // that's fine
-    middlewares: ReadonlyArray<MiddlewareMaker>
+    middlewares: ReadonlyArray<MiddlewareMaker.Any>
     dmp: any
     middlewareR: any
   }
 > = MWs extends [
-  infer F extends MiddlewareMaker,
-  ...infer Rest extends ReadonlyArray<MiddlewareMaker>
+  infer F extends MiddlewareMaker.Any,
+  ...infer Rest extends ReadonlyArray<MiddlewareMaker.Any>
 ] ? RecursiveHandleMWsSideways<Rest, {
     rcm: R["rcm"]
     // when one dynamic middleware depends on another, subtract the key to enforce the dependency to be provided after
@@ -76,11 +82,36 @@ type RecursiveHandleMWsSideways<
 export interface BuildingMiddleware<
   RequestContextMap extends Record<string, RPCContextMap.Any>,
   Provided extends keyof RequestContextMap,
-  Middlewares extends ReadonlyArray<MiddlewareMaker>,
+  Middlewares extends ReadonlyArray<MiddlewareMaker.Any>,
   DynamicMiddlewareProviders,
   out MiddlewareR extends { _tag: string } = never
 > {
-  middleware<MWs extends NonEmptyArray<MiddlewareMaker>>(
+  rpc: <
+    const Tag extends string,
+    Payload extends Schema.Schema.Any | Schema.Struct.Fields = typeof Schema.Void,
+    Success extends Schema.Schema.Any = typeof Schema.Void,
+    Error extends Schema.Schema.All = typeof Schema.Never,
+    const Stream extends boolean = false,
+    Config extends GetContextConfig<RequestContextMap> = {}
+  >(tag: Tag, options?: {
+    readonly payload?: Payload
+    readonly success?: Success
+    readonly error?: Error
+    readonly stream?: Stream
+    readonly config?: Config
+    readonly primaryKey?: [Payload] extends [Schema.Struct.Fields]
+      ? ((payload: Schema.Simplify<Schema.Struct.Type<NoInfer<Payload>>>) => string)
+      : never
+  }) =>
+    & Rpc.Rpc<
+      Tag,
+      Payload extends Schema.Struct.Fields ? Schema.Struct<Payload> : Payload,
+      Stream extends true ? RpcSchema.Stream<Success, Error> : Success,
+      Stream extends true ? typeof Schema.Never : Error
+    >
+    & { readonly config: Config }
+
+  middleware<MWs extends NonEmptyArray<MiddlewareMaker.Any>>(
     ...mw: MWs
   ): RecursiveHandleMWsSideways<MWs, {
     rcm: RequestContextMap
@@ -91,7 +122,7 @@ export interface BuildingMiddleware<
   }> extends infer Res extends {
     rcm: RequestContextMap
     provided: keyof RequestContextMap
-    middlewares: ReadonlyArray<MiddlewareMaker>
+    middlewares: ReadonlyArray<MiddlewareMaker.Any>
     dmp: any
     middlewareR: any
   } ? MiddlewaresBuilder<
@@ -113,7 +144,7 @@ export interface BuildingMiddleware<
 export type MiddlewaresBuilder<
   RequestContextMap extends Record<string, RPCContextMap.Any>,
   Provided extends keyof RequestContextMap = never,
-  Middlewares extends ReadonlyArray<MiddlewareMaker> = [],
+  Middlewares extends ReadonlyArray<MiddlewareMaker.Any> = [],
   DynamicMiddlewareProviders = unknown,
   MiddlewareR extends { _tag: string } = never
 > =
@@ -126,50 +157,20 @@ export type MiddlewaresBuilder<
   >
   & //  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<
-          RequestContextMap,
-          Middlewares
-        >
+  (keyof Omit<RequestContextMap, Provided> extends never ? [MiddlewareR] extends [never] ? MiddlewareMaker<
+        RequestContextMap,
+        Middlewares
       >
     : {}
     : {})
 
-export const makeMiddleware: <
-  RequestContextMap extends Record<string, RPCContextMap.Any>
->(rcm: RequestContextMap) => MiddlewaresBuilder<RequestContextMap> = (rcm) => {
-  let allMiddleware: MiddlewareMaker[] = []
-  const it = {
-    middleware: (...middlewares: any[]) => {
-      for (const mw of middlewares) {
-        // recall that we run middlewares in reverse order
-        allMiddleware = [mw, ...allMiddleware]
-      }
-      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 interface MiddlewareMakerId {
-  readonly _id: unique symbol
-}
-
-// 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>,
-    MiddlewareProviders extends ReadonlyArray<MiddlewareMaker>
+    MiddlewareProviders extends ReadonlyArray<MiddlewareMaker.Any>
   >(
-    _rcm: RequestContextMap,
+    rcm: RequestContextMap,
     ...make: MiddlewareProviders
   ) => {
     // reverse middlewares and wrap one after the other
@@ -201,26 +202,203 @@ const makeMiddlewareBasic =
         ],
       provides: (provides.length > 0
         ? provides
-        : undefined) as unknown as MiddlewareMaker.ManyProvided<MiddlewareProviders> extends never ? never : [
-          MakeTags<MiddlewareMaker.ManyProvided<MiddlewareProviders>>
-        ],
+        : undefined) as unknown as MiddlewareMaker.ManyProvided<MiddlewareProviders> extends never ? never
+          : MakeTags<MiddlewareMaker.ManyProvided<MiddlewareProviders>>,
       wrap: true
-    })(
-      middleware as {
-        dependencies: typeof middleware["dependencies"]
-        effect: Effect<
+    })
+
+    const layer = Layer
+      .scoped(
+        MiddlewareMaker,
+        middleware as Effect<
           any, // TODO: why ?
-          Effect.Error<typeof middleware["effect"]>,
-          Effect.Context<typeof middleware["effect"]>
+          Effect.Error<typeof middleware>,
+          Effect.Context<typeof middleware>
         >
-      }
-    )
+      )
 
     // add to the tag a default implementation
     return Object.assign(MiddlewareMaker, {
+      layer,
       // tag to be used to retrieve the RequestContextConfig from RPC annotations
       requestContext: Context.GenericTag<"RequestContextConfig", GetContextConfig<RequestContextMap>>(
         "RequestContextConfig"
-      )
+      ),
+      requestContextMap: rcm
     })
   }
+
+export const makeMiddleware = <
+  RequestContextMap extends Record<string, RPCContextMap.Any>
+>(rcm: RequestContextMap): MiddlewaresBuilder<RequestContextMap> => {
+  let allMiddleware: MiddlewareMaker.Any[] = []
+  const requestContext = Context.GenericTag<"RequestContextConfig", GetContextConfig<RequestContextMap>>(
+    "RequestContextConfig"
+  )
+  const it = {
+    // rpc with config
+    rpc: <
+      const Tag extends string,
+      Payload extends Schema.Schema.Any | Schema.Struct.Fields = typeof Schema.Void,
+      Success extends Schema.Schema.Any = typeof Schema.Void,
+      Error extends Schema.Schema.All = typeof Schema.Never,
+      const Stream extends boolean = false,
+      Config extends GetContextConfig<RequestContextMap> = {}
+    >(tag: Tag, options?: {
+      readonly payload?: Payload
+      readonly success?: Success
+      readonly error?: Error
+      readonly stream?: Stream
+      readonly config?: Config
+      readonly primaryKey?: [Payload] extends [Schema.Struct.Fields]
+        ? ((payload: Schema.Simplify<Schema.Struct.Type<NoInfer<Payload>>>) => string)
+        : never
+    }):
+      & Rpc.Rpc<
+        Tag,
+        Payload extends Schema.Struct.Fields ? Schema.Struct<Payload> : Payload,
+        // TODO: enhance `Error`. type based on middleware config.
+        Stream extends true ? RpcSchema.Stream<Success, Error> : Success,
+        Stream extends true ? typeof Schema.Never : Error
+      >
+      & { config: Config } =>
+    {
+      const config = options?.config ?? {} as Config
+
+      // based on the config, we must enhance (union) or set failures.
+      // TODO: we should only include errors that are relevant based on the middleware config.ks
+      const error = options?.error
+      const errors = typedValuesOf(rcm).map((_) => _.error).filter((_) => _ && _ !== S.Never) // TODO: only the errors relevant based on config
+      const newError = error ? S.Union(error, ...errors) : S.Union(...errors)
+
+      const rpc = Rpc.make(tag, { ...options, error: newError }) as any
+
+      return Object.assign(rpc.annotate(requestContext, config), { config })
+    },
+    middleware: (...middlewares: any[]) => {
+      for (const mw of middlewares) {
+        // recall that we run middlewares in reverse order
+        allMiddleware = [mw, ...allMiddleware]
+      }
+      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
+}
+
+// customised version of Rpc.AddMiddleware, so that we don't loose the `config`...
+// not needed if there's official support in Rpc.Rpc.
+export type AddMiddleware<R extends Rpc.Any, Middleware extends RpcMiddleware.TagClassAny> = R extends Rpc.Rpc<
+  infer _Tag,
+  infer _Payload,
+  infer _Success,
+  infer _Error,
+  infer _Middleware
+> ?
+    & Rpc.Rpc<
+      _Tag,
+      _Payload,
+      _Success,
+      _Error,
+      _Middleware | Middleware
+    >
+    & { readonly config: R extends { readonly config: infer _C } ? _C : never }
+  : never
+
+// alternatively consider group.serverMiddleware? hmmm
+export const middlewareGroup = <
+  RequestContextMap extends Record<string, RPCContextMap.Any>,
+  Middleware extends Context.Tag<MiddlewareMakerId, any> & RpcMiddleware.TagClassAny & {
+    readonly requestContext: RequestContextTag<RequestContextMap>
+    readonly requestContextMap: RequestContextMap
+  }
+>(
+  middleware: Middleware
+) =>
+<R extends Rpc.Any>(group: RpcGroup.RpcGroup<R>) => {
+  type RN = AddMiddleware<R, typeof middleware>
+  const middlewaredGroup = group.middleware(middleware) as unknown as RpcGroup.RpcGroup<RN>
+  const toLayerOriginal = middlewaredGroup.toLayer.bind(middlewaredGroup)
+  return Object.assign(middlewaredGroup, {
+    toLayerDynamic: <
+      Handlers extends HandlersFrom<RN>,
+      EX = never,
+      RX = never
+    >(
+      build:
+        | Handlers
+        | Effect.Effect<Handlers, EX, RX>
+    ): Layer.Layer<
+      Rpc.ToHandler<RN>,
+      EX,
+      | Exclude<RX, Scope>
+      | HandlersContext<RN, Handlers>
+    > => {
+      return toLayerOriginal(build as any) as any // ??
+    }
+  })
+}
+
+// customized versions to handle dynamically eliminated context.
+export type HandlersContext<Rpcs extends Rpc.Any, Handlers> = keyof Handlers extends infer K
+  ? K extends keyof Handlers & string ? HandlerContext<Rpcs, K, Handlers[K]> : never
+  : never
+
+export type HandlerContext<Rpcs extends Rpc.Any, K extends Rpcs["_tag"], Handler> = [Rpc.IsStream<Rpcs, K>] extends
+  [true] ? Handler extends (...args: any) =>
+    | Stream.Stream<infer _A, infer _E, infer _R>
+    | Rpc.Fork<Stream.Stream<infer _A, infer _E, infer _R>>
+    | Effect.Effect<
+      ReadonlyMailbox<infer _A, infer _E>,
+      infer _EX,
+      infer _R
+    >
+    | Rpc.Fork<
+      Effect.Effect<
+        ReadonlyMailbox<infer _A, infer _E>,
+        infer _EX,
+        infer _R
+      >
+    > ? Exclude<ExcludeProvides<_R, Rpcs, K>, Scope>
+  : never
+  : Handler extends (
+    ...args: any
+  ) => Effect.Effect<infer _A, infer _E, infer _R> | Rpc.Fork<Effect.Effect<infer _A, infer _E, infer _R>>
+    ? ExcludeProvides<_R, Rpcs, K>
+  : never
+
+// new
+export type ExtractDynamicallyProvides<R extends Rpc.Any, Tag extends string> = R extends
+  Rpc.Rpc<Tag, infer _Payload, infer _Success, infer _Error, infer _Middleware> ? _Middleware extends {
+    readonly requestContextMap: infer _RC
+  } ? _RC extends Record<string, RPCContextMap.Any> // ? GetEffectContext<_RC, { allowAnonymous: false }>
+      ? R extends { readonly config: infer _C } ? GetEffectContext<_RC, _C>
+      : GetEffectContext<_RC, {}>
+    : never
+  : never
+  : never
+
+export type ExtractProvides<R extends Rpc.Any, Tag extends string> = R extends
+  Rpc.Rpc<Tag, infer _Payload, infer _Success, infer _Error, infer _Middleware> ? _Middleware extends {
+    readonly provides: Context.Tag<infer _I, infer _S>
+  } ? _I
+  : never
+  : never
+
+export type ExcludeProvides<Env, R extends Rpc.Any, Tag extends string> = Exclude<
+  Env,
+  // customisation is down here.
+  ExtractProvides<R, Tag> | ExtractDynamicallyProvides<R, Tag>
+>
+
+//
+export interface MiddlewareMakerId {
+  readonly _id: unique symbol
+}
+
+// TODO: actually end up with [Tag<A, A>, Tag<B, B>, ...] once `provides: []` is implemented
+export type MakeTags<A> = Context.Tag<A, A>

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

@@ -0,0 +1,23 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { RpcMiddleware } from "@effect/rpc"
+import { Context } from "effect-app"
+
+export class DevMode extends Context.Reference<DevMode>()("DevMode", { defaultValue: () => false }) {}
+
+export class RequestCacheMiddleware
+  extends RpcMiddleware.Tag<RequestCacheMiddleware>()("RequestCacheMiddleware", { wrap: true })
+{}
+
+export class ConfigureInterruptibilityMiddleware
+  extends RpcMiddleware.Tag<ConfigureInterruptibilityMiddleware>()("ConfigureInterruptibilityMiddleware", {
+    wrap: true
+  })
+{}
+
+export class LoggerMiddleware extends RpcMiddleware.Tag<LoggerMiddleware>()("LoggerMiddleware", { wrap: true }) {}
+
+export const DefaultGenericMiddlewares = [
+  RequestCacheMiddleware,
+  ConfigureInterruptibilityMiddleware,
+  LoggerMiddleware
+] as const

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

@@ -1,14 +1,15 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { Cause, Context, Duration, Effect, Layer, ParseResult, Request, Schedule, type Schema } from "effect-app"
+import { Cause, Duration, Effect, Layer, ParseResult, Request, Schedule, type Schema } from "effect"
 import { pretty } from "effect-app/utils"
 import { logError, reportError } from "../../../errorReporter.js"
 import { InfraLogger } from "../../../logger.js"
 import { determineMethod, isCommand } from "../utils.js"
-import { Tag } from "./RpcMiddleware.js"
+import * as MiddlewareNative from "./middleware-native.js"
 
 const logRequestError = logError("Request")
 const reportRequestError = reportError("Request")
 
+export { DevMode } from "./middleware-native.js"
+
 export const RequestCacheLayers = Layer.mergeAll(
   Layer.setRequestCache(
     Request.makeCache({ capacity: 500, timeToLive: Duration.hours(8) })
@@ -17,46 +18,43 @@ export const RequestCacheLayers = Layer.mergeAll(
   Layer.setRequestBatching(true)
 )
 
-export class DevMode extends Context.Reference<DevMode>()("DevMode", { defaultValue: () => false }) {}
-
-export class RequestCacheMiddleware extends Tag<RequestCacheMiddleware>()("RequestCacheMiddleware", { wrap: true })({
-  effect: Effect.succeed(({ next }) => next.pipe(Effect.provide(RequestCacheLayers)))
-}) {
-}
+export const RequestCacheMiddlewareLive = Layer.succeed(
+  MiddlewareNative.RequestCacheMiddleware,
+  ({ next }) => next.pipe(Effect.provide(RequestCacheLayers))
+)
 
 // retry just once on optimistic concurrency exceptions
 const optimisticConcurrencySchedule = Schedule.once.pipe(
   Schedule.intersect(Schedule.recurWhile<any>((a) => a?._tag === "OptimisticConcurrencyException"))
 )
 
-export class ConfigureInterruptibilityMiddleware
-  extends Tag<ConfigureInterruptibilityMiddleware>()("ConfigureInterruptibilityMiddleware", { wrap: true })({
-    effect: Effect.gen(function*() {
-      const cache = new Map()
-      const getCached = (key: string, schema: Schema.Schema.Any) => {
-        const existing = cache.get(key)
-        if (existing) return existing
-        const n = determineMethod(key, schema)
-        cache.set(key, n)
-        return n
-      }
-      return ({ next, rpc }) => {
-        const method = getCached(rpc._tag, rpc.payloadSchema)
+export const ConfigureInterruptibilityMiddlewareLive = Layer.effect(
+  MiddlewareNative.ConfigureInterruptibilityMiddleware,
+  Effect.gen(function*() {
+    const cache = new Map()
+    const getCached = (key: string, schema: Schema.Schema.Any) => {
+      const existing = cache.get(key)
+      if (existing) return existing
+      const n = determineMethod(key, schema)
+      cache.set(key, n)
+      return n
+    }
+    return ({ next, rpc }) => {
+      const method = getCached(rpc._tag, rpc.payloadSchema)
 
-        next = isCommand(method)
-          ? Effect.retry(Effect.uninterruptible(next), optimisticConcurrencySchedule)
-          : Effect.interruptible(next)
+      next = isCommand(method)
+        ? Effect.retry(Effect.uninterruptible(next), optimisticConcurrencySchedule)
+        : Effect.interruptible(next)
 
-        return next
-      }
-    })
+      return next
+    }
   })
-{
-}
+)
 
-export class LoggerMiddleware extends Tag<LoggerMiddleware>()("LoggerMiddleware", { wrap: true })({
-  effect: Effect.gen(function*() {
-    const devMode = yield* DevMode
+export const LoggerMiddlewareLive = Layer.effect(
+  MiddlewareNative.LoggerMiddleware,
+  Effect.gen(function*() {
+    const devMode = yield* MiddlewareNative.DevMode
     return ({ headers, next, payload, rpc }) =>
       Effect
         .annotateCurrentSpan({
@@ -112,11 +110,10 @@ export class LoggerMiddleware extends Tag<LoggerMiddleware>()("LoggerMiddleware"
           devMode ? (_) => _ : Effect.catchAllDefect(() => Effect.die("Internal Server Error"))
         )
   })
-}) {
-}
+)
 
-export const DefaultGenericMiddlewares = [
-  RequestCacheMiddleware,
-  ConfigureInterruptibilityMiddleware,
-  LoggerMiddleware
-] as const
+export const DefaultGenericMiddlewaresLive = Layer.mergeAll(
+  RequestCacheMiddlewareLive,
+  ConfigureInterruptibilityMiddlewareLive,
+  LoggerMiddlewareLive
+)

package/src/api/routing/middleware.ts

@@ -4,6 +4,7 @@ export * from "./middleware/middleware-api.js"
 export * from "./middleware/middleware.js"
 export * from "./middleware/RouterMiddleware.js"
 export * from "./middleware/RpcMiddleware.js"
+export * from "./middleware/RpcMiddlewareX.js"
 // codegen:end
 
 export * as Middleware from "./middleware.js"

package/src/api/routing.ts

@@ -5,7 +5,7 @@
 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"
+import { type HttpHeaders } from "effect-app/http"
 import { typedKeysOf, typedValuesOf } from "effect-app/utils"
 import { type Service } from "effect/Effect"
 import type { Contravariant } from "effect/Types"
@@ -158,8 +158,6 @@ export type RouteMatcher<
     }
 }
 
-export class Router extends HttpRouter.Tag("@effect-app/Rpc")<Router>() {}
-
 export const makeRouter = <
   RequestContextMap extends Record<string, RPCContextMap.Any>,
   MakeMiddlewareE,
@@ -439,15 +437,13 @@ export const makeRouter = <
             >
 
           return RpcServer
-            .layer(rpcs, { spanPrefix: "RpcServer." + meta.moduleName })
+            .layerHttpRouter({
+              spanPrefix: "RpcServer." + meta.moduleName,
+              group: rpcs,
+              path: ("/rpc/" + meta.moduleName) as `/${typeof meta.moduleName}`,
+              protocol: "http"
+            })
             .pipe(Layer.provide(rpc))
-            .pipe(
-              Layer.provideMerge(
-                RpcServer.layerProtocolHttp(
-                  { path: ("/" + meta.moduleName) as `/${typeof meta.moduleName}`, routerTag: Router }
-                )
-              )
-            )
         })
         .pipe(Layer.unwrapEffect)
 
@@ -459,8 +455,6 @@ export const makeRouter = <
         Layer.provide(Layer.succeed(DevMode, devMode))
       )
 
-      // Effect.Effect<HttpRouter.HttpRouter<unknown, HttpRouter.HttpRouter.DefaultServices>, never, UserRouter>
-
       return {
         moduleName: meta.moduleName,
         routes

package/test/contextProvider.test.ts

@@ -12,7 +12,7 @@ class MyContextProvider extends Effect.Service<MyContextProvider>()("MyContextPr
     if (Math.random() > 0.5) return yield* new CustomError1()
 
     return Effect.gen(function*() {
-      // the only requirements you can have are the one provided by HttpRouter.HttpRouter.Provided
+      // the only requirements you can have are the one provided by HttpLayerRouter.Provided
       yield* Scope.Scope
 
       yield* Effect.logInfo("MyContextProviderGen", "this is a generator")
@@ -63,7 +63,7 @@ class MyContextProviderGen extends Effect.Service<MyContextProviderGen>()("MyCon
     if (Math.random() > 0.5) return yield* new CustomError1()
 
     return function*() {
-      // the only requirements you can have are the one provided by HttpRouter.HttpRouter.Provided
+      // the only requirements you can have are the one provided by HttpLayerRouter.Provided
       yield* Scope.Scope
 
       yield* Effect.logInfo("MyContextProviderGen", "this is a generator")
@@ -87,7 +87,7 @@ export const someContextProvider = ContextProvider({
     if (Math.random() > 0.5) return yield* new CustomError1()
 
     return Effect.gen(function*() {
-      // the only requirements you can have are the one provided by HttpRouter.HttpRouter.Provided
+      // the only requirements you can have are the one provided by HttpLayerRouter.Provided
       yield* Scope.Scope
 
       // not allowed
@@ -106,7 +106,7 @@ export const someContextProviderGen = ContextProvider({
     if (Math.random() > 0.5) return yield* new CustomError1()
 
     return function*() {
-      // the only requirements you can have are the one provided by HttpRouter.HttpRouter.Provided
+      // the only requirements you can have are the one provided by HttpLayerRouter.Provided
       yield* Scope.Scope
 
       // not allowed