@effect-app/infra 2.75.0 → 2.77.0

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

@@ -1,122 +1,44 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { Array, Context, Effect, Option, type S } from "effect-app"
+import { Array, type Context, Effect, type Option, type S } from "effect-app"
 import { type GetEffectContext, type RPCContextMap } from "effect-app/client"
 import { type Tag } from "effect-app/Context"
 import { typedValuesOf } from "effect-app/utils"
-import { InfraLogger } from "../../../logger.js"
-import { type ContextTagWithDefault } from "../../layerUtils.js"
+import { type ContextTagWithDefault, mergeOptionContexts } from "../../layerUtils.js"
 import { sort } from "../tsort.js"
 
 export type ContextWithLayer<
   Config,
-  Id,
   Service,
-  E,
-  R,
-  MakeE,
-  MakeR,
-  Tag extends string,
-  Args extends [config: Config, headers: Record<string, string>],
-  Dependencies extends any[]
-> =
-  & ContextTagWithDefault<
-    Id,
-    { handle: (...args: Args) => Effect<Option<Context<Service>>, E, R>; _tag: Tag },
-    MakeE,
-    MakeR
+  Error,
+  Dependencies,
+  Thing extends ContextTagWithDefault<
+    any,
+    {
+      handle: (
+        ...args: [config: Config, headers: Record<string, string>]
+      ) => Effect<Option<Context<Service>>, Error, unknown>
+    },
+    any,
+    unknown,
+    any
   >
+> =
+  & Thing
   & {
     dependsOn?: Dependencies
   }
 
 export namespace ContextWithLayer {
-  export type Base<Config, Service, Error> =
-    | ContextWithLayer<
-      Config,
-      any,
-      Service,
-      Error,
-      any,
-      any,
-      any,
-      string,
-      any,
-      any
-    >
-    | ContextWithLayer<
-      Config,
-      any,
-      Service,
-      Error,
-      never,
-      any,
-      never,
-      any,
-      any,
-      any
-    >
-    | ContextWithLayer<
-      Config,
-      any,
-      Service,
-      Error,
-      any,
-      any,
-      never,
-      any,
-      any,
-      any
-    >
-    | ContextWithLayer<
-      Config,
-      any,
-      Service,
-      Error,
-      never,
-      any,
-      any,
-      any,
-      any,
-      any
-    >
+  export type Base<Config, Service, Error> = ContextWithLayer<
+    Config,
+    Service,
+    Error,
+    any,
+    any
+  >
 }
 
-export const mergeContexts = Effect.fnUntraced(
-  function*<T extends readonly { maker: any; handle: Effect<Context<any>> }[]>(makers: T) {
-    let context = Context.empty()
-    for (const mw of makers) {
-      yield* InfraLogger.logDebug("Building context for middleware", mw.maker.key ?? mw.maker)
-      const moreContext = yield* mw.handle.pipe(Effect.provide(context))
-      yield* InfraLogger.logDebug(
-        "Built 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) {
-      yield* InfraLogger.logDebug("Building context for middleware", mw.maker.key ?? mw.maker)
-      const moreContext = yield* mw.handle.pipe(Effect.provide(context))
-      yield* InfraLogger.logDebug(
-        "Built context for middleware",
-        mw.maker.key ?? mw.maker,
-        Option.map(moreContext, (c) => (c as any).toJSON().services)
-      )
-      if (moreContext.value) {
-        context = Context.merge(context, moreContext.value)
-      }
-    }
-    return context
-  }
-)
-
+// 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 {
@@ -146,13 +68,17 @@ export const implementMiddleware = <T extends Record<string, RPCContextMap.Any>>
           GetEffectContext<T, typeof config>
         >
       }
-    ) as (
+    )
+  }) as unknown as Effect<
+    (
       config: { [K in keyof T]?: T[K]["contextActivation"] },
       headers: Record<string, string>
     ) => Effect.Effect<
       Context.Context<GetEffectContext<T, typeof config>>,
       Effect.Error<ReturnType<Tag.Service<TI[keyof TI]>["handle"]>>,
       Effect.Context<ReturnType<Tag.Service<TI[keyof TI]>["handle"]>>
-    >
-  })
+    >,
+    never,
+    Tag.Identifier<{ [K in keyof TI]: TI[K] }[keyof TI]>
+  >
 })

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

