@effect-app/infra 2.93.0 → 3.0.0

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

@@ -3,11 +3,10 @@
 /* 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 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"
-import { type Service } from "effect/Effect"
 
 // updated to support Scope.Scope and Requires
 export interface RpcMiddleware<Provides, E, Requires> {
@@ -28,7 +27,7 @@ export interface RpcMiddlewareWrap<Provides, E, Requires> {
   }): Effect.Effect<SuccessValue, E, Scope.Scope | Requires>
 }
 
-type RpcOptionsOriginal = {
+export type RpcOptionsOriginal = {
   readonly wrap?: boolean
   readonly optional?: boolean
   readonly failure?: Schema.Schema.All
@@ -47,7 +46,7 @@ export type DependsOn = {
   readonly dependsOn: NonEmptyReadonlyArray<AnyDynamic> | undefined
 }
 
-interface RpcOptionsDynamic<Key extends string, A extends RPCContextMap.Any> extends RpcOptionsOriginal {
+export interface RpcOptionsDynamic<Key extends string, A extends RPCContextMap.Any> extends RpcOptionsOriginal {
   readonly dynamic: RpcDynamic<Key, A>
   readonly dependsOn?: NonEmptyReadonlyArray<AnyDynamic> | undefined
 }
@@ -245,56 +244,10 @@ export const Tag = <Self>() =>
 >(
   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>
-  >
-} =>
+): 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 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

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

@@ -0,0 +1,70 @@
+/* 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,15 +1,56 @@
 /* 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 { 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 type MiddlewareMaker = TagClassAny & { Default: Layer.Layer.Any } // todo; and Layer..
+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> =
@@ -44,120 +85,114 @@ export namespace MiddlewareMaker {
 }
 
 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>>
-    >
+  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 {
-    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) =>
+  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)
-                  : (_) => 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
-          }
+                : Effect.zipRight(middleware(options), previous)
+            )
+          ) as any
         }
-        return handler
       }
-    })
-  } as any
+      return handler
+    }
+  }) as any
 }