@effect-app/infra 2.80.0 → 2.81.0

package/dist/api/routing/middleware/middleware.d.ts

@@ -2,21 +2,21 @@ import { Context } from "effect-app";
 declare const DevMode_base: Context.ReferenceClass<DevMode, "DevMode", boolean>;
 export declare class DevMode extends DevMode_base {
 }
-declare const RequestCacheMiddleware_base: import("@effect/rpc/RpcMiddleware").TagClass<RequestCacheMiddleware, "RequestCacheMiddleware", {
+declare const RequestCacheMiddleware_base: import("./DynamicMiddleware.js").TagClass<RequestCacheMiddleware, "RequestCacheMiddleware", {
     readonly wrap: true;
 }> & {
     Default: import("effect/Layer").Layer<RequestCacheMiddleware, never, never>;
 };
 export declare class RequestCacheMiddleware extends RequestCacheMiddleware_base {
 }
-declare const ConfigureInterruptibility_base: import("@effect/rpc/RpcMiddleware").TagClass<ConfigureInterruptibility, "ConfigureInterruptibility", {
+declare const ConfigureInterruptibility_base: import("./DynamicMiddleware.js").TagClass<ConfigureInterruptibility, "ConfigureInterruptibility", {
     readonly wrap: true;
 }> & {
     Default: import("effect/Layer").Layer<ConfigureInterruptibility, never, never>;
 };
 export declare class ConfigureInterruptibility extends ConfigureInterruptibility_base {
 }
-declare const MiddlewareLogger_base: import("@effect/rpc/RpcMiddleware").TagClass<MiddlewareLogger, "MiddlewareLogger", {
+declare const MiddlewareLogger_base: import("./DynamicMiddleware.js").TagClass<MiddlewareLogger, "MiddlewareLogger", {
     readonly wrap: true;
 }> & {
     Default: import("effect/Layer").Layer<MiddlewareLogger, never, never>;

package/dist/api/routing/middleware.d.ts

@@ -2,6 +2,7 @@ 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 * as Middleware from "./middleware.js";
 //# sourceMappingURL=middleware.d.ts.map

package/dist/api/routing/middleware.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"middleware.d.ts","sourceRoot":"","sources":["../../../src/api/routing/middleware.ts"],"names":[],"mappings":"AACA,cAAc,iCAAiC,CAAA;AAC/C,cAAc,oCAAoC,CAAA;AAClD,cAAc,mCAAmC,CAAA;AACjD,cAAc,oCAAoC,CAAA;AAClD,cAAc,4BAA4B,CAAA;AAG1C,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAA"}
+{"version":3,"file":"middleware.d.ts","sourceRoot":"","sources":["../../../src/api/routing/middleware.ts"],"names":[],"mappings":"AACA,cAAc,iCAAiC,CAAA;AAC/C,cAAc,oCAAoC,CAAA;AAClD,cAAc,mCAAmC,CAAA;AACjD,cAAc,oCAAoC,CAAA;AAClD,cAAc,gCAAgC,CAAA;AAC9C,cAAc,4BAA4B,CAAA;AAG1C,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAA"}

package/dist/api/routing/middleware.js

@@ -3,7 +3,8 @@ 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";
 // codegen:end
 export * as Middleware from "./middleware.js";
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWlkZGxld2FyZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9hcGkvcm91dGluZy9taWRkbGV3YXJlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLDRFQUE0RTtBQUM1RSxjQUFjLGlDQUFpQyxDQUFBO0FBQy9DLGNBQWMsb0NBQW9DLENBQUE7QUFDbEQsY0FBYyxtQ0FBbUMsQ0FBQTtBQUNqRCxjQUFjLG9DQUFvQyxDQUFBO0FBQ2xELGNBQWMsNEJBQTRCLENBQUE7QUFDMUMsY0FBYztBQUVkLE9BQU8sS0FBSyxVQUFVLE1BQU0saUJBQWlCLENBQUEifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWlkZGxld2FyZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9hcGkvcm91dGluZy9taWRkbGV3YXJlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLDRFQUE0RTtBQUM1RSxjQUFjLGlDQUFpQyxDQUFBO0FBQy9DLGNBQWMsb0NBQW9DLENBQUE7QUFDbEQsY0FBYyxtQ0FBbUMsQ0FBQTtBQUNqRCxjQUFjLG9DQUFvQyxDQUFBO0FBQ2xELGNBQWMsZ0NBQWdDLENBQUE7QUFDOUMsY0FBYyw0QkFBNEIsQ0FBQTtBQUMxQyxjQUFjO0FBRWQsT0FBTyxLQUFLLFVBQVUsTUFBTSxpQkFBaUIsQ0FBQSJ9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect-app/infra",
-  "version": "2.80.0",
+  "version": "2.81.0",
   "license": "MIT",
   "type": "module",
   "dependencies": {
@@ -322,6 +322,10 @@
       "types": "./dist/api/routing/middleware/middleware.d.ts",
       "default": "./dist/api/routing/middleware/middleware.js"
     },
+    "./api/routing/middleware/middleware-api": {
+      "types": "./dist/api/routing/middleware/middleware-api.d.ts",
+      "default": "./dist/api/routing/middleware/middleware-api.js"
+    },
     "./api/routing/schema/jwt": {
       "types": "./dist/api/routing/schema/jwt.d.ts",
       "default": "./dist/api/routing/schema/jwt.js"

package/src/api/internal/auth.ts

@@ -11,9 +11,7 @@ import { auth, InsufficientScopeError, InvalidRequestError, InvalidTokenError, U
 type Config = Parameters<typeof auth>[0]
 export const checkJWTI = (config: Config) => {
   const mw = auth(config)
-  return Effect.gen(function*() {
-    const req = yield* HttpServerRequest.HttpServerRequest
-
+  return Effect.fnUntraced(function*(headers: HttpHeaders.Headers) {
     return yield* Effect.async<
       void,
       InsufficientScopeError | InvalidRequestError | InvalidTokenError | UnauthorizedError
@@ -31,7 +29,7 @@ export const checkJWTI = (config: Config) => {
           }
           return cb(Effect.die(err))
         }
-        const r = { headers: req.headers, query: {}, body: {}, is: () => false } // is("urlencoded")
+        const r = { headers, query: {}, body: {}, is: () => false } // is("urlencoded")
         try {
           mw(r as any, {} as any, next)
         } catch (e) {
@@ -46,7 +44,8 @@ export const checkJwt = (config: Config) => {
   const check = checkJWTI(config)
   return HttpMiddleware.make((app) =>
     Effect.gen(function*() {
-      const response = yield* check.pipe(Effect.catchAll((e) =>
+      const req = yield* HttpServerRequest.HttpServerRequest
+      const response = yield* check(req.headers).pipe(Effect.catchAll((e) =>
         Effect.succeed(
           HttpServerResponse.unsafeJson({ message: e.message }, {
             status: e.status,

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

@@ -2,8 +2,8 @@
 /* eslint-disable @typescript-eslint/no-unsafe-return */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { Rpc, RpcMiddleware } from "@effect/rpc"
-import { type SuccessValue, type TagClass } from "@effect/rpc/RpcMiddleware"
-import { Console, Context, Effect, Layer, type NonEmptyReadonlyArray, type Request, type S, type Schema, type Scope, Unify } from "effect-app"
+import { type SuccessValue, type TypeId } from "@effect/rpc/RpcMiddleware"
+import { Console, Context, Effect, Layer, type NonEmptyReadonlyArray, type Option, type Request, type S, type Schema, type Scope, Unify } from "effect-app"
 import type { GetEffectContext, RPCContextMap } from "effect-app/client/req"
 import { type HttpHeaders } from "effect-app/http"
 import { type TagUnify, type TagUnifyIgnore } from "effect/Context"
@@ -83,7 +83,7 @@ export type RPCHandlerFactory<
   >
 >
 
-type RequestContextMapProvider<RequestContextMap extends Record<string, RPCContextMap.Any>> = {
+export type RequestContextMapProvider<RequestContextMap extends Record<string, RPCContextMap.Any>> = {
   [K in keyof RequestContextMap]: ContextWithLayer.Base<
     { [K in keyof RequestContextMap]?: RequestContextMap[K]["contextActivation"] },
     RequestContextMap[K]["service"],
@@ -155,6 +155,13 @@ export type RequestContextMapErrors<RequestContextMap extends Record<string, RPC
   RequestContextMap[keyof RequestContextMap]["error"]
 >
 
+/*:
+    & Context.Tag<MiddlewareMakerId, {
+      effect: RPCHandlerFactory<RequestContextMap, GenericMiddlewareMaker.Provided<GenericMiddlewareProviders[number]>>
+      _tag: "MiddlewareMaker"
+    }>
+    & { Default: "abc" } */
+
 // factory for middlewares
 export const makeMiddleware =
   // by setting RequestContextMap beforehand, execute contextual typing does not fuck up itself to anys
@@ -193,6 +200,131 @@ export const makeMiddleware =
     const dynamicMiddlewares = implementMiddleware<RequestContextMap>()(make.dynamicMiddlewares)
     const middlewares = genericMiddlewareMaker(...make.genericMiddlewares)
 
+    const l = Layer.scoped(
+      MiddlewareMaker,
+      Effect
+        .all({
+          dynamicMiddlewares: dynamicMiddlewares.effect,
+          generic: middlewares.effect,
+          middleware: make.execute
+            ? make.execute((
+              cb: MakeRPCHandlerFactory<
+                RequestContextMap,
+                Scope.Scope | GenericMiddlewareMaker.Provided<GenericMiddlewareProviders[number]>
+              >
+            ) => cb)
+            : Effect.succeed<
+              MakeRPCHandlerFactory<
+                RequestContextMap,
+                Scope.Scope | GenericMiddlewareMaker.Provided<GenericMiddlewareProviders[number]>
+              >
+            >((_schema, next) => (payload, headers) => next(payload, headers))
+        })
+        .pipe(
+          Effect.map(({ dynamicMiddlewares, generic, middleware }) => ({
+            _tag: "MiddlewareMaker" as const,
+            effect: makeRpcEffect<
+              RequestContextMap,
+              GenericMiddlewareMaker.Provided<GenericMiddlewareProviders[number]>
+            >()(
+              (schema, next, moduleName) => {
+                const h = middleware(schema, next as any, moduleName)
+                return (payload, headers) => {
+                  const basic = {
+                    config: schema.config ?? {},
+                    payload,
+                    headers,
+                    clientId: 0, // TODO: get the clientId from the request context
+                    rpc: {
+                      ...Rpc.fromTaggedRequest(schema as any),
+                      // middlewares ? // todo: get from actual middleware flow?
+                      annotations: Context.empty(), // TODO //Annotations(schema as any),
+                      // successSchema: schema.success ?? Schema.Void,
+                      // errorSchema: schema.failure ?? Schema.Never,
+                      payloadSchema: schema,
+                      _tag: `${moduleName}.${payload._tag}`,
+                      key: `${moduleName}.${payload._tag}` /* ? */
+                      // clientId: 0 as number /* ? */
+                    }
+                  }
+                  return Effect
+                    .gen(function*() {
+                      const gen = generic({
+                        ...basic,
+                        next:
+                          // the contextProvider is an Effect that builds the context for the request
+                          // the dynamicMiddlewares is an Effect that builds the dynamiuc context for the request
+                          dynamicMiddlewares(basic).pipe(
+                            Effect.flatMap((dynamicContext) => h(payload, headers).pipe(Effect.provide(dynamicContext)))
+                          ) as any
+                      })
+                      console.log({ gen })
+
+                      return yield* gen
+                    })
+                    .pipe(Effect.onExit(Console.log)) as any // why?
+                }
+              }
+            )
+          })),
+          Effect.onExit(Console.log)
+        )
+    )
+
+    const dependencies = [
+      ...(make.dependencies ? make.dependencies : []),
+      ...(dynamicMiddlewares.dependencies as any),
+      ...middlewares.dependencies
+    ]
+    const middlewareLayer = l
+      .pipe(
+        Layer.provide(dependencies as any)
+      ) as Layer.Layer<
+        MiddlewareMakerId,
+        | MakeMiddlewareE // what the middleware construction can fail with
+        | LayerUtils.GetLayersError<typeof dynamicMiddlewares.dependencies>
+        | LayerUtils.GetLayersError<typeof middlewares.dependencies>, // what could go wrong when building the dynamic middleware provider
+        | LayerUtils.GetLayersContext<MiddlewareDependencies> // what's needed to build layers
+        | LayerUtils.GetLayersContext<typeof middlewares.dependencies>
+        | LayerUtils.GetLayersContext<typeof dynamicMiddlewares.dependencies> // what's needed to build dynamic middleware layers
+        | Exclude<MakeMiddlewareR, LayerUtils.GetLayersSuccess<MiddlewareDependencies>> // what layers provides
+      >
+
+    return Object.assign(MiddlewareMaker, { Default: middlewareLayer })
+  }
+
+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 NonEmptyReadonlyArray<GenericMiddlewareMaker>
+  >(
+    make: MiddlewareMake<
+      RequestContextMap,
+      RequestContextProviders,
+      GenericMiddlewareProviders,
+      never,
+      never,
+      never
+    >
+  ) => {
+    const MiddlewareMaker = Context.GenericTag<
+      MiddlewareMakerId,
+      {
+        effect: RPCHandlerFactory<
+          RequestContextMap,
+          GenericMiddlewareMaker.Provided<GenericMiddlewareProviders[number]>
+        >
+        _tag: "MiddlewareMaker"
+      }
+    >(
+      "MiddlewareMaker"
+    )
+
+    const dynamicMiddlewares = implementMiddleware<RequestContextMap>()(make.dynamicMiddlewares)
+    const middlewares = genericMiddlewareMaker(...make.genericMiddlewares)
+
     const l = Layer.scoped(
       MiddlewareMaker,
       Effect
@@ -225,7 +357,8 @@ export const makeMiddleware =
                 return (payload, headers) =>
                   Effect
                     .gen(function*() {
-                      const gen = generic({
+                      const basic = {
+                        config: schema.config ?? {},
                         payload,
                         headers,
                         clientId: 0, // TODO: get the clientId from the request context
@@ -239,17 +372,17 @@ export const makeMiddleware =
                           _tag: `${moduleName}.${payload._tag}`,
                           key: `${moduleName}.${payload._tag}` /* ? */
                           // clientId: 0 as number /* ? */
-                        }, // todo: make moduleName part of the tag on S.Req creation.
+                        }
+                      }
+                      return yield* generic({
+                        ...basic,
                         next:
                           // the contextProvider is an Effect that builds the context for the request
                           // the dynamicMiddlewares is an Effect that builds the dynamiuc context for the request
-                          dynamicMiddlewares(schema.config ?? {}, headers).pipe(
+                          dynamicMiddlewares(basic).pipe(
                             Effect.flatMap((dynamicContext) => h(payload, headers).pipe(Effect.provide(dynamicContext)))
                           ) as any
                       })
-                      console.log({ gen })
-
-                      return yield* gen
                     })
                     .pipe(Effect.onExit(Console.log)) as any // why?
               }
@@ -261,7 +394,7 @@ export const makeMiddleware =
 
     const dependencies = [
       ...(make.dependencies ? make.dependencies : []),
-      ...(dynamicMiddlewares.dependencies as any),
+      ...(dynamicMiddlewares.dependencies),
       ...middlewares.dependencies
     ]
     const middlewareLayer = l
@@ -269,13 +402,10 @@ export const makeMiddleware =
         Layer.provide(dependencies as any)
       ) as Layer.Layer<
         MiddlewareMakerId,
-        | MakeMiddlewareE // what the middleware construction can fail with
         | LayerUtils.GetLayersError<typeof dynamicMiddlewares.dependencies>
         | LayerUtils.GetLayersError<typeof middlewares.dependencies>, // what could go wrong when building the dynamic middleware provider
-        | LayerUtils.GetLayersContext<MiddlewareDependencies> // what's needed to build layers
         | LayerUtils.GetLayersContext<typeof middlewares.dependencies>
         | LayerUtils.GetLayersContext<typeof dynamicMiddlewares.dependencies> // what's needed to build dynamic middleware layers
-        | Exclude<MakeMiddlewareR, LayerUtils.GetLayersSuccess<MiddlewareDependencies>> // what layers provides
       >
 
     return Object.assign(MiddlewareMaker, { Default: middlewareLayer })
@@ -347,10 +477,154 @@ type RpcOptionsOriginal = {
   readonly requiredForClient?: boolean
 }
 
+type RpcDynamic<Key extends string, A extends RPCContextMap.Any> = {
+  key: Key
+  settings: A
+}
+
+type RpcOptionsDynamic<Key extends string, A extends RPCContextMap.Any> = RpcOptionsOriginal & {
+  readonly dynamic: RpcDynamic<Key, A>
+}
+
+export type Dynamic<Options> = Options extends RpcOptionsDynamic<any, any> ? true : false
+
+export interface RpcMiddlewareDynamic<A, E, Config> {
+  (options: {
+    readonly config: Config // todo
+    readonly clientId: number
+    readonly rpc: Rpc.AnyWithProps
+    readonly payload: unknown
+    readonly headers: HttpHeaders.Headers
+  }): Effect.Effect<Option.Option<Context.Context<A>>, E, Scope.Scope>
+}
+
+export interface TagClassDynamicAny<RequestContext extends Record<string, RPCContextMap.Any>>
+  extends Context.Tag<any, any>
+{
+  readonly [RpcMiddleware.TypeId]: RpcMiddleware.TypeId
+  readonly optional: boolean
+  readonly provides?: Context.Tag<any, any> | undefined
+  readonly failure: Schema.Schema.All
+  readonly requiredForClient: boolean
+  readonly dynamic: RpcDynamic<any, RequestContext[keyof RequestContext]>
+  readonly wrap: boolean
+}
+
+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"]>
+    : 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> } ? A["service"]
+    : 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"]
+      : undefined
+    readonly dynamic: Options extends RpcOptionsDynamic<any, any> ? Options["dynamic"]
+      : undefined
+    readonly requiredForClient: RequiredForClient<Options>
+    readonly wrap: Wrap<Options>
+  }
+}
+
+export interface TagClass<
+  Self,
+  Name extends string,
+  Options
+> extends
+  TagClass.Base<
+    Self,
+    Name,
+    Options,
+    TagClass.Wrap<Options> extends true ? RpcMiddlewareWrap<
+        TagClass.Provides<Options>,
+        TagClass.Failure<Options>
+      >
+      : Options extends RpcOptionsDynamic<any, any> ? RpcMiddlewareDynamic<
+          TagClass.Service<Options>,
+          TagClass.FailureService<Options>,
+          { [K in Options["dynamic"]["key"]]?: Options["dynamic"]["settings"]["contextActivation"] }
+        >
+      : RpcMiddleware<
+        TagClass.Service<Options>,
+        TagClass.FailureService<Options>
+      >
+  >
+{}
+
 export const Tag = <Self>() =>
 <
   const Name extends string,
-  const Options extends RpcOptionsOriginal
+  const Options extends RpcOptionsOriginal | RpcOptionsDynamic<any, any>
 >(
   id: Name,
   options?: Options | undefined
@@ -361,6 +635,11 @@ export const Tag = <Self>() =>
         TagClass.Provides<Options>,
         TagClass.Failure<Options>
       >
+      : Options extends RpcOptionsDynamic<any, any> ? RpcMiddlewareDynamic<
+          TagClass.Service<Options>,
+          TagClass.FailureService<Options>,
+          { [K in Options["dynamic"]["key"]]?: Options["dynamic"]["settings"]["contextActivation"] }
+        >
       : RpcMiddleware<
         TagClass.Service<Options>,
         TagClass.FailureService<Options>
@@ -369,10 +648,12 @@ export const Tag = <Self>() =>
     R
   >
   dependencies?: L
-}): RpcMiddleware.TagClass<Self, Name, Options> & {
+}): TagClass<Self, Name, Options> & {
   Default: Layer.Layer<Self, E | LayerUtils.GetLayersError<L>, Exclude<R, LayerUtils.GetLayersSuccess<L>>>
 } =>
   class extends RpcMiddleware.Tag<Self>()(id, options) {
+    // TODO: move to TagClass.
+    static readonly dynamic = options && "dynamic" in options ? options.dynamic : undefined
     static readonly Default = Layer.scoped(this, opts.effect as any).pipe(
       Layer.provide([Layer.empty, ...opts.dependencies ?? []])
     )

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

@@ -1,10 +1,12 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { Array, type Context, Effect, type Option, type S } from "effect-app"
+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"
 
 export type ContextWithLayer<
   Config,
@@ -18,25 +20,13 @@ export type ContextWithLayer<
   & (
     | ContextTagWithDefault<
       Id,
-      {
-        _tag: any
-        handle: (
-          config: Config,
-          headers: Record<string, string>
-        ) => Effect<Option<Context<Service>>, Error, any>
-      },
+      RpcMiddlewareDynamic<Service, Error, Config>,
       LayerE,
       LayerR
     >
     | ContextTagWithDefault<
       Id,
-      {
-        _tag: any
-        handle: (
-          config: Config,
-          headers: Record<string, string>
-        ) => Effect<Option<Context<Service>>, Error, never>
-      },
+      RpcMiddlewareDynamic<Service, Error, Config>,
       LayerE,
       LayerR
     >
@@ -76,26 +66,25 @@ export const implementMiddleware = <T extends Record<string, RPCContextMap.Any>>
 
     const makers = yield* Effect.all(sorted)
     return Effect.fnUntraced(
-      function*(config: { [K in keyof T]?: T[K]["contextActivation"] }, headers: Record<string, string>) {
+      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).handle(config, headers) as any }) as any
+            (_, i) => ({ maker: sorted[i], handle: (_ as any)(options) as any }) as any
           )
         )
         return ctx as Context.Context<
-          GetEffectContext<T, typeof config>
+          GetEffectContext<T, typeof options["config"]>
         >
       }
     )
   }) as unknown as Effect<
     (
-      config: { [K in keyof T]?: T[K]["contextActivation"] },
-      headers: Record<string, string>
+      options: { config: { [K in keyof T]?: T[K]["contextActivation"] }; headers: HttpHeaders.Headers }
     ) => 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"]>>
+      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

@@ -2,8 +2,10 @@
 import { type Rpc, type RpcMiddleware } from "@effect/rpc"
 import { type SuccessValue, type TagClassAny } from "@effect/rpc/RpcMiddleware"
 import { type Array, Context, Effect, type Layer, type Scope } from "effect-app"
+import { type RPCContextMap } from "effect-app/client"
 import { type HttpHeaders } from "effect-app/http"
 import { InfraLogger } from "../../../logger.js"
+import { type TagClassDynamicAny } from "./DynamicMiddleware.js"
 
 export interface GenericMiddlewareOptions<E> {
   // Effect rpc middleware does not support changing payload or headers, but we do..
@@ -15,6 +17,9 @@ 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 Provided<T> = T extends TagClassAny

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

@@ -0,0 +1,44 @@
+import { 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"
+
+export const contextMap = <RequestContextMap>() => <K extends keyof RequestContextMap>(a: K) => ({
+  key: a,
+  settings: null as any as RequestContextMap[typeof a]
+})
+
+type DynamicMiddlewareMakerrsss<
+  RequestContext extends Record<string, RPCContextMap.Any>,
+  Provided extends keyof RequestContext,
+  Middlewares extends NonEmptyReadonlyArray<GenericMiddlewareMaker>,
+  DynamicMiddlewareProviders extends RequestContextMapProvider<RequestContext>
+> = keyof Omit<RequestContext, Provided> extends never
+  ? { make: () => ReturnType<typeof makeMiddlewareBasic<RequestContext, DynamicMiddlewareProviders, Middlewares>> }
+  : {
+    addDynamicMiddleware: <MW extends DynamicMiddlewareMaker<RequestContext>>(
+      a: MW
+    ) => DynamicMiddlewareMakerrsss<
+      RequestContext,
+      Provided | MW["dynamic"]["key"],
+      Middlewares,
+      DynamicMiddlewareProviders & { [K in MW["dynamic"]["key"]]: MW }
+    > // TODO: any of RequestContecxtMap, and track them, so remove the ones provided
+  }
+
+export const makeNewMiddleware: <
+  RequestContextMap extends Record<string, RPCContextMap.Any>
+>() => <Middlewares extends NonEmptyReadonlyArray<GenericMiddlewareMaker>>(
+  ...genericMiddlewares: Middlewares
+) => DynamicMiddlewareMakerrsss<RequestContextMap, never, Middlewares, never> = () => (...genericMiddlewares) => {
+  const dynamicMiddlewares: Record<keyof any, any> = {} as any
+  const make = makeMiddleware<any>()
+  const it = {
+    addDynamicMiddleware: (a: any) => {
+      console.log("Adding dynamic middleware", a, a.dynamic, Object.keys(a))
+      ;(dynamicMiddlewares as any)[a.dynamic.key] = a
+      return it
+    },
+    make: () => make({ genericMiddlewares: genericMiddlewares as any, dynamicMiddlewares })
+  }
+  return it
+}

package/src/api/routing/middleware.ts

@@ -3,6 +3,7 @@ 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"
 // codegen:end