@effect-app/infra 2.86.0 → 2.87.0

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,
@@ -48,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.Service<TI[keyof TI]>>>
-    >,
-    never,
-    Tag.Identifier<{ [K in keyof TI]: TI[K] }[keyof TI]>
-  >
-})

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

@@ -1,28 +1,11 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { type Rpc, type RpcMiddleware } from "@effect/rpc"
-import { type SuccessValue, type TypeId } from "@effect/rpc/RpcMiddleware"
-import { type Array, Context, Effect, type Layer, type NonEmptyReadonlyArray, type Schema, type Scope } from "effect-app"
-import { type RPCContextMap } from "effect-app/client"
+import { type SuccessValue } from "@effect/rpc/RpcMiddleware"
+import { type Array, Context, Effect, type Layer, type NonEmptyReadonlyArray, Option, type Scope } from "effect-app"
+import { type ContextRepr } from "effect-app/client"
 import { type HttpHeaders } from "effect-app/http"
-import { type Tag } from "effect/Context"
 import { InfraLogger } from "../../../logger.js"
-import { type TagClassDynamicAny } from "./DynamicMiddleware.js"
-
-export type ContextRepr = NonEmptyReadonlyArray<Context.Tag<any, any>>
-export namespace ContextRepr {
-  export type Identifier<A> = A extends ContextRepr ? Tag.Identifier<A[number]> : never
-  export type Service<A> = A extends ContextRepr ? Tag.Service<A[number]> : never
-}
-
-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
-}
+import { type TagClassAny } from "./RpcMiddleware.js"
 
 export interface GenericMiddlewareOptions<E> {
   // Effect rpc middleware does not support changing payload or headers, but we do..
@@ -34,9 +17,6 @@ export interface GenericMiddlewareOptions<E> {
 }
 
 export type GenericMiddlewareMaker = TagClassAny & { Default: Layer.Layer.Any } // todo; and Layer..
-export type DynamicMiddlewareMaker<RequestContext extends Record<string, RPCContextMap.Any>> =
-  & TagClassDynamicAny<RequestContext>
-  & { Default: Layer.Layer.Any } // todo; and Layer..
 
 export namespace GenericMiddlewareMaker {
   export type ApplyServices<A extends TagClassAny, R> = Exclude<R, Provided<A>> | Required<A>
@@ -56,8 +36,6 @@ export namespace GenericMiddlewareMaker {
     : never
 }
 
-export const genericMiddleware = (i: GenericMiddlewareMaker) => i
-
 export const genericMiddlewareMaker = <
   T extends Array<GenericMiddlewareMaker>
 >(...middlewares: T): {
@@ -70,11 +48,6 @@ export const genericMiddlewareMaker = <
     dependencies: middlewares.map((_) => _.Default),
     effect: Effect.gen(function*() {
       const context = yield* Effect.context()
-      // const middlewares: readonly (RpcMiddlewareWrap<any, any> | RpcMiddleware.RpcMiddleware<any, any>)[] =
-      //   (yield* Effect.all(
-      //     middlewares
-      //   )) as any
-
       return <E>(
         options: GenericMiddlewareOptions<E>
       ) => {
@@ -83,13 +56,13 @@ export const genericMiddlewareMaker = <
         for (const tag of middlewares) {
           if (tag.wrap) {
             const middleware = Context.unsafeGet(context, tag)
-            handler = InfraLogger.logDebug("Applying middleware " + tag.key).pipe(
-              Effect.zipRight(middleware({ ...options, next: handler as any }))
+            handler = InfraLogger.logDebug("Applying middleware wrap " + tag.key).pipe(
+              Effect.zipRight(middleware({ ...options, next: handler }))
             ) as any
           } else if (tag.optional) {
             const middleware = Context.unsafeGet(context, tag) as RpcMiddleware.RpcMiddleware<any, any>
             const previous = handler
-            handler = InfraLogger.logDebug("Applying middleware " + tag.key).pipe(
+            handler = InfraLogger.logDebug("Applying middleware optional " + tag.key).pipe(
               Effect.zipRight(Effect.matchEffect(middleware(options), {
                 onFailure: () => previous,
                 onSuccess: tag.provides !== undefined
@@ -100,6 +73,22 @@ export const genericMiddlewareMaker = <
                   : (_) => previous
               }))
             )
+          } else if (tag.dynamic) {
+            const middleware = Context.unsafeGet(context, tag) as RpcMiddleware.RpcMiddleware<any, any>
+            const previous = handler
+            handler = InfraLogger.logDebug("Applying middleware dynamic " + tag.key, tag.dynamic).pipe(
+              Effect.zipRight(
+                middleware(options).pipe(
+                  Effect.flatMap((value) =>
+                    Option.isSome(value)
+                      ? Context.isContext(value.value)
+                        ? Effect.provide(previous, value.value)
+                        : Effect.provideService(previous, tag.dynamic!.settings.service!, /* TODO */ value.value)
+                      : previous
+                  )
+                )
+              )
+            )
           } else {
             const middleware = Context.unsafeGet(context, tag) as RpcMiddleware.RpcMiddleware<any, any>
             const previous = handler