@effect-app/infra 2.85.0 → 2.87.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect-app/infra",
-  "version": "2.85.0",
+  "version": "2.87.0",
   "license": "MIT",
   "type": "module",
   "dependencies": {
@@ -13,7 +13,7 @@
     "proper-lockfile": "^4.1.2",
     "pure-rand": "7.0.1",
     "query-string": "^9.2.2",
-    "effect-app": "2.51.0"
+    "effect-app": "2.52.0"
   },
   "devDependencies": {
     "@azure/cosmos": "^4.5.0",
@@ -306,9 +306,13 @@
       "types": "./dist/api/routing/middleware/ContextProvider.d.ts",
       "default": "./dist/api/routing/middleware/ContextProvider.js"
     },
-    "./api/routing/middleware/DynamicMiddleware": {
-      "types": "./dist/api/routing/middleware/DynamicMiddleware.d.ts",
-      "default": "./dist/api/routing/middleware/DynamicMiddleware.js"
+    "./api/routing/middleware/RouterMiddleware": {
+      "types": "./dist/api/routing/middleware/RouterMiddleware.d.ts",
+      "default": "./dist/api/routing/middleware/RouterMiddleware.js"
+    },
+    "./api/routing/middleware/RpcMiddleware": {
+      "types": "./dist/api/routing/middleware/RpcMiddleware.d.ts",
+      "default": "./dist/api/routing/middleware/RpcMiddleware.js"
     },
     "./api/routing/middleware/dynamic-middleware": {
       "types": "./dist/api/routing/middleware/dynamic-middleware.d.ts",

package/src/api/layerUtils.ts

@@ -7,19 +7,19 @@ export namespace LayerUtils {
     NonEmptyReadonlyArray<Layer.Layer.Any> ? {
       [k in keyof Layers]: Layer.Layer.Success<Layers[k]>
     }[number]
-    : never
+    : Layer.Layer.Success<Layers[number]>
 
   export type GetLayersContext<Layers extends ReadonlyArray<Layer.Layer.Any>> = Layers extends
     NonEmptyReadonlyArray<Layer.Layer.Any> ? {
       [k in keyof Layers]: Layer.Layer.Context<Layers[k]>
     }[number]
-    : never
+    : Layer.Layer.Context<Layers[number]>
 
   export type GetLayersError<Layers extends ReadonlyArray<Layer.Layer.Any>> = Layers extends
     NonEmptyReadonlyArray<Layer.Layer.Any> ? {
       [k in keyof Layers]: Layer.Layer.Error<Layers[k]>
     }[number]
-    : never
+    : Layer.Layer.Error<Layers[number]>
 }
 
 export type ContextTagWithDefault<Id, A, LayerE, LayerR> =
@@ -35,25 +35,11 @@ export namespace ContextTagWithDefault {
 export type GetContext<T> = T extends Context.Context<infer Y> ? Y : never
 
 export const mergeContexts = Effect.fnUntraced(
-  function*<T extends readonly { maker: any; handle: Effect<Context<any>> }[]>(makers: T) {
+  function*<T extends readonly { maker: any; handle: Effect<Context<any> | Option<Context<any>>> }[]>(makers: T) {
     let context = Context.empty()
     for (const mw of makers) {
-      const moreContext = yield* mw.handle.pipe(Effect.provide(context))
-      yield* InfraLogger.logDebug(
-        "Built dynamic context for middleware" + (mw.maker.key ?? mw.maker),
-        (moreContext as any).toJSON().services
-      )
-      context = Context.merge(context, moreContext)
-    }
-    return context as Context.Context<Effect.Success<T[number]["handle"]>>
-  }
-)
-
-export const mergeOptionContexts = Effect.fnUntraced(
-  function*<T extends readonly { maker: any; handle: Effect<Option<Context<any>>> }[]>(makers: T) {
-    let context = Context.empty()
-    for (const mw of makers) {
-      const moreContext = yield* mw.handle.pipe(Effect.provide(context))
+      const ctx = yield* mw.handle.pipe(Effect.provide(context))
+      const moreContext = Context.isContext(ctx) ? Option.some(ctx) : ctx
       yield* InfraLogger.logDebug(
         "Built dynamic context for middleware" + (mw.maker.key ?? mw.maker),
         Option.map(moreContext, (c) => (c as any).toJSON().services)
@@ -62,6 +48,6 @@ export const mergeOptionContexts = Effect.fnUntraced(
         context = Context.merge(context, moreContext.value)
       }
     }
-    return context
+    return context as Context.Context<Effect.Success<T[number]["handle"]>>
   }
 )

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

@@ -87,9 +87,9 @@ export const mergeContextProviders = <
   effect: Effect.Effect<
     Effect.Effect<
       // we need to merge all contexts into one
-      Context.Context<GetContext<EffectGenUtils.Success<Tag.Service<TDeps[number]>>>>,
+      Context.Context<GetContext<EffectGenUtils.Success<Tag.Identifier<TDeps[number]>>>>,
       never,
-      EffectGenUtils.Context<Tag.Service<TDeps[number]>>
+      EffectGenUtils.Context<Tag.Identifier<TDeps[number]>>
     >,
     LayerUtils.GetLayersError<{ [K in keyof TDeps]: TDeps[K]["Default"] }>,
     LayerUtils.GetLayersSuccess<{ [K in keyof TDeps]: TDeps[K]["Default"] }>
@@ -174,13 +174,13 @@ export const MergedContextProvider = <
     ContextProviderId,
     Effect.Effect<
       // we need to merge all contexts into one
-      Context.Context<GetContext<EffectGenUtils.Success<Tag.Service<TDeps[number]>>>>,
+      Context.Context<GetContext<EffectGenUtils.Success<Tag.Identifier<TDeps[number]>>>>,
       never,
-      EffectGenUtils.Context<Tag.Service<TDeps[number]>>
+      EffectGenUtils.Context<Tag.Identifier<TDeps[number]>>
     >,
     LayerUtils.GetLayersError<{ [K in keyof TDeps]: TDeps[K]["Default"] }>,
     | Exclude<
-      Tag.Service<TDeps[number]>,
+      Tag.Identifier<TDeps[number]>,
       LayerUtils.GetLayersSuccess<{ [K in keyof TDeps]: TDeps[K]["Default"] }>
     >
     | LayerUtils.GetLayersContext<{ [K in keyof TDeps]: TDeps[K]["Default"] }>

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

@@ -0,0 +1,149 @@
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-unsafe-return */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { type Effect, type Request, type S, type Scope } from "effect-app"
+import type { GetEffectContext, RPCContextMap } from "effect-app/client/req"
+import type * as EffectRequest from "effect/Request"
+import { type ContextTagWithDefault } from "../../layerUtils.js"
+import { type ContextWithLayer } from "./dynamic-middleware.js"
+
+// module:
+//
+export type MakeRPCHandlerFactory<
+  RequestContextMap extends Record<string, RPCContextMap.Any>,
+  MiddlewareR
+> = <
+  T extends {
+    config?: Partial<Record<keyof RequestContextMap, any>>
+  },
+  Req extends S.TaggedRequest.All,
+  HandlerR
+>(
+  schema: T & S.Schema<Req, any, never>,
+  next: (
+    request: Req,
+    headers: any
+  ) => Effect.Effect<
+    EffectRequest.Request.Success<Req>,
+    EffectRequest.Request.Error<Req>,
+    // dynamic middlewares removes the dynamic context from HandlerR
+    Exclude<HandlerR, GetEffectContext<RequestContextMap, (T & S.Schema<Req, any, never>)["config"]>>
+  >,
+  moduleName: string
+) => (
+  req: Req,
+  headers: any
+) => Effect.Effect<
+  Request.Request.Success<Req>,
+  Request.Request.Error<Req> | RequestContextMapErrors<RequestContextMap>,
+  // the middleware will remove from HandlerR the dynamic context, but will also add some requirements
+  | MiddlewareR
+  // & S.Schema<Req, any, never> is useless here but useful when creating the middleware
+  | Exclude<HandlerR, GetEffectContext<RequestContextMap, (T & S.Schema<Req, any, never>)["config"]>>
+>
+
+export type RPCHandlerFactory<
+  RequestContextMap extends Record<string, RPCContextMap.Any>,
+  ContextProviderA
+> = <
+  T extends {
+    config?: Partial<Record<keyof RequestContextMap, any>>
+  },
+  Req extends S.TaggedRequest.All,
+  HandlerR
+>(
+  schema: T & S.Schema<Req, any, never>,
+  next: (
+    request: Req,
+    headers: any
+  ) => Effect.Effect<
+    EffectRequest.Request.Success<Req>,
+    EffectRequest.Request.Error<Req>,
+    HandlerR
+  >,
+  moduleName: string
+) => (
+  req: Req,
+  headers: any
+) => Effect.Effect<
+  Request.Request.Success<Req>,
+  Request.Request.Error<Req> | RequestContextMapErrors<RequestContextMap>,
+  | Scope.Scope // because of the context provider and the middleware (Middleware)
+  | Exclude<
+    // the middleware will remove from HandlerR the dynamic context
+    // & S.Schema<Req, any, never> is useless here but useful when creating the middleware
+    Exclude<HandlerR, GetEffectContext<RequestContextMap, (T & S.Schema<Req, any, never>)["config"]>>,
+    // the context provider provides additional stuff both to the middleware and the next
+    ContextProviderA
+  >
+>
+
+export type RequestContextMapProvider<RequestContextMap extends Record<string, RPCContextMap.Any>> = {
+  [K in keyof RequestContextMap]: ContextWithLayer.Base<
+    { [K in keyof RequestContextMap]?: RequestContextMap[K]["contextActivation"] },
+    RequestContextMap[K]["service"],
+    S.Schema.Type<RequestContextMap[K]["error"]>
+  >
+}
+
+export interface MiddlewareMakerId {
+  _tag: "MiddlewareMaker"
+}
+
+export type RouterMiddleware<
+  RequestContextMap extends Record<string, RPCContextMap.Any>, // what services will the middlware provide dynamically to the next, or raise errors.
+  MakeMiddlewareE, // what the middleware construction can fail with
+  MakeMiddlewareR, // what the middlware requires to be constructed
+  ContextProviderA // what the context provider provides
+> = ContextTagWithDefault<
+  MiddlewareMakerId,
+  {
+    _tag: "MiddlewareMaker"
+    effect: RPCHandlerFactory<RequestContextMap, ContextProviderA>
+  },
+  MakeMiddlewareE,
+  MakeMiddlewareR
+>
+
+export type RequestContextMapErrors<RequestContextMap extends Record<string, RPCContextMap.Any>> = S.Schema.Type<
+  RequestContextMap[keyof RequestContextMap]["error"]
+>
+
+// it just provides the right types without cluttering the implementation with them
+export function makeRpcEffect<
+  RequestContextMap extends Record<string, RPCContextMap.Any>,
+  ContextProviderA
+>() {
+  return (
+    cb: <
+      T extends {
+        config?: Partial<Record<keyof RequestContextMap, any>>
+      },
+      Req extends S.TaggedRequest.All,
+      HandlerR
+    >(
+      schema: T & S.Schema<Req, any, never>,
+      next: (
+        request: Req,
+        headers: any
+      ) => Effect.Effect<
+        EffectRequest.Request.Success<Req>,
+        EffectRequest.Request.Error<Req>,
+        HandlerR
+      >,
+      moduleName: string
+    ) => (
+      req: Req,
+      headers: any
+    ) => Effect.Effect<
+      Request.Request.Success<Req>,
+      Request.Request.Error<Req> | RequestContextMapErrors<RequestContextMap>,
+      | Scope.Scope // the context provider may require Scope to run
+      | Exclude<
+        // it can also be removed from HandlerR
+        Exclude<HandlerR, GetEffectContext<RequestContextMap, (T & S.Schema<Req, any, never>)["config"]>>,
+        ContextProviderA
+      >
+    >
+  ) => cb
+}

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

@@ -0,0 +1,287 @@
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-unsafe-return */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { type Rpc, RpcMiddleware } from "@effect/rpc"
+import { type SuccessValue, type TypeId } from "@effect/rpc/RpcMiddleware"
+import { type Context, type Effect, Layer, type NonEmptyReadonlyArray, type Option, type S, type Schema, type Scope, Unify } from "effect-app"
+import type { AnyService, ContextRepr, RPCContextMap } from "effect-app/client/req"
+import { type HttpHeaders } from "effect-app/http"
+import { type TagUnify, type TagUnifyIgnore } from "effect/Context"
+import { type LayerUtils } from "../../layerUtils.js"
+
+// updated to support Scope.Scope
+export interface RpcMiddleware<Provides, E, Requires> {
+  (options: {
+    readonly clientId: number
+    readonly rpc: Rpc.AnyWithProps
+    readonly payload: unknown
+    readonly headers: HttpHeaders.Headers
+  }): Effect.Effect<Provides, E, Scope.Scope | Requires>
+}
+export interface RpcMiddlewareWrap<Provides, E, Requires> {
+  (options: {
+    readonly clientId: number
+    readonly rpc: Rpc.AnyWithProps
+    readonly payload: unknown
+    readonly headers: HttpHeaders.Headers
+    readonly next: Effect.Effect<SuccessValue, E, Provides | Scope.Scope | Requires>
+  }): Effect.Effect<SuccessValue, E, Scope.Scope | Requires>
+}
+
+type RpcOptionsOriginal = {
+  readonly wrap?: boolean
+  readonly optional?: boolean
+  readonly failure?: Schema.Schema.All
+  readonly provides?: AnyService
+  readonly requiredForClient?: boolean
+}
+
+export type RpcDynamic<Key extends string, A extends RPCContextMap.Any> = {
+  key: Key
+  settings: A
+}
+
+export type AnyDynamic = { dynamic: RpcDynamic<any, any> }
+
+export type DependsOn = {
+  readonly dependsOn: NonEmptyReadonlyArray<AnyDynamic> | undefined
+}
+
+type RpcOptionsDynamic<Key extends string, A extends RPCContextMap.Any> = RpcOptionsOriginal & {
+  readonly dynamic: RpcDynamic<Key, A>
+  readonly dependsOn?: NonEmptyReadonlyArray<AnyDynamic> | undefined
+}
+
+export type Dynamic<Options> = Options extends RpcOptionsDynamic<any, any> ? true : false
+
+export interface RpcMiddlewareDynamicWrap<E, R, Config> {
+  (options: {
+    readonly next: Effect.Effect<SuccessValue, E, Scope.Scope | R>
+    readonly config: Config // todo
+    readonly clientId: number
+    readonly rpc: Rpc.AnyWithProps
+    readonly payload: unknown
+    readonly headers: HttpHeaders.Headers
+  }): Effect.Effect<
+    SuccessValue,
+    E,
+    Scope.Scope | R
+  >
+}
+
+export interface RpcMiddlewareDynamicNormal<A, E, R, Config> {
+  (options: {
+    readonly config: Config // todo
+    readonly clientId: number
+    readonly rpc: Rpc.AnyWithProps
+    readonly payload: unknown
+    readonly headers: HttpHeaders.Headers
+  }): Effect.Effect<
+    Option.Option<A>,
+    E,
+    Scope.Scope | R
+  >
+}
+
+export interface TagClassAny extends Context.Tag<any, any> {
+  readonly [TypeId]: TypeId
+  readonly optional: boolean
+  readonly provides?: Context.Tag<any, any> | ContextRepr | undefined
+  readonly requires?: Context.Tag<any, any> | ContextRepr | undefined
+  readonly failure: Schema.Schema.All
+  readonly requiredForClient: boolean
+  readonly wrap: boolean
+  readonly dynamic?: RpcDynamic<any, any> | undefined
+  readonly dependsOn?: NonEmptyReadonlyArray<AnyDynamic> | undefined
+}
+
+export declare namespace TagClass {
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export type Provides<Options> = Options extends {
+    readonly provides: Context.Tag<any, any>
+    readonly optional?: false
+  } ? Context.Tag.Identifier<Options["provides"]>
+    : Options extends {
+      readonly provides: ContextRepr
+      readonly optional?: false
+    } ? ContextRepr.Identifier<Options["provides"]>
+    : never
+
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export type Requires<Options> = Options extends {
+    readonly requires: Context.Tag<any, any>
+  } ? Context.Tag.Identifier<Options["requires"]>
+    : Options extends {
+      readonly requires: ContextRepr
+    } ? ContextRepr.Identifier<Options["requires"]>
+    : never
+
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export type Service<Options> = Options extends { readonly provides: Context.Tag<any, any> }
+    ? Context.Tag.Service<Options["provides"]>
+    : Options extends { readonly dynamic: RpcDynamic<any, infer A> }
+      ? Options extends { wrap: true } ? void : AnyService.Bla<A["service"]>
+    : Options extends { readonly provides: ContextRepr } ? Context.Context<ContextRepr.Identifier<Options["provides"]>>
+    : void
+
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export type FailureSchema<Options> = Options extends
+    { readonly failure: Schema.Schema.All; readonly optional?: false } ? Options["failure"]
+    : Options extends { readonly dynamic: RpcDynamic<any, infer A> } ? A["error"]
+    : typeof Schema.Never
+
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export type Failure<Options> = Options extends
+    { readonly failure: Schema.Schema<infer _A, infer _I, infer _R>; readonly optional?: false } ? _A
+    : Options extends { readonly dynamic: RpcDynamic<any, infer A> } ? S.Schema.Type<A["error"]>
+    : never
+
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export type FailureContext<Options> = Schema.Schema.Context<FailureSchema<Options>>
+
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export type FailureService<Options> = Optional<Options> extends true ? unknown : Failure<Options>
+
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export type Optional<Options> = Options extends { readonly optional: true } ? true : false
+
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export type RequiredForClient<Options> = Options extends { readonly requiredForClient: true } ? true : false
+
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export type Wrap<Options> = Options extends { readonly wrap: true } ? true : false
+
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export interface Base<Self, Name extends string, Options, Service> extends Context.Tag<Self, Service> {
+    new(_: never): Context.TagClassShape<Name, Service>
+    readonly [TypeId]: TypeId
+    readonly optional: Optional<Options>
+    readonly failure: FailureSchema<Options>
+    readonly provides: Options extends { readonly provides: Context.Tag<any, any> } ? Options["provides"]
+      : Options extends { readonly provides: ContextRepr } ? Options["provides"]
+      : undefined
+    readonly requires: Options extends { readonly requires: Context.Tag<any, any> } ? Options["requires"]
+      : Options extends { readonly requires: ContextRepr } ? Options["requires"]
+      : undefined
+    readonly dynamic: Options extends RpcOptionsDynamic<any, any> ? Options["dynamic"]
+      : undefined
+    readonly dependsOn: Options extends DependsOn ? Options["dependsOn"] : undefined
+    readonly requiredForClient: RequiredForClient<Options>
+    readonly wrap: Wrap<Options>
+  }
+}
+
+export interface TagClass<
+  Self,
+  Name extends string,
+  Options
+> extends
+  TagClass.Base<
+    Self,
+    Name,
+    Options,
+    Options extends RpcOptionsDynamic<any, any> ? TagClass.Wrap<Options> extends true ? RpcMiddlewareDynamicWrap<
+          TagClass.FailureService<Options>,
+          TagClass.Requires<Options>,
+          { [K in Options["dynamic"]["key"]]?: Options["dynamic"]["settings"]["contextActivation"] }
+        >
+      : RpcMiddlewareDynamicNormal<
+        TagClass.Service<Options>,
+        TagClass.FailureService<Options>,
+        TagClass.Requires<Options>,
+        { [K in Options["dynamic"]["key"]]?: Options["dynamic"]["settings"]["contextActivation"] }
+      >
+      : TagClass.Wrap<Options> extends true ? RpcMiddlewareWrap<
+          TagClass.Provides<Options>,
+          TagClass.Requires<Options>,
+          TagClass.Failure<Options>
+        >
+      : RpcMiddleware<
+        TagClass.Service<Options>,
+        TagClass.FailureService<Options>,
+        TagClass.Requires<Options>
+      >
+  >
+{}
+
+export const Tag = <Self>() =>
+<
+  const Name extends string,
+  const Options extends RpcOptionsOriginal | RpcOptionsDynamic<any, any>
+>(
+  id: Name,
+  options?: Options | undefined
+) =>
+<E, R, L extends NonEmptyReadonlyArray<Layer.Layer.Any>>(opts: {
+  effect: Effect.Effect<
+    Options extends RpcOptionsDynamic<any, any> ? TagClass.Wrap<Options> extends true ? RpcMiddlewareDynamicWrap<
+          TagClass.FailureService<Options>,
+          TagClass.Requires<Options>,
+          { [K in Options["dynamic"]["key"]]?: Options["dynamic"]["settings"]["contextActivation"] }
+        >
+      : RpcMiddlewareDynamicNormal<
+        TagClass.Service<Options>,
+        TagClass.FailureService<Options>,
+        TagClass.Requires<Options>,
+        { [K in Options["dynamic"]["key"]]?: Options["dynamic"]["settings"]["contextActivation"] }
+      >
+      : TagClass.Wrap<Options> extends true ? RpcMiddlewareWrap<
+          TagClass.Provides<Options>,
+          TagClass.Failure<Options>,
+          TagClass.Requires<Options>
+        >
+      : RpcMiddleware<
+        TagClass.Service<Options>,
+        TagClass.FailureService<Options>,
+        TagClass.Requires<Options>
+      >,
+    E,
+    R
+  >
+  dependencies?: L
+}): TagClass<Self, Name, Options> & {
+  Default: Layer.Layer<Self, E | LayerUtils.GetLayersError<L>, Exclude<R, LayerUtils.GetLayersSuccess<L>>>
+} =>
+  class extends RpcMiddleware.Tag<Self>()(id, options as any) {
+    static readonly dynamic = options && "dynamic" in options ? options.dynamic : undefined
+    static readonly dependsOn = options && "dependsOn" in options ? options.dependsOn : undefined
+    static readonly Default = Layer.scoped(this, opts.effect as any).pipe(
+      Layer.provide([Layer.empty, ...opts.dependencies ?? []])
+    )
+    static override [Unify.typeSymbol]?: unknown
+    static override [Unify.unifySymbol]?: TagUnify<typeof this>
+    static override [Unify.ignoreSymbol]?: TagUnifyIgnore
+  } as any

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

@@ -1,12 +1,9 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { Array, type Context, Effect, type S } from "effect-app"
-import { type GetEffectContext, type RPCContextMap } from "effect-app/client"
-import { type Tag } from "effect-app/Context"
-import { type HttpHeaders } from "effect-app/http"
-import { typedValuesOf } from "effect-app/utils"
-import { type ContextTagWithDefault, mergeOptionContexts } from "../../layerUtils.js"
-import { sort } from "../tsort.js"
-import { type RpcMiddlewareDynamic } from "./DynamicMiddleware.js"
+import { type ContextTagWithDefault } from "../../layerUtils.js"
+import { type RpcMiddlewareDynamicNormal, type RpcMiddlewareDynamicWrap } from "./RpcMiddleware.js"
+
+export type RpcMiddlewareDynamic<A, E, R, Config> = [A] extends [void] ? RpcMiddlewareDynamicWrap<E, R, Config>
+  : RpcMiddlewareDynamicNormal<A, E, R, Config>
 
 export type ContextWithLayer<
   Config,
@@ -20,13 +17,15 @@ export type ContextWithLayer<
   & (
     | ContextTagWithDefault<
       Id,
-      RpcMiddlewareDynamic<Service, Error, Config>,
+      // todo
+      RpcMiddlewareDynamic<Service, Error, any, Config>,
       LayerE,
       LayerR
     >
     | ContextTagWithDefault<
       Id,
-      RpcMiddlewareDynamic<Service, Error, Config>,
+      // todo
+      RpcMiddlewareDynamic<Service, Error, never, Config>,
       LayerE,
       LayerR
     >
@@ -46,47 +45,3 @@ export namespace ContextWithLayer {
     any
   >
 }
-
-// Effect Rpc Middleware: no substitute atm. though maybe something could be achieved with Wrap, we just don't have type safety on the Request input etc.
-export const implementMiddleware = <T extends Record<string, RPCContextMap.Any>>() =>
-<
-  TI extends {
-    [K in keyof T]: ContextWithLayer.Base<
-      { [K in keyof T]?: T[K]["contextActivation"] },
-      T[K]["service"],
-      S.Schema.Type<T[K]["error"]>
-    >
-  }
->(implementations: TI) => ({
-  dependencies: typedValuesOf(implementations).map((_) => _.Default) as {
-    [K in keyof TI]: TI[K]["Default"]
-  }[keyof TI][],
-  effect: Effect.gen(function*() {
-    const sorted = sort(typedValuesOf(implementations))
-
-    const makers = yield* Effect.all(sorted)
-    return Effect.fnUntraced(
-      function*(options: { config: { [K in keyof T]?: T[K]["contextActivation"] }; headers: HttpHeaders.Headers }) {
-        const ctx = yield* mergeOptionContexts(
-          Array.map(
-            makers,
-            (_, i) => ({ maker: sorted[i], handle: (_ as any)(options) as any }) as any
-          )
-        )
-        return ctx as Context.Context<
-          GetEffectContext<T, typeof options["config"]>
-        >
-      }
-    )
-  }) as unknown as Effect<
-    (
-      options: { config: { [K in keyof T]?: T[K]["contextActivation"] }; headers: HttpHeaders.Headers }
-    ) => Effect.Effect<
-      Context.Context<GetEffectContext<T, typeof options["config"]>>,
-      Effect.Error<ReturnType<Tag.Service<TI[keyof TI]>>>,
-      Effect.Context<ReturnType<Tag.Identifier<TI[keyof TI]>>>
-    >,
-    never,
-    Tag.Identifier<{ [K in keyof TI]: TI[K] }[keyof TI]>
-  >
-})