@effect-app/infra 2.94.0 → 3.0.1

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

@@ -1,58 +0,0 @@
-import { Context, S } from "effect-app";
-import { middlewareMaker } from "./generic-middleware.js";
-import { Tag } from "./RpcMiddleware.js";
-/** Adapter used when setting the dynamic prop on a middleware implementation */
-export const contextMap = (rcm, key) => ({
-    key,
-    settings: { service: rcm[key]["service"] }
-});
-/** Retrieves RequestContextConfig out of the RPC annotations */
-export const getConfig = () => (rpc) => {
-    return Context.unsafeGet(rpc.annotations, Context.GenericTag("RequestContextConfig"));
-};
-export const makeMiddleware = (rcm) => {
-    let allMiddleware = [];
-    const it = {
-        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;
-};
-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
-    })(middleware);
-    // add to the tag a default implementation
-    return Object.assign(MiddlewareMaker, {
-        // tag to be used to retrieve the RequestContextConfig from RPC annotations
-        requestContext: Context.GenericTag("RequestContextConfig")
-    });
-};
-//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,301 +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, Layer, 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"
-import { type Service } from "effect/Effect"
-
-// 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>
-}
-
-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
-}
-
-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
-) =>
-<
-  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
-    >
-    // TODO: we really should only support NonEmtyReadonlyArray because ReadonlyArray fucks up once you have a Layer.empty in the list, as the whole thing resolves to never
-    dependencies?: NonEmptyReadonlyArray<Layer.Layer.Any> | ReadonlyArray<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 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/generic-middleware.ts

@@ -1,163 +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 } from "effect-app/client"
-import { InfraLogger } from "../../../logger.js"
-import { type RpcMiddlewareWrap, type TagClassAny } from "./RpcMiddleware.js"
-
-// Effect rpc middleware does not support changing payload or headers, but we do..
-
-export type MiddlewareMaker = TagClassAny & { Default: Layer.Layer.Any } // todo; and Layer..
-
-export namespace MiddlewareMaker {
-  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>
->(middlewares: MiddlewareProviders): {
-  dependencies: { [K in keyof MiddlewareProviders]: MiddlewareProviders[K]["Default"] }
-  effect: 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 {
-    dependencies: middlewares.map((_) => _.Default),
-    effect: 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
-}