@effect-app/infra 3.0.0 → 3.0.1

package/dist/api/routing/middleware/middleware-api.js

@@ -1,88 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { Rpc } from "@effect/rpc";
-import { Tag } from "@effect/rpc/RpcMiddleware";
-import { Context, Layer, S } from "effect-app";
-import { typedValuesOf } from "effect-app/utils";
-import { middlewareMaker } from "./generic-middleware.js";
-/** Adapter used when setting the dynamic prop on a middleware implementation */
-export const contextMap = (rcm, key) => ({
-    key,
-    settings: { service: rcm[key]["service"] }
-});
-const tag = Context.GenericTag("RequestContextConfig");
-/** Retrieves RequestContextConfig out of the RPC annotations */
-export const getConfig = () => (rpc) => {
-    return Context.getOrElse(rpc.annotations, tag, () => ({}));
-};
-const makeMiddlewareBasic = 
-// by setting RequestContextMap beforehand, execute contextual typing does not fuck up itself to anys
-(rcm, ...make) => {
-    // reverse middlewares and wrap one after the other
-    const middleware = middlewareMaker(make);
-    const failures = make.map((_) => _.failure).filter(Boolean);
-    const provides = make.flatMap((_) => !_.provides ? [] : Array.isArray(_.provides) ? _.provides : [_.provides]);
-    const requires = make
-        .flatMap((_) => !_.requires ? [] : Array.isArray(_.requires) ? _.requires : [_.requires])
-        .filter((_) => !provides.includes(_));
-    const MiddlewareMaker = Tag()("MiddlewareMaker", {
-        failure: (failures.length > 0
-            ? S.Union(...failures)
-            : S.Never),
-        requires: (requires.length > 0
-            ? requires
-            : undefined),
-        provides: (provides.length > 0
-            ? provides
-            : undefined),
-        wrap: true
-    });
-    const layer = Layer
-        .scoped(MiddlewareMaker, 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"),
-        requestContextMap: rcm
-    });
-};
-export const makeMiddleware = (rcm) => {
-    let allMiddleware = [];
-    const requestContext = Context.GenericTag("RequestContextConfig");
-    const it = {
-        // rpc with config
-        rpc: (tag, options) => {
-            const config = options?.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 });
-            return Object.assign(rpc.annotate(requestContext, config), { config });
-        },
-        middleware: (...middlewares) => {
-            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(rcm, ...allMiddleware), it);
-        }
-    };
-    return it;
-};
-// alternatively consider group.serverMiddleware? hmmm
-export const middlewareGroup = (middleware) => (group) => {
-    const middlewaredGroup = group.middleware(middleware);
-    const toLayerOriginal = middlewaredGroup.toLayer.bind(middlewaredGroup);
-    return Object.assign(middlewaredGroup, {
-        toLayerDynamic: (build) => {
-            return toLayerOriginal(build); // ??
-        }
-    });
-};
-//# sourceMappingURL=data:application/json;base64,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

package/dist/api/routing/middleware/middleware-native.d.ts

@@ -1,23 +0,0 @@
-import { RpcMiddleware } from "@effect/rpc";
-import { Context } from "effect-app";
-declare const DevMode_base: Context.ReferenceClass<DevMode, "DevMode", boolean>;
-export declare class DevMode extends DevMode_base {
-}
-declare const RequestCacheMiddleware_base: RpcMiddleware.TagClass<RequestCacheMiddleware, "RequestCacheMiddleware", {
-    readonly wrap: true;
-}>;
-export declare class RequestCacheMiddleware extends RequestCacheMiddleware_base {
-}
-declare const ConfigureInterruptibilityMiddleware_base: RpcMiddleware.TagClass<ConfigureInterruptibilityMiddleware, "ConfigureInterruptibilityMiddleware", {
-    readonly wrap: true;
-}>;
-export declare class ConfigureInterruptibilityMiddleware extends ConfigureInterruptibilityMiddleware_base {
-}
-declare const LoggerMiddleware_base: RpcMiddleware.TagClass<LoggerMiddleware, "LoggerMiddleware", {
-    readonly wrap: true;
-}>;
-export declare class LoggerMiddleware extends LoggerMiddleware_base {
-}
-export declare const DefaultGenericMiddlewares: readonly [typeof RequestCacheMiddleware, typeof ConfigureInterruptibilityMiddleware, typeof LoggerMiddleware];
-export {};
-//# sourceMappingURL=middleware-native.d.ts.map