@@ -3,10 +3,20 @@ import { type Array, Effect } from "effect-app"
 import { type HttpHeaders, type HttpRouter } from "effect-app/http"
 import { type ContextTagWithDefault } from "../../layerUtils.js"
 
+export interface GenericMiddlewareOptions<A, E> {
+  // Effect rpc middleware does not support changing payload or headers, but we do..
+  readonly next: Effect.Effect<A, E, HttpRouter.HttpRouter.Provided>
+  readonly payload: unknown
+  readonly headers: HttpHeaders.Headers
+  // readonly clientId: number
+  readonly rpc: { _tag: string } // Rpc.AnyWithProps
+}
+
 export type GenericMiddlewareMaker = <A, E>(
-  handle: (input: any, headers: HttpHeaders.Headers) => Effect.Effect<A, E, HttpRouter.HttpRouter.Provided>,
-  moduleName: string
-) => (input: any, headers: HttpHeaders.Headers) => Effect.Effect<A, E, HttpRouter.HttpRouter.Provided>
+  options: GenericMiddlewareOptions<A, E>
+) => Effect.Effect<A, E, HttpRouter.HttpRouter.Provided>
+
+export const genericMiddleware = (i: GenericMiddlewareMaker) => i
 
 export const genericMiddlewareMaker = <
   T extends Array<
