@effect-app/infra 2.85.0 → 2.87.0

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

@@ -1,27 +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 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..
@@ -33,19 +17,24 @@ 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>
+  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 Provided<T> = T extends TagClassAny
     ? T extends { provides: Context.Tag<any, any> } ? Context.Tag.Identifier<T["provides"]>
     : T extends { provides: ContextRepr } ? ContextRepr.Identifier<T["provides"]>
     : never
     : never
-}
 
-export const genericMiddleware = (i: GenericMiddlewareMaker) => i
+  export type Required<T> = T extends TagClassAny
+    ? T extends { requires: Context.Tag<any, any> } ? Context.Tag.Identifier<T["requires"]>
+    : T extends { requires: ContextRepr } ? ContextRepr.Identifier<T["requires"]>
+    : never
+    : never
+}
 
 export const genericMiddlewareMaker = <
   T extends Array<GenericMiddlewareMaker>
@@ -59,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>
       ) => {
@@ -72,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
@@ -89,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

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

@@ -1,50 +1,220 @@
-import { type NonEmptyReadonlyArray } from "effect-app"
+import { Rpc } from "@effect/rpc"
+import { Context, Effect, Layer, type NonEmptyArray, type NonEmptyReadonlyArray } from "effect-app"
 import { type RPCContextMap } from "effect-app/client"
-import { type DynamicMiddlewareMaker, type GenericMiddlewareMaker, makeMiddleware, type makeMiddlewareBasic, type RequestContextMapProvider } from "../../routing.js"
+import { type Simplify } from "effect-app/Types"
+import { type LayerUtils } from "../../layerUtils.js"
+import { type GenericMiddlewareMaker, genericMiddlewareMaker } from "./generic-middleware.js"
+import { makeRpcEffect, type MiddlewareMakerId, type RPCHandlerFactory } from "./RouterMiddleware.js"
+import { type AnyDynamic, type RpcDynamic, type TagClassAny } from "./RpcMiddleware.js"
 
-// TODO: ContextMap should be physical Tag (so typeof Tag), so that we can retrieve Identifier and Service separately.
-// in Service classes and TagId, the Id and Service are the same, but don't have to be in classic Tag or GenericTag.
-export const contextMap = <RequestContextMap>() => <K extends keyof RequestContextMap>(a: K) => ({
-  key: a,
-  settings: null as any as RequestContextMap[typeof a]
-})
+// TODO: don't expect service when it's wrap/never
+// perhaps RequestContextMap should be an object, instead of an interface, so that we don't need to provide anything here
+export const contextMap =
+  <RequestContextMap extends Record<string, RPCContextMap.Any>>() =>
+  <K extends keyof RequestContextMap>(a: K, service: RequestContextMap[K]["service"]) => ({
+    key: a,
+    settings: { service } as any as RequestContextMap[typeof a]
+  })
 
-type DynamicMiddlewareMakerrsss<
+export interface MiddlewareM<
+  RequestContext extends Record<string, RPCContextMap.Any>,
+  Provided extends keyof RequestContext,
+  Middlewares extends ReadonlyArray<GenericMiddlewareMaker>,
+  DynamicMiddlewareProviders,
+  // out MiddlewareR = never
+  MiddlewareR = never
+> {
+  middleware<MW extends NonEmptyArray<GenericMiddlewareMaker>>(
+    ...mw: MW
+  ): DynamicMiddlewareMakerrsss<
+    RequestContext,
+    Provided,
+    [...Middlewares, ...MW],
+    DynamicMiddlewareProviders,
+    GenericMiddlewareMaker.ApplyManyServices<MW, MiddlewareR>
+  >
+}
+
+type GetDependsOnKeys<MW extends GenericMiddlewareMaker> = MW extends { dependsOn: NonEmptyReadonlyArray<TagClassAny> }
+  ? {
+    [K in keyof MW["dependsOn"]]: MW["dependsOn"][K] extends AnyDynamic ? MW["dependsOn"][K]["dynamic"]["key"]
+      : never
+  }[keyof MW["dependsOn"]]
+  : never
+
+export interface MiddlewareDynamic<
   RequestContext extends Record<string, RPCContextMap.Any>,
   Provided extends keyof RequestContext,
-  Middlewares extends NonEmptyReadonlyArray<GenericMiddlewareMaker>,
-  DynamicMiddlewareProviders extends RequestContextMapProvider<RequestContext>
-> = keyof Omit<RequestContext, Provided> extends never
-  ? ReturnType<typeof makeMiddlewareBasic<RequestContext, DynamicMiddlewareProviders, Middlewares>>
-  : {
-    addDynamicMiddleware: <MW extends NonEmptyReadonlyArray<DynamicMiddlewareMaker<RequestContext>>>(
-      ...middlewares: MW
-    ) => DynamicMiddlewareMakerrsss<
+  Middlewares extends ReadonlyArray<GenericMiddlewareMaker>,
+  DynamicMiddlewareProviders,
+  out MiddlewareR
+> {
+  middleware<MW extends NonEmptyArray<GenericMiddlewareMaker>>(
+    ...mw: MW
+  ): MW extends NonEmptyArray<{ dynamic: RpcDynamic<any, RequestContext[keyof RequestContext]> }>
+    ? DynamicMiddlewareMakerrsss<
       RequestContext,
-      Provided | MW[number]["dynamic"]["key"],
-      Middlewares,
+      // when one dynamic middleware depends on another, substract the key, to enforce the dependency to be provided after.
+      Exclude<
+        Provided | MW[number]["dynamic"]["key"],
+        { [K in keyof MW]: GetDependsOnKeys<MW[K]> }[number]
+      >,
+      [...Middlewares, ...MW],
       & DynamicMiddlewareProviders
       & {
-        [K in keyof MW as MW[K] extends DynamicMiddlewareMaker<RequestContext> ? MW[K]["dynamic"]["key"] : never]: MW[K]
+        [U in MW[number] as U["dynamic"]["key"]]: U
+      },
+      GenericMiddlewareMaker.ApplyManyServices<MW, MiddlewareR>
+    >
+    : DynamicMiddlewareMakerrsss<
+      RequestContext,
+      Provided,
+      [...Middlewares, ...MW],
+      DynamicMiddlewareProviders,
+      GenericMiddlewareMaker.ApplyManyServices<MW, MiddlewareR>
+    >
+}
+
+type DynamicMiddlewareMakerrsss<
+  RequestContext extends Record<string, RPCContextMap.Any>,
+  Provided extends keyof RequestContext = never,
+  Middlewares extends ReadonlyArray<GenericMiddlewareMaker> = [],
+  DynamicMiddlewareProviders = unknown,
+  MiddlewareR = never
+> = keyof Omit<RequestContext, Provided> extends never ? [MiddlewareR] extends [never] ?
+      & {
+        MiddlewareR: MiddlewareR
+        Provided: Provided
+        Middlewares: Middlewares
+        DynamicMiddlewareProviders: Simplify<DynamicMiddlewareProviders>
       }
+      & ReturnType<
+        typeof makeMiddlewareBasic<
+          RequestContext,
+          Middlewares
+        >
+      >
+      & MiddlewareM<
+        RequestContext,
+        Provided,
+        Middlewares,
+        DynamicMiddlewareProviders,
+        MiddlewareR
+      >
+  :
+    & {
+      MiddlewareR: MiddlewareR
+      Provided: Provided
+      Middlewares: Middlewares
+      DynamicMiddlewareProviders: Simplify<DynamicMiddlewareProviders>
+    }
+    & MiddlewareM<
+      RequestContext,
+      Provided,
+      Middlewares,
+      DynamicMiddlewareProviders,
+      MiddlewareR
+    >
+  :
+    & {
+      MiddlewareR: MiddlewareR
+      Provided: Provided
+      Middlewares: Middlewares
+      DynamicMiddlewareProviders: Simplify<DynamicMiddlewareProviders>
+    }
+    & MiddlewareDynamic<
+      RequestContext,
+      Provided,
+      Middlewares,
+      DynamicMiddlewareProviders,
+      MiddlewareR
     >
-  }
 
-export const makeNewMiddleware: <
+export const makeMiddleware: <
   RequestContextMap extends Record<string, RPCContextMap.Any>
->() => <Middlewares extends NonEmptyReadonlyArray<GenericMiddlewareMaker>>(
-  ...genericMiddlewares: Middlewares
-) => DynamicMiddlewareMakerrsss<RequestContextMap, never, Middlewares, never> = () => (...genericMiddlewares) => {
-  const dynamicMiddlewares: Record<string, any> = {} as any
-  const make = makeMiddleware<any>()
+>() => DynamicMiddlewareMakerrsss<RequestContextMap> = () => {
+  let allMiddleware: GenericMiddlewareMaker[] = []
   const it = {
-    addDynamicMiddleware: (...middlewares: any[]) => {
-      for (const a of middlewares) {
-        console.log("Adding dynamic middleware", a, a.dynamic, Object.keys(a))
-        dynamicMiddlewares[a.dynamic.key] = a
+    middleware: (...middlewares: any[]) => {
+      for (const mw of middlewares) {
+        allMiddleware = [mw, ...allMiddleware]
       }
-      return Object.assign(make({ genericMiddlewares: genericMiddlewares as any, dynamicMiddlewares }), it)
+      // TODO: support dynamic and generic intertwined. treat them as one
+      return Object.assign(makeMiddlewareBasic<any, any>(...allMiddleware), it)
     }
   }
   return it as any
 }
+
+export const makeMiddlewareBasic =
+  // by setting RequestContextMap beforehand, execute contextual typing does not fuck up itself to anys
+  <
+    RequestContextMap extends Record<string, RPCContextMap.Any>,
+    // RequestContextProviders extends RequestContextMapProvider<RequestContextMap>, // how to resolve the dynamic middleware
+    GenericMiddlewareProviders extends ReadonlyArray<GenericMiddlewareMaker>
+  >(
+    ...make: GenericMiddlewareProviders
+  ) => {
+    const MiddlewareMaker = Context.GenericTag<
+      MiddlewareMakerId,
+      {
+        effect: RPCHandlerFactory<
+          RequestContextMap,
+          GenericMiddlewareMaker.Provided<GenericMiddlewareProviders[number]>
+        >
+        _tag: "MiddlewareMaker"
+      }
+    >(
+      "MiddlewareMaker"
+    )
+
+    const middlewares = genericMiddlewareMaker(...make)
+
+    const l = Layer.scoped(
+      MiddlewareMaker,
+      middlewares
+        .effect
+        .pipe(
+          Effect.map((generic) => ({
+            _tag: "MiddlewareMaker" as const,
+            effect: makeRpcEffect<
+              RequestContextMap,
+              GenericMiddlewareMaker.Provided<GenericMiddlewareProviders[number]>
+            >()(
+              (schema, next, moduleName) => {
+                return (payload, headers) =>
+                  Effect
+                    .gen(function*() {
+                      const basic = {
+                        config: schema.config ?? {},
+                        payload,
+                        headers,
+                        clientId: 0, // TODO: get the clientId from the request context
+                        rpc: {
+                          ...Rpc.fromTaggedRequest(schema as any),
+                          key: `${moduleName}.${payload._tag}`,
+                          _tag: `${moduleName}.${payload._tag}`
+                        }
+                      }
+                      return yield* generic({
+                        ...basic,
+                        next: next(payload, headers) as any
+                      })
+                    }) as any // why?
+              }
+            )
+          }))
+        )
+    )
+
+    const middlewareLayer = l
+      .pipe(
+        Layer.provide(middlewares.dependencies as any)
+      ) as Layer.Layer<
+        MiddlewareMakerId,
+        LayerUtils.GetLayersError<typeof middlewares.dependencies>, // what could go wrong when building the dynamic middleware provider
+        LayerUtils.GetLayersContext<typeof middlewares.dependencies>
+      >
+
+    return Object.assign(MiddlewareMaker, { Default: middlewareLayer })
+  }

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

@@ -1,24 +1,32 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { Cause, Context, Effect, ParseResult } from "effect-app"
+import { Cause, Context, Duration, Effect, Layer, ParseResult, Request } from "effect-app"
 import { pretty } from "effect-app/utils"
 import { logError, reportError } from "../../../errorReporter.js"
 import { InfraLogger } from "../../../logger.js"
-import { RequestCacheLayers, Tag } from "../../routing.js"
+import { Tag } from "./RpcMiddleware.js"
 
 const logRequestError = logError("Request")
 const reportRequestError = reportError("Request")
 
+export const RequestCacheLayers = Layer.mergeAll(
+  Layer.setRequestCache(
+    Request.makeCache({ capacity: 500, timeToLive: Duration.hours(8) })
+  ),
+  Layer.setRequestCaching(true),
+  Layer.setRequestBatching(true)
+)
+
 export class DevMode extends Context.Reference<DevMode>()("DevMode", { defaultValue: () => false }) {}
 
 export class RequestCacheMiddleware extends Tag<RequestCacheMiddleware>()("RequestCacheMiddleware", { wrap: true })({
-  effect: Effect.succeed((options) => options.next.pipe(Effect.provide(RequestCacheLayers)))
+  effect: Effect.succeed(({ next }) => next.pipe(Effect.provide(RequestCacheLayers)))
 }) {
 }
 
 export class ConfigureInterruptibility
   extends Tag<ConfigureInterruptibility>()("ConfigureInterruptibility", { wrap: true })({
-    effect: Effect.succeed((options) =>
-      options.next.pipe(
+    effect: Effect.succeed(({ next }) =>
+      next.pipe(
         // TODO: make this depend on query/command, and consider if middleware also should be affected. right now it's not.
         Effect.uninterruptible
       )

package/src/api/routing/middleware.ts

@@ -1,10 +1,11 @@
 // codegen:start {preset: barrel, include: ./middleware/*.ts, nodir: false }
 export * from "./middleware/ContextProvider.js"
 export * from "./middleware/dynamic-middleware.js"
-export * from "./middleware/DynamicMiddleware.js"
 export * from "./middleware/generic-middleware.js"
 export * from "./middleware/middleware-api.js"
 export * from "./middleware/middleware.js"
+export * from "./middleware/RouterMiddleware.js"
+export * from "./middleware/RpcMiddleware.js"
 // codegen:end
 
 export * as Middleware from "./middleware.js"

package/src/api/routing/tsort.ts

@@ -39,7 +39,7 @@ export function tsort(edges) {
   return sorted
 }
 
-export const createEdges = <T extends { dependsOn?: any[] }>(dep: readonly T[]) => {
+export const createEdges = <T extends { dependsOn?: readonly any[] }>(dep: readonly T[]) => {
   const result = []
   dep.forEach((key) => {
     key.dependsOn?.forEach((n) => {
@@ -49,7 +49,7 @@ export const createEdges = <T extends { dependsOn?: any[] }>(dep: readonly T[])
   return result
 }
 
-export const sort = <T>(dep: readonly (T & { dependsOn?: any[] })[]): readonly T[] => {
+export const sort = <T>(dep: readonly (T & { dependsOn?: readonly any[] })[]): readonly T[] => {
   const edges = createEdges(dep)
   const result = tsort(edges)
   return result.concat(dep.filter((v) => !result.includes(v)))

package/src/api/routing.ts

@@ -4,7 +4,7 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { determineMethod, isCommand } from "@effect-app/infra/api/routing/utils"
 import { Rpc, RpcGroup, RpcServer } from "@effect/rpc"
-import { type Array, Duration, Effect, Layer, type NonEmptyReadonlyArray, Predicate, Request, S, Schedule, Schema, type Scope } from "effect-app"
+import { type Array, Effect, Layer, type NonEmptyReadonlyArray, Predicate, S, Schedule, Schema, type Scope } from "effect-app"
 import type { GetEffectContext, GetEffectError, RPCContextMap } from "effect-app/client/req"
 import { type HttpHeaders, HttpRouter } from "effect-app/http"
 import { typedKeysOf, typedValuesOf } from "effect-app/utils"
@@ -819,11 +819,3 @@ export type MakeHandlers<Make, Handlers extends Record<string, any>> = Make exte
  * @since 3.9.0
  */
 export type MakeDepsOut<Make> = Contravariant.Type<MakeDeps<Make>[Layer.LayerTypeId]["_ROut"]>
-
-export const RequestCacheLayers = Layer.mergeAll(
-  Layer.setRequestCache(
-    Request.makeCache({ capacity: 500, timeToLive: Duration.hours(8) })
-  ),
-  Layer.setRequestCaching(true),
-  Layer.setRequestBatching(true)
-)

package/test/contextProvider.test.ts

@@ -3,8 +3,7 @@
 import { expectTypeOf } from "@effect/vitest"
 import { Context, Effect, Scope } from "effect-app"
 import { ContextProvider, mergeContextProviders, MergedContextProvider } from "../src/api/routing.js"
-import { CustomError1, Some, SomeElse } from "./controller.test.js"
-import { SomeService } from "./query.test.js"
+import { CustomError1, Some, SomeElse, SomeService } from "./fixtures.js"
 
 // @effect-diagnostics-next-line missingEffectServiceDependency:off
 class MyContextProvider extends Effect.Service<MyContextProvider>()("MyContextProvider", {