package/dist/api/routing/middleware/middleware-native.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"middleware-native.d.ts","sourceRoot":"","sources":["../../../../src/api/routing/middleware/middleware-native.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAC3C,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAA;;AAEpC,qBAAa,OAAQ,SAAQ,YAAsE;CAAG;;;;AAEtG,qBAAa,sBACX,SAAQ,2BAAqF;CAC7F;;;;AAEF,qBAAa,mCACX,SAAQ,wCAEN;CACF;;;;AAEF,qBAAa,gBAAiB,SAAQ,qBAAyE;CAAG;AAElH,eAAO,MAAM,yBAAyB,+GAI5B,CAAA"}

package/dist/api/routing/middleware/middleware-native.js

@@ -1,19 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { RpcMiddleware } from "@effect/rpc";
-import { Context } from "effect-app";
-export class DevMode extends Context.Reference()("DevMode", { defaultValue: () => false }) {
-}
-export class RequestCacheMiddleware extends RpcMiddleware.Tag()("RequestCacheMiddleware", { wrap: true }) {
-}
-export class ConfigureInterruptibilityMiddleware extends RpcMiddleware.Tag()("ConfigureInterruptibilityMiddleware", {
-    wrap: true
-}) {
-}
-export class LoggerMiddleware extends RpcMiddleware.Tag()("LoggerMiddleware", { wrap: true }) {
-}
-export const DefaultGenericMiddlewares = [
-    RequestCacheMiddleware,
-    ConfigureInterruptibilityMiddleware,
-    LoggerMiddleware
-];
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWlkZGxld2FyZS1uYXRpdmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvYXBpL3JvdXRpbmcvbWlkZGxld2FyZS9taWRkbGV3YXJlLW5hdGl2ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSx1REFBdUQ7QUFDdkQsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLGFBQWEsQ0FBQTtBQUMzQyxPQUFPLEVBQUUsT0FBTyxFQUFFLE1BQU0sWUFBWSxDQUFBO0FBRXBDLE1BQU0sT0FBTyxPQUFRLFNBQVEsT0FBTyxDQUFDLFNBQVMsRUFBVyxDQUFDLFNBQVMsRUFBRSxFQUFFLFlBQVksRUFBRSxHQUFHLEVBQUUsQ0FBQyxLQUFLLEVBQUUsQ0FBQztDQUFHO0FBRXRHLE1BQU0sT0FBTyxzQkFDWCxTQUFRLGFBQWEsQ0FBQyxHQUFHLEVBQTBCLENBQUMsd0JBQXdCLEVBQUUsRUFBRSxJQUFJLEVBQUUsSUFBSSxFQUFFLENBQUM7Q0FDN0Y7QUFFRixNQUFNLE9BQU8sbUNBQ1gsU0FBUSxhQUFhLENBQUMsR0FBRyxFQUF1QyxDQUFDLHFDQUFxQyxFQUFFO0lBQ3RHLElBQUksRUFBRSxJQUFJO0NBQ1gsQ0FBQztDQUNGO0FBRUYsTUFBTSxPQUFPLGdCQUFpQixTQUFRLGFBQWEsQ0FBQyxHQUFHLEVBQW9CLENBQUMsa0JBQWtCLEVBQUUsRUFBRSxJQUFJLEVBQUUsSUFBSSxFQUFFLENBQUM7Q0FBRztBQUVsSCxNQUFNLENBQUMsTUFBTSx5QkFBeUIsR0FBRztJQUN2QyxzQkFBc0I7SUFDdEIsbUNBQW1DO0lBQ25DLGdCQUFnQjtDQUNSLENBQUEifQ==

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