@@ -21,17 +31,14 @@ export const genericMiddlewareMaker = <
     effect: Effect.gen(function*() {
       const middlewaresInstances = yield* Effect.all(middlewares)
 
-      return <A, E, R>(
-        handle: (input: any, headers: HttpHeaders.Headers) => Effect.Effect<A, E, R>,
-        moduleName: string
+      return <A, E>(
+        options: GenericMiddlewareOptions<A, E>
       ) => {
-        return (input: any, headers: HttpHeaders.Headers) => {
-          let effect = handle
-          for (const middleware of (middlewaresInstances as any[]).toReversed()) {
-            effect = middleware(effect, moduleName)
-          }
-          return effect(input, headers)
+        let next = options.next
+        for (const middleware of (middlewaresInstances as any[]).toReversed()) {
+          next = middleware({ ...options, next })
         }
+        return next
       }
     })
   } as any

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

@@ -1,67 +1,49 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
 import { Cause, Context, Effect, ParseResult } from "effect-app"
-import { HttpHeaders, type HttpRouter, HttpServerRequest } from "effect-app/http"
 import { pretty } from "effect-app/utils"
 import { logError, reportError } from "../../../errorReporter.js"
 import { InfraLogger } from "../../../logger.js"
+import { genericMiddleware, RequestCacheLayers } from "../../routing.js"
 
 const logRequestError = logError("Request")
 const reportRequestError = reportError("Request")
 
 export class DevMode extends Context.Reference<DevMode>()("DevMode", { defaultValue: () => false }) {}
+// Effect Rpc Middleware: Wrap
+export class RequestCacheMiddleware extends Effect.Service<RequestCacheMiddleware>()("RequestCacheMiddleware", {
+  effect: Effect.gen(function*() {
+    return genericMiddleware(Effect.fnUntraced(function*(options) {
+      return yield* options.next.pipe(Effect.provide(RequestCacheLayers))
+    }))
+  })
+}) {}
 
+// Effect Rpc Middleware: Wrap
 export class ConfigureInterruptibility extends Effect.Service<ConfigureInterruptibility>()(
   "ConfigureInterruptibility",
   {
     effect: Effect.gen(function*() {
-      return <A, E>(
-        handle: (input: any, headers: HttpHeaders.Headers) => Effect.Effect<A, E, HttpRouter.HttpRouter.Provided>,
-        _moduleName: string
-      ) =>
-        Effect.fnUntraced(function*(input: any, headers: HttpHeaders.Headers) {
-          return yield* handle(input, headers).pipe(
-            // TODO: make this depend on query/command, and consider if middleware also should be affected. right now it's not.
-            Effect.uninterruptible
-          )
-        })
+      return genericMiddleware(Effect.fnUntraced(function*(options) {
+        return yield* options.next.pipe(
+          // TODO: make this depend on query/command, and consider if middleware also should be affected. right now it's not.
+          Effect.uninterruptible
+        )
+      }))
     })
   }
 ) {}
 
-export class CaptureHttpHeadersAsRpcHeaders
-  extends Effect.Service<CaptureHttpHeadersAsRpcHeaders>()("CaptureHttpHeadersAsRpcHeaders", {
-    effect: Effect.gen(function*() {
-      return <A, E>(
-        handle: (input: any, headers: HttpHeaders.Headers) => Effect.Effect<A, E, HttpRouter.HttpRouter.Provided>,
-        _moduleName: string
-      ) =>
-        Effect.fnUntraced(function*(input: any, rpcHeaders: HttpHeaders.Headers) {
-          // merge in the request headers
-          // we should consider if we should merge them into rpc headers on the Protocol layer instead.
-          const httpReq = yield* HttpServerRequest.HttpServerRequest
-          const headers = HttpHeaders.merge(httpReq.headers, rpcHeaders)
-          return yield* handle(input, headers)
-        })
-    })
-  })
-{}
-
+// Effect Rpc Middleware: Wrap
 export class MiddlewareLogger extends Effect.Service<MiddlewareLogger>()("MiddlewareLogger", {
   effect: Effect.gen(function*() {
-    return <A, E>(
-      handle: (input: any, headers: HttpHeaders.Headers) => Effect.Effect<A, E, HttpRouter.HttpRouter.Provided>,
-      moduleName: string
-    ) =>
-      Effect.fnUntraced(function*(input: any, rpcHeaders: HttpHeaders.Headers) {
-        const devMode = yield* DevMode
-        // merge in the request headers
-        // we should consider if we should merge them into rpc headers on the Protocol layer instead.
-        const httpReq = yield* HttpServerRequest.HttpServerRequest
-        const headers = HttpHeaders.merge(httpReq.headers, rpcHeaders)
+    return genericMiddleware(Effect.fnUntraced(function*({ headers, next, payload, rpc }) {
+      const devMode = yield* DevMode
 
-        return yield* Effect
-          .annotateCurrentSpan(
-            "requestInput",
-            Object.entries(input).reduce((prev, [key, value]: [string, unknown]) => {
+      return yield* Effect
+        .annotateCurrentSpan(
+          "requestInput",
+          typeof payload === "object" && payload !== null
+            ? Object.entries(payload).reduce((prev, [key, value]: [string, unknown]) => {
               prev[key] = key === "password"
                 ? "<redacted>"
                 : typeof value === "string" || typeof value === "number" || typeof value === "boolean"
@@ -77,44 +59,45 @@ export class MiddlewareLogger extends Effect.Service<MiddlewareLogger>()("Middle
                 : typeof value
               return prev
             }, {} as Record<string, string | number | boolean>)
-          )
-          .pipe(
-            // can't use andThen due to some being a function and effect
-            Effect.zipRight(handle(input, headers)),
-            // TODO: support ParseResult if the error channel of the request allows it.. but who would want that?
-            Effect.catchAll((_) => ParseResult.isParseError(_) ? Effect.die(_) : Effect.fail(_)),
-            Effect.tapErrorCause((cause) => Cause.isFailure(cause) ? logRequestError(cause) : Effect.void),
-            Effect.tapDefect((cause) =>
-              Effect
-                .all([
-                  reportRequestError(cause, {
-                    action: `${moduleName}.${input._tag}`
-                  }),
-                  InfraLogger
-                    .logError("Finished request", cause)
-                    .pipe(Effect.annotateLogs({
-                      action: `${moduleName}.${input._tag}`,
-                      req: pretty(input),
-                      headers: pretty(headers)
-                      // resHeaders: pretty(
-                      //   Object
-                      //     .entries(headers)
-                      //     .reduce((prev, [key, value]) => {
-                      //       prev[key] = value && typeof value === "string" ? snipString(value) : value
-                      //       return prev
-                      //     }, {} as Record<string, any>)
-                      // )
-                    }))
-                ])
-            ),
-            devMode ? (_) => _ : Effect.catchAllDefect(() => Effect.die("Internal Server Error"))
-          )
-      })
+            : payload
+        )
+        .pipe(
+          // can't use andThen due to some being a function and effect
+          Effect.zipRight(next),
+          // TODO: support ParseResult if the error channel of the request allows it.. but who would want that?
+          Effect.catchAll((_) => ParseResult.isParseError(_) ? Effect.die(_) : Effect.fail(_)),
+          Effect.tapErrorCause((cause) => Cause.isFailure(cause) ? logRequestError(cause) : Effect.void),
+          Effect.tapDefect((cause) =>
+            Effect
+              .all([
+                reportRequestError(cause, {
+                  action: rpc._tag
+                }),
+                InfraLogger
+                  .logError("Finished request", cause)
+                  .pipe(Effect.annotateLogs({
+                    action: rpc._tag,
+                    req: pretty(payload),
+                    headers: pretty(headers)
+                    // resHeaders: pretty(
+                    //   Object
+                    //     .entries(headers)
+                    //     .reduce((prev, [key, value]) => {
+                    //       prev[key] = value && typeof value === "string" ? snipString(value) : value
+                    //       return prev
+                    //     }, {} as Record<string, any>)
+                    // )
+                  }))
+              ])
+          ),
+          devMode ? (_) => _ : Effect.catchAllDefect(() => Effect.die("Internal Server Error"))
+        )
+    }))
   })
 }) {}
 
 export const DefaultGenericMiddlewares = [
+  RequestCacheMiddleware,
   ConfigureInterruptibility,
-  CaptureHttpHeadersAsRpcHeaders,
   MiddlewareLogger
 ] as const

package/test/controller.test.ts

@@ -1,13 +1,13 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
-import { type MakeContext, type MakeErrors, makeRouter, RequestCacheLayers } from "@effect-app/infra/api/routing"
+import { type MakeContext, type MakeErrors, makeRouter } from "@effect-app/infra/api/routing"
 import type { RequestContext } from "@effect-app/infra/RequestContext"
 import { expect, expectTypeOf, it } from "@effect/vitest"
 import { type Array, Context, Effect, Layer, Option, S } from "effect-app"
 import { InvalidStateError, makeRpcClient, type RPCContextMap, UnauthorizedError } from "effect-app/client"
-import { type HttpHeaders, type HttpRouter, HttpServerRequest } from "effect-app/http"
+import { HttpServerRequest } from "effect-app/http"
 import { Class, TaggedError } from "effect-app/Schema"
-import { ContextProvider, DefaultGenericMiddlewares, makeMiddleware, mergeContextProviders, MergedContextProvider } from "../src/api/routing/middleware.js"
+import { ContextProvider, DefaultGenericMiddlewares, genericMiddleware, implementMiddleware, makeMiddleware, mergeContextProviders, MergedContextProvider } from "../src/api/routing/middleware.js"
 import { sort } from "../src/api/routing/tsort.js"
 import { SomeService } from "./query.test.js"
 
@@ -76,11 +76,24 @@ class MyContextProvider extends Effect.Service<MyContextProvider>()("MyContextPr
   })
 }) {}
 
-class RequestCacheContext extends Effect.Service<RequestCacheContext>()("RequestCacheContext", {
+// @effect-diagnostics-next-line missingEffectServiceDependency:off
+class MyContextProvider2 extends Effect.Service<MyContextProvider2>()("MyContextProvider2", {
   effect: Effect.gen(function*() {
+    yield* SomeService
+    if (Math.random() > 0.5) return yield* new CustomError1()
+
     return Effect.gen(function*() {
-      const ctx = yield* Layer.build(RequestCacheLayers)
-      return ctx as Context.Context<any> // todo: ugh.
+      // the only requiremeno you can have are the one provided by HttpRouter.HttpRouter.Provided
+      yield* HttpServerRequest.HttpServerRequest
+
+      // this is allowed here but mergeContextProviders/MergedContextProvider will trigger an error
+      // yield* SomeElse
+
+      // currently the effectful context provider cannot trigger an error when building the per request context
+      // this is allowed here but mergeContextProviders/MergedContextProvider will trigger an error
+      // if (Math.random() > 0.5) return yield* new CustomError2()
+
+      return Context.make(SomeElse, new SomeElse({ b: 2 }))
     })
   })
 }) {}
@@ -90,9 +103,9 @@ export const contextProvider2 = ContextProvider(merged)
 export const contextProvider3 = MergedContextProvider(MyContextProvider)
 expectTypeOf(contextProvider2).toEqualTypeOf<typeof someContextProvider>()
 expectTypeOf(contextProvider3).toEqualTypeOf<typeof contextProvider2>()
-const merged2 = mergeContextProviders(MyContextProvider, RequestCacheContext)
+const merged2 = mergeContextProviders(MyContextProvider, MyContextProvider2)
 export const contextProvider22 = ContextProvider(merged2)
-export const contextProvider23 = MergedContextProvider(MyContextProvider, RequestCacheContext)
+export const contextProvider23 = MergedContextProvider(MyContextProvider, MyContextProvider2)
 expectTypeOf(contextProvider23).toEqualTypeOf<typeof contextProvider22>()
 
 export type RequestContextMap = {
@@ -124,8 +137,10 @@ class AllowAnonymous extends Effect.Service<AllowAnonymous>()("AllowAnonymous",
   })
 }) {}
 
+// @effect-diagnostics-next-line missingEffectServiceDependency:off
 class RequireRoles extends Effect.Service<RequireRoles>()("RequireRoles", {
   effect: Effect.gen(function*() {
+    yield* Some
     return {
       handle: Effect.fn(
         function*(cfg: { requireRoles?: readonly string[] }) {
@@ -154,24 +169,21 @@ class Test extends Effect.Service<Test>()("Test", {
   })
 }) {}
 
-export class MiddlewareLogger2 extends Effect.Service<MiddlewareLogger2>()("MiddlewareLogger2", {
+export class BogusMiddleware extends Effect.Service<BogusMiddleware>()("BogusMiddleware", {
   effect: Effect.gen(function*() {
-    return <A, E>(
-      handle: (input: any, headers: HttpHeaders.Headers) => Effect.Effect<A, E, HttpRouter.HttpRouter.Provided>,
-      _moduleName: string
-    ) =>
-      Effect.fnUntraced(function*(input: any, headers: HttpHeaders.Headers) {
-        return yield* handle(input, headers)
-      })
+    return genericMiddleware(Effect.fnUntraced(function*(options) {
+      return yield* options.next
+    }))
   })
 }) {}
 
+const contextProvider = MergedContextProvider(MyContextProvider2, MyContextProvider)
 // TODO: eventually it might be nice if we have total control over order somehow..
 // [ AddRequestNameToSpanContext, RequestCacheContext, UninterruptibleMiddleware, Dynamic(or individual, AllowAnonymous, RequireRoles, Test - or whichever order) ]
 const middleware = makeMiddleware<RequestContextMap>()({
   // TODO: I guess it makes sense to support just passing array of context providers too, like dynamicMiddlewares?
-  contextProvider: MergedContextProvider(RequestCacheContext, MyContextProvider),
-  genericMiddlewares: [...DefaultGenericMiddlewares, MiddlewareLogger2],
+  contextProvider,
+  genericMiddlewares: [...DefaultGenericMiddlewares, BogusMiddleware],
   // or is the better api to use constructors outside, like how contextProvider is used now?
   dynamicMiddlewares: {
     requireRoles: RequireRoles,
@@ -202,8 +214,8 @@ const middleware = makeMiddleware<RequestContextMap>()({
 
 const middleware2 = makeMiddleware<RequestContextMap>()({
   // TODO: I guess it makes sense to support just passing array of context providers too, like dynamicMiddlewares?
-  contextProvider: MergedContextProvider(RequestCacheContext, MyContextProvider),
-  genericMiddlewares: [...DefaultGenericMiddlewares, MiddlewareLogger2],
+  contextProvider,
+  genericMiddlewares: [...DefaultGenericMiddlewares, BogusMiddleware],
   // or is the better api to use constructors outside, like how contextProvider is used now?
   dynamicMiddlewares: {
     requireRoles: RequireRoles,
@@ -439,3 +451,9 @@ expectTypeOf({} as MakeErrors<typeof router2.make>).toEqualTypeOf<InvalidStateEr
 expectTypeOf({} as makeContext2).toEqualTypeOf<
   SomethingService | SomethingRepo | SomethingService2
 >()
+
+export const dynamicMiddlewares = implementMiddleware<RequestContextMap>()({
+  requireRoles: RequireRoles,
+  allowAnonymous: AllowAnonymous,
+  test: Test
+})

package/test/dist/controller.test.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"controller.test.d.ts","sourceRoot":"","sources":["../controller.test.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"controller.test.d.ts","sourceRoot":"","sources":["../controller.test.ts"],"names":[],"mappings":"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"}