@@ -1,254 +0,0 @@
-/* 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, type NonEmptyReadonlyArray, type Option, type S, type Schema, type Scope, Unify } from "effect-app"
-import type { AnyService, ContextTagArray, RPCContextMap } from "effect-app/client/req"
-import { type HttpHeaders } from "effect-app/http"
-import { type TagUnify, type TagUnifyIgnore } from "effect/Context"
-
-// updated to support Scope.Scope and Requires
-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>
-}
-
-export 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
-}
-
-export interface RpcOptionsDynamic<Key extends string, A extends RPCContextMap.Any> extends 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 clientId: number
-    readonly rpc: Rpc.AnyWithProps // TODO & { annotations: Context.Context<RequestContextMap<Config>> }
-    readonly payload: unknown
-    readonly headers: HttpHeaders.Headers
-  }): Effect.Effect<
-    SuccessValue,
-    E,
-    Scope.Scope | R
-  >
-}
-
-export interface RpcMiddlewareDynamicNormal<A, E, R, _Config> {
-  (options: {
-    readonly clientId: number
-    readonly rpc: Rpc.AnyWithProps // TODO & { annotations: Context.Context<RequestContextMap<Config>> }
-    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> | ContextTagArray | undefined
-  readonly requires?: Context.Tag<any, any> | ContextTagArray | 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: ContextTagArray
-      readonly optional?: false
-    } ? ContextTagArray.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: ContextTagArray
-    } ? ContextTagArray.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: ContextTagArray }
-      ? Context.Context<ContextTagArray.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"]
-    // actually not, the Failure depends on Dynamic Middleware Configuration!
-    // : 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
-    // actually not, the Failure depends on Dynamic Middleware Configuration!
-    : 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: ContextTagArray } ? Options["provides"]
-      : undefined
-    readonly requires: Options extends { readonly requires: Context.Tag<any, any> } ? Options["requires"]
-      : Options extends { readonly requires: ContextTagArray } ? 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.Failure<Options>,
-          TagClass.Requires<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
-): TagClass<Self, Name, Options> =>
-  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 override [Unify.typeSymbol]?: unknown
-    static override [Unify.unifySymbol]?: TagUnify<typeof this>
-    static override [Unify.ignoreSymbol]?: TagUnifyIgnore
-  } as any

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

@@ -1,70 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-/* eslint-disable @typescript-eslint/no-unsafe-return */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { type Effect, Layer, type NonEmptyReadonlyArray, Unify } from "effect-app"
-import { type TagUnify, type TagUnifyIgnore } from "effect/Context"
-import { type Service } from "effect/Effect"
-import { type RpcMiddleware, type RpcMiddlewareDynamicNormal, type RpcMiddlewareDynamicWrap, type RpcMiddlewareWrap, type RpcOptionsDynamic, type RpcOptionsOriginal, Tag, type TagClass } from "./RpcMiddleware.js"
-
-/**
- * @deprecated - RPC groups are defined centrally and re-used between server and client,
- * so layer implementation details should not be mixed.
- */
-export const TagService = <Self>() =>
-<
-  const Name extends string,
-  const Options extends RpcOptionsOriginal | RpcOptionsDynamic<any, any>
->(
-  id: Name,
-  options?: Options | undefined
-) =>
-<
-  LayerOpts extends {
-    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>
-        >,
-      any,
-      any
-    >
-    dependencies?: NonEmptyReadonlyArray<Layer.Layer.Any>
-  }
->(opts: LayerOpts): TagClass<Self, Name, Options> & {
-  Default: Layer.Layer<
-    Self,
-    | (LayerOpts extends { effect: Effect<infer _A, infer _E, infer _R> } ? _E
-      : never)
-    | Service.MakeDepsE<LayerOpts>,
-    | Exclude<
-      LayerOpts extends { effect: Effect<infer _A, infer _E, infer _R> } ? _R : never,
-      Service.MakeDepsOut<LayerOpts>
-    >
-    | Service.MakeDepsIn<LayerOpts>
-  >
-} =>
-  class extends Tag<Self>()(id, options as any) {
-    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/generic-middleware.ts

@@ -1,198 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { type RpcMiddleware } from "@effect/rpc"
-import { Context, Effect, type Layer, type NonEmptyReadonlyArray, Option, type S, type Scope } from "effect-app"
-import { type ContextTagArray, type GetContextConfig, type RPCContextMap } from "effect-app/client"
-import { type Tag } from "effect/Context"
-import { type Simplify } from "effect/Types"
-import { InfraLogger } from "../../../logger.js"
-import { type MakeTags, type MiddlewareMakerId } from "./middleware-api.js"
-import { type RpcMiddlewareWrap, type TagClassAny } from "./RpcMiddleware.js"
-
-// Effect rpc middleware does not support changing payload or headers, but we do..
-
-export interface MiddlewareMaker<
-  RequestContextMap extends Record<string, RPCContextMap.Any>,
-  MiddlewareProviders extends ReadonlyArray<MiddlewareMaker.Any>
-> extends
-  RpcMiddleware.TagClass<
-    MiddlewareMakerId,
-    "MiddlewareMaker",
-    Simplify<
-      & { readonly wrap: true }
-      & (Exclude<
-        MiddlewareMaker.ManyRequired<MiddlewareProviders>,
-        MiddlewareMaker.ManyProvided<MiddlewareProviders>
-      > extends never ? {} : {
-        readonly requires: MakeTags<
-          Exclude<
-            MiddlewareMaker.ManyRequired<MiddlewareProviders>,
-            MiddlewareMaker.ManyProvided<MiddlewareProviders>
-          >
-        >
-      })
-      & (MiddlewareMaker.ManyErrors<MiddlewareProviders> extends never ? {}
-        : {
-          readonly failure: S.Schema<MiddlewareMaker.ManyErrors<MiddlewareProviders>>
-        })
-      & (MiddlewareMaker.ManyProvided<MiddlewareProviders> extends never ? {}
-        : { readonly provides: MakeTags<MiddlewareMaker.ManyProvided<MiddlewareProviders>> })
-    >
-  >
-{
-  readonly layer: Layer.Layer<MiddlewareMakerId, never, Tag.Identifier<MiddlewareProviders[number]>>
-  readonly requestContext: RequestContextTag<RequestContextMap>
-  readonly requestContextMap: RequestContextMap
-}
-
-export interface RequestContextTag<RequestContextMap extends Record<string, RPCContextMap.Any>>
-  extends Context.Tag<"RequestContextConfig", GetContextConfig<RequestContextMap>>
-{}
-
-export namespace MiddlewareMaker {
-  export type Any = TagClassAny
-
-  export type ApplyServices<A extends TagClassAny, R> = Exclude<R, Provided<A>> | Required<A>
-
-  export type ApplyManyServices<A extends NonEmptyReadonlyArray<TagClassAny>, R> =
-    | Exclude<R, { [K in keyof A]: Provided<A[K]> }[number]>
-    | { [K in keyof A]: Required<A[K]> }[number]
-
-  export type ManyProvided<A extends ReadonlyArray<TagClassAny>> = A extends NonEmptyReadonlyArray<TagClassAny>
-    ? { [K in keyof A]: Provided<A[K]> }[number]
-    : Provided<A[number]>
-  export type ManyRequired<A extends ReadonlyArray<TagClassAny>> = A extends NonEmptyReadonlyArray<TagClassAny>
-    ? { [K in keyof A]: Required<A[K]> }[number]
-    : Required<A[number]>
-  export type ManyErrors<A extends ReadonlyArray<TagClassAny>> = A extends NonEmptyReadonlyArray<TagClassAny>
-    ? { [K in keyof A]: Errors<A[K]> }[number]
-    : Errors<A[number]>
-
-  export type Provided<T> = T extends TagClassAny
-    ? T extends { provides: Context.Tag<any, any> } ? Context.Tag.Identifier<T["provides"]>
-    : T extends { provides: ContextTagArray } ? ContextTagArray.Identifier<T["provides"]>
-    : never
-    : never
-
-  export type Errors<T> = T extends TagClassAny ? T extends { failure: S.Schema.Any } ? S.Schema.Type<T["failure"]>
-    : never
-    : never
-
-  export type Required<T> = T extends TagClassAny
-    ? T extends { requires: Context.Tag<any, any> } ? Context.Tag.Identifier<T["requires"]>
-    : T extends { requires: ContextTagArray } ? ContextTagArray.Identifier<T["requires"]>
-    : never
-    : never
-}
-
-export const middlewareMaker = <
-  MiddlewareProviders extends ReadonlyArray<MiddlewareMaker.Any>
->(middlewares: MiddlewareProviders): Effect.Effect<
-  RpcMiddlewareWrap<
-    MiddlewareMaker.ManyProvided<MiddlewareProviders>,
-    MiddlewareMaker.ManyErrors<MiddlewareProviders>,
-    Exclude<
-      MiddlewareMaker.ManyRequired<MiddlewareProviders>,
-      MiddlewareMaker.ManyProvided<MiddlewareProviders>
-    > extends never ? never
-      : Exclude<MiddlewareMaker.ManyRequired<MiddlewareProviders>, MiddlewareMaker.ManyProvided<MiddlewareProviders>>
-  >
-> => {
-  // we want to run them in reverse order because latter middlewares will provide context to former ones
-  middlewares = middlewares.toReversed() as any
-
-  return Effect.gen(function*() {
-    const context = yield* Effect.context()
-
-    // returns a Effect/RpcMiddlewareWrap with Scope in requirements
-    return (
-      options: Parameters<
-        RpcMiddlewareWrap<
-          MiddlewareMaker.ManyProvided<MiddlewareProviders>,
-          never,
-          Scope.Scope
-        >
-      >[0]
-    ) => {
-      // we start with the actual handler
-      let handler = options.next
-
-      // inspired from Effect/RpcMiddleware
-      for (const tag of middlewares) {
-        if (tag.wrap) {
-          // use the tag to get the middleware from context
-          const middleware = Context.unsafeGet(context, tag)
-
-          // wrap the current handler, allowing the middleware to run before and after it
-          handler = InfraLogger.logDebug("Applying middleware wrap " + tag.key).pipe(
-            Effect.zipRight(middleware({ ...options, next: handler }))
-          ) as any
-        } else if (tag.optional) {
-          // use the tag to get the middleware from context
-          // if the middleware fails to run, we will ignore the error
-          const middleware = Context.unsafeGet(context, tag) as RpcMiddleware.RpcMiddleware<any, any>
-
-          const previous = handler
-
-          // set the previous handler to run after the middleware
-          // if the middleware is not present, we just return the previous handler
-          // otherwise the middleware will provide some context to be provided to the previous handler
-          handler = InfraLogger.logDebug("Applying middleware optional " + tag.key).pipe(
-            Effect.zipRight(Effect.matchEffect(middleware(options), {
-              onFailure: () => previous,
-              onSuccess: tag.provides !== undefined
-                ? (value) =>
-                  Context.isContext(value)
-                    ? Effect.provide(previous, value)
-                    : Effect.provideService(previous, tag.provides as any, value)
-                : (_) => previous
-            }))
-          )
-        } else if (tag.dynamic) {
-          // use the tag to get the middleware from context
-          const middleware = Context.unsafeGet(context, tag) as RpcMiddleware.RpcMiddleware<any, any>
-
-          const previous = handler
-
-          // set the previous handler to run after the middleware
-          // we do expect the middleware to be present, but the context might not be available
-          // if it is, we provide it to the previous handler
-          handler = InfraLogger.logDebug("Applying middleware dynamic " + tag.key, tag.dynamic).pipe(
-            Effect.zipRight(
-              middleware(options).pipe(
-                Effect.flatMap((o) =>
-                  Option.isSome(o)
-                    ? Context.isContext(o.value)
-                      ? Effect.provide(previous, o.value)
-                      : Effect.provideService(previous, tag.dynamic!.settings.service!, /* TODO */ o.value)
-                    : previous
-                )
-              )
-            )
-          ) as any
-        } else {
-          // use the tag to get the middleware from context
-          const middleware = Context.unsafeGet(context, tag) as RpcMiddleware.RpcMiddleware<any, any>
-
-          const previous = handler
-
-          // set the previous handler to run after the middleware
-          // we do expect both the middleware and the context to be present
-          handler = InfraLogger.logDebug("Applying middleware " + tag.key).pipe(
-            Effect.zipRight(
-              tag.provides !== undefined
-                ? middleware(options).pipe(
-                  Effect.flatMap((value) =>
-                    Context.isContext(value)
-                      ? Effect.provide(previous, value)
-                      : Effect.provideService(previous, tag.provides as any, value)
-                  )
-                )
-                : Effect.zipRight(middleware(options), previous)
-            )
-          ) as any
-        }
-      }
-      return handler
-    }
-  }) as any
-}