@effect-app/infra 2.71.0 → 2.73.0

package/dist/api/routing.js

@@ -6,10 +6,9 @@ import { determineMethod, isCommand } from "@effect-app/infra/api/routing/utils"
 import { logError, reportError } from "@effect-app/infra/errorReporter";
 import { InfraLogger } from "@effect-app/infra/logger";
 import { Rpc, RpcGroup, RpcServer } from "@effect/rpc";
-import { Array, Cause, Context, Duration, Effect, Layer, ParseResult, Predicate, Request, S, Schedule, Schema } from "effect-app";
+import { Array, Cause, Duration, Effect, Layer, ParseResult, Predicate, Request, S, Schedule, Schema } from "effect-app";
 import { HttpRouter } from "effect-app/http";
 import { pretty, typedKeysOf, typedValuesOf } from "effect-app/utils";
-import { makeMiddlewareLayer, makeRpc } from "./routing/DynamicMiddleware.js";
 export * from "./routing/DynamicMiddleware.js";
 const logRequestError = logError("Request");
 const reportRequestError = reportError("Request");
@@ -27,7 +26,6 @@ export const RouterSymbol = Symbol();
 export class Router extends HttpRouter.Tag("@effect-app/Rpc")() {
 }
 export const makeRouter = (middleware, devMode) => {
-    const middlewareLayer = makeMiddlewareLayer(middleware);
     function matchFor(rsc) {
         const { meta } = rsc;
         const requestModules = typedKeysOf(rsc).reduce((acc, cur) => {
@@ -106,7 +104,7 @@ export const makeRouter = (middleware, devMode) => {
                     ? Effect.fnUntraced(make)(router3)
                     : make;
                 const controllers = yield* make;
-                const rpc = yield* makeRpc(middleware);
+                const rpc = yield* middleware;
                 // return make.pipe(Effect.map((c) => controllers(c, dependencies)))
                 const mapped = typedKeysOf(requestModules).reduce((acc, cur) => {
                     const handler = controllers[cur];
@@ -201,8 +199,7 @@ export const makeRouter = (middleware, devMode) => {
             // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
             const routes = (layer.pipe(Layer.provide([
                 ...dependencies ?? [],
-                middleware.contextProvider.Default,
-                middlewareLayer
+                middleware.Default
             ])));
             // Effect.Effect<HttpRouter.HttpRouter<unknown, HttpRouter.HttpRouter.DefaultServices>, never, UserRouter>
             return {
@@ -224,16 +221,4 @@ export const makeRouter = (middleware, devMode) => {
     };
 };
 export const RequestCacheLayers = Layer.mergeAll(Layer.setRequestCache(Request.makeCache({ capacity: 500, timeToLive: Duration.hours(8) })), Layer.setRequestCaching(true), Layer.setRequestBatching(true));
-export const contextMaker = (...deps) => ({
-    dependencies: deps.map((_) => _.Default),
-    effect: Effect.gen(function* () {
-        const services = yield* Effect.all(deps);
-        // services are effects which return some Context.Context<...>
-        return Effect.all(services).pipe(Effect.map((_) => Context.mergeAll(..._)));
-    })
-});
-export class EmptyContextMaker extends Effect.Service()("EmptyContextMaker", {
-    succeed: Effect.succeed(Context.empty())
-}) {
-}
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"routing.js","sourceRoot":"","sources":["../../src/api/routing.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"routing.js","sourceRoot":"","sources":["../../src/api/routing.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect-app/infra",
-  "version": "2.71.0",
+  "version": "2.73.0",
   "license": "MIT",
   "type": "module",
   "dependencies": {

package/src/api/routing/DynamicMiddleware.ts

@@ -1,14 +1,16 @@
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
 /* eslint-disable @typescript-eslint/no-unsafe-return */
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { Context, Effect, Layer, type NonEmptyArray, type Request, type S, type Scope } from "effect-app"
+import { type Array, Context, Effect, Layer, type NonEmptyArray, type Request, type S } from "effect-app"
 import type { GetEffectContext, RPCContextMap } from "effect-app/client/req"
+import { type HttpRouter } from "effect-app/http"
 import type * as EffectRequest from "effect/Request"
 import { type LayersUtils } from "../routing.js"
 
-export const MiddlewareMaker = Context.GenericTag<"MiddlewareMaker", any>("MiddlewareMaker")
-
-export type RPCHandlerFactory<RequestContextMap extends Record<string, RPCContextMap.Any>, MiddlewareR> = <
+export type MakeRPCHandlerFactory<
+  RequestContextMap extends Record<string, RPCContextMap.Any>,
+  MiddlewareR
+> = <
   T extends {
     config?: Partial<Record<keyof RequestContextMap, any>>
   },
@@ -30,69 +32,68 @@ export type RPCHandlerFactory<RequestContextMap extends Record<string, RPCContex
   headers: any
 ) => Effect.Effect<
   Request.Request.Success<Req>,
-  Request.Request.Error<Req>,
+  Request.Request.Error<Req> | RequestContextMapErrors<RequestContextMap>,
   // the middleware will remove from HandlerR the dynamic context, but will also add the MiddlewareR
   | MiddlewareR
   // & S.Schema<Req, any, never> is useless here but useful when creating the middleware
   | Exclude<HandlerR, GetEffectContext<RequestContextMap, (T & S.Schema<Req, any, never>)["config"]>>
 >
 
-function makeRpcHandler<RequestContextMap extends Record<string, RPCContextMap.Any>, MiddlewareR>() {
-  return (cb: RPCHandlerFactory<RequestContextMap, MiddlewareR>) => cb
-}
-
-export const makeMiddlewareLayer = <
+export type RPCHandlerFactory<
   RequestContextMap extends Record<string, RPCContextMap.Any>,
   MiddlewareR,
-  MakeMiddlewareR,
-  MiddlewareDependencies extends NonEmptyArray<Layer.Layer.Any>,
-  ContextProviderId,
-  ContextProviderKey extends string,
-  ContextProviderA,
-  MakeContextProviderE,
-  MakeContextProviderR
+  ContextProviderA
+> = <
+  T extends {
+    config?: Partial<Record<keyof RequestContextMap, any>>
+  },
+  Req extends S.TaggedRequest.All,
+  HandlerR
 >(
-  middleware: Middleware<
-    MiddlewareR,
-    RequestContextMap,
-    MakeMiddlewareR,
-    MiddlewareDependencies,
-    ContextProviderId,
-    ContextProviderKey,
-    ContextProviderA,
-    MakeContextProviderE,
-    MakeContextProviderR
+  schema: T & S.Schema<Req, any, never>,
+  handler: (
+    request: Req,
+    headers: any
+  ) => Effect.Effect<
+    EffectRequest.Request.Success<Req>,
+    EffectRequest.Request.Error<Req>,
+    HandlerR
+  >,
+  moduleName?: string
+) => (
+  req: Req,
+  headers: any
+) => Effect.Effect<
+  Request.Request.Success<Req>,
+  Request.Request.Error<Req> | RequestContextMapErrors<RequestContextMap>,
+  | HttpRouter.HttpRouter.Provided
+  // the middleware will remove from HandlerR the dynamic context, but will also add the MiddlewareR
+  | Exclude<
+    | MiddlewareR
+    // & S.Schema<Req, any, never> is useless here but useful when creating the middleware
+    | Exclude<HandlerR, GetEffectContext<RequestContextMap, (T & S.Schema<Req, any, never>)["config"]>>,
+    ContextProviderA
   >
-) => {
-  if (!middleware.execute && !middleware.executeContextual) {
-    throw new Error("No execute or executeContextual provided in middleware")
-  }
-  const middlewareLayer = Layer
-    .effect(
-      MiddlewareMaker,
-      middleware.execute
-        ? middleware.execute
-        : middleware.executeContextual!(makeRpcHandler<RequestContextMap, MiddlewareR>())
-    )
-    .pipe(middleware.dependencies ? Layer.provide(middleware.dependencies) as any : (_) => _)
+>
 
-  return middlewareLayer as Layer.Layer<
-    "MiddlewareMaker",
-    never,
-    Exclude<MiddlewareR, LayersUtils.GetLayersSuccess<MiddlewareDependencies>>
-  >
+function makeRpcHandler<RequestContextMap extends Record<string, RPCContextMap.Any>, MiddlewareR>() {
+  return (cb: MakeRPCHandlerFactory<RequestContextMap, MiddlewareR>) => cb
 }
-export type ContextProviderShape<ContextProviderA> = Effect<Context.Context<ContextProviderA>, never, Scope>
 
-export interface Middleware<
+export type ContextProviderShape<ContextProviderA> = Effect<
+  Context.Context<ContextProviderA>,
+  never,
+  HttpRouter.HttpRouter.Provided
+>
+
+export interface MiddlewareMake<
   MiddlewareR, // what the middlware requires to execute
   RequestContextMap extends Record<string, RPCContextMap.Any>, // what services will the middlware provide dynamically to the handler, or raise errors.
+  MakeMiddlewareE, // what the middleware construction can fail with
   MakeMiddlewareR, // what the middlware requires to be constructed
   MiddlewareDependencies extends NonEmptyArray<Layer.Layer.Any>, // layers provided for the middlware to be constructed
   //
   // ContextProvider is a service that builds additional context for each request.
-  ContextProviderId, // it is the context provider itself
-  ContextProviderKey extends string, // tag for the context provider
   ContextProviderA, // what the context provider provides
   MakeContextProviderE, // what the context provider construction can fail with
   MakeContextProviderR // what the context provider construction requires
@@ -101,36 +102,221 @@ export interface Middleware<
   contextProvider:
     & Context.Tag<
       ContextProviderId,
-      ContextProviderId & ContextProviderShape<ContextProviderA> & { _tag: ContextProviderKey }
+      ContextProviderShape<ContextProviderA>
     >
     & {
       Default: Layer.Layer<ContextProviderId, MakeContextProviderE, MakeContextProviderR>
     }
-  execute?: Effect<
-    RPCHandlerFactory<RequestContextMap, MiddlewareR>,
-    never,
+  execute: (
+    maker: (
+      cb: MakeRPCHandlerFactory<RequestContextMap, MiddlewareR>
+    ) => MakeRPCHandlerFactory<RequestContextMap, MiddlewareR>
+  ) => Effect<
+    MakeRPCHandlerFactory<RequestContextMap, MiddlewareR>,
+    MakeMiddlewareE,
     MakeMiddlewareR
   >
-  // better DX because types are contextually provided
-  executeContextual?: (
-    maker: (cb: RPCHandlerFactory<RequestContextMap, MiddlewareR>) => RPCHandlerFactory<RequestContextMap, MiddlewareR>
-  ) => Effect<
-    RPCHandlerFactory<RequestContextMap, MiddlewareR>,
+}
+
+export interface MiddlewareMakerId {
+  _tag: "MiddlewareMaker"
+}
+
+export interface ContextProviderId {
+  _tag: "ContextProvider"
+}
+
+type GetContext<T> = T extends Context.Context<infer Y> ? Y : never
+
+export const mergeContextProviders = <
+  // TDeps is an array of services whit Default implementation
+  // each service is an effect which builds some context for each request
+  TDeps extends Array.NonEmptyReadonlyArray<
+    & (
+      | Context.Tag<any, Effect<Context.Context<any>, never, any> & { _tag: any }>
+      | Context.Tag<any, Effect<Context.Context<any>, never, never> & { _tag: any }>
+    )
+    & {
+      new(...args: any[]): any
+      Default: Layer.Layer<Effect<Context.Context<any>> & { _tag: any }, any, any>
+    }
+  >
+>(...deps: TDeps): {
+  dependencies: { [K in keyof TDeps]: TDeps[K]["Default"] }
+  effect: Effect.Effect<
+    Effect.Effect<
+      Context.Context<GetContext<Effect.Success<InstanceType<TDeps[number]>>>>,
+      Effect.Error<InstanceType<TDeps[number]>>,
+      Effect.Context<InstanceType<TDeps[number]>>
+    >,
     never,
-    MakeMiddlewareR
+    InstanceType<TDeps[number]>
   >
+} => ({
+  dependencies: deps.map((_) => _.Default) as any,
+  effect: Effect.gen(function*() {
+    const services = yield* Effect.all(deps)
+    // services are effects which return some Context.Context<...>
+    return Effect.all(services as any[]).pipe(
+      Effect.map((_) => Context.mergeAll(..._ as any))
+    )
+  }) as any
+})
+
+// TODO: andrea; how?
+// export const MergedContextProvider = <
+//   // TDeps is an array of services whit Default implementation
+//   // each service is an effect which builds some context for each request
+//   TDeps extends Array.NonEmptyReadonlyArray<
+//     & (
+//       | Context.Tag<any, Effect<Context.Context<any>, never, any> & { _tag: any }>
+//       | Context.Tag<any, Effect<Context.Context<any>, never, never> & { _tag: any }>
+//     )
+//     & {
+//       new(...args: any[]): any
+//       Default: Layer.Layer<Effect<Context.Context<any>> & { _tag: any }, any, any>
+//     }
+//   >
+// >(...deps: TDeps) => ContextProvider(mergeContextProviders(...deps))
+
+export const ContextProvider = <A, E, R, EContext, Dependencies extends NonEmptyArray<Layer.Layer.Any>>(
+  input: { effect: Effect<Effect<A, EContext, HttpRouter.HttpRouter.Provided>, E, R>; dependencies?: Dependencies }
+) => {
+  const ctx = Context.GenericTag<
+    ContextProviderId,
+    Effect<A, EContext, HttpRouter.HttpRouter.Provided>
+  >(
+    "ContextProvider"
+  )
+  const l = Layer.effect(ctx, input.effect)
+  return Object.assign(ctx, {
+    Default: l.pipe(
+      input.dependencies ? Layer.provide(input.dependencies) as any : (_) => _
+    ) as Layer.Layer<
+      ContextProviderId,
+      E | LayersUtils.GetLayersError<Dependencies>,
+      Exclude<R, LayersUtils.GetLayersSuccess<Dependencies>> | LayersUtils.GetLayersContext<Dependencies>
+    >
+  })
 }
 
+export const EmptyContextProvider = ContextProvider({ effect: Effect.succeed(Effect.succeed(Context.empty())) })
+
+export type Middleware<
+  MiddlewareR, // what the middlware requires to execute
+  RequestContextMap extends Record<string, RPCContextMap.Any>, // what services will the middlware provide dynamically to the handler, or raise errors.
+  MakeMiddlewareE, // what the middleware construction can fail with
+  MakeMiddlewareR, // what the middlware requires to be constructed
+  ContextProviderA // what the context provider provides
+> =
+  & Context.Tag<
+    MiddlewareMakerId,
+    MiddlewareMakerId & {
+      effect: RPCHandlerFactory<RequestContextMap, MiddlewareR, ContextProviderA>
+    } & {
+      _tag: "MiddlewareMaker"
+    }
+  >
+  & {
+    Default: Layer.Layer<
+      MiddlewareMakerId,
+      MakeMiddlewareE,
+      MakeMiddlewareR
+    >
+  }
+
+export type RequestContextMapErrors<RequestContextMap extends Record<string, RPCContextMap.Any>> = S.Schema.Type<
+  RequestContextMap[keyof RequestContextMap]["error"]
+>
+
 // identity factory for Middleware
 export const makeMiddleware =
-  // by setting MiddlewareR and RequestContextMap beforehand, executeContextual contextual typing does not fuck up itself to anys
+  // by setting MiddlewareR and RequestContextMap beforehand, execute contextual typing does not fuck up itself to anys
   <RequestContextMap extends Record<string, RPCContextMap.Any>, MiddlewareR>() =>
-  <M extends Middleware<MiddlewareR, RequestContextMap, any, NonEmptyArray<Layer.Layer.Any>, any, any, any, any, any>>(
-    content: M
-  ): M => content
+  <
+    MakeMiddlewareE, // what the middleware construction can fail with
+    MakeMiddlewareR, // what the middlware requires to be constructed
+    MiddlewareDependencies extends NonEmptyArray<Layer.Layer.Any>, // layers provided for the middlware to be constructed
+    //
+    // ContextProvider is a service that builds additional context for each request.
+    ContextProviderA, // what the context provider provides
+    MakeContextProviderE, // what the context provider construction can fail with
+    MakeContextProviderR // what the context provider construction requires
+  >(
+    make: MiddlewareMake<
+      MiddlewareR,
+      RequestContextMap,
+      MakeMiddlewareE,
+      MakeMiddlewareR,
+      MiddlewareDependencies,
+      ContextProviderA,
+      MakeContextProviderE,
+      MakeContextProviderR
+    >
+  ) => {
+    // type Id = MiddlewareMakerId &
+    const MiddlewareMaker = Context.GenericTag<
+      MiddlewareMakerId,
+      {
+        effect: RPCHandlerFactory<RequestContextMap, MiddlewareR, ContextProviderA>
+        _tag: "MiddlewareMaker"
+      }
+    >(
+      "MiddlewareMaker"
+    )
+
+    const l = Layer.effect(
+      MiddlewareMaker,
+      Effect
+        .all({
+          middleware: make.execute(makeRpcHandler<RequestContextMap, MiddlewareR>()),
+          contextProvider: make.contextProvider // uses the middleware.contextProvider tag to get the context provider service
+        })
+        .pipe(
+          Effect.map(({ contextProvider, middleware }) => ({
+            _tag: "MiddlewareMaker" as const,
+            effect: makeRpcEffect<RequestContextMap, MiddlewareR, ContextProviderA>()(
+              (schema, handler, moduleName) => {
+                const h = middleware(schema, handler, moduleName)
+                return (req, headers) =>
+                  // the contextProvider is an Effect that builds the context for the request
+                  contextProvider.pipe(
+                    Effect.flatMap((ctx) =>
+                      h(req, headers)
+                        .pipe(
+                          Effect.provide(ctx),
+                          // TODO: make this depend on query/command, and consider if middleware also should be affected or not.
+                          Effect.uninterruptible
+                        )
+                    )
+                  )
+              }
+            )
+          }))
+        )
+    )
+    const middlewareLayer = l
+      .pipe(
+        make.dependencies ? Layer.provide(make.dependencies) as any : (_) => _,
+        Layer.provide(make.contextProvider.Default)
+      ) as Layer.Layer<
+        MiddlewareMakerId,
+        | MakeMiddlewareE
+        | Layer.Error<typeof make.contextProvider.Default>,
+        | LayersUtils.GetLayersContext<MiddlewareDependencies>
+        | Exclude<MakeMiddlewareR, LayersUtils.GetLayersSuccess<MiddlewareDependencies>>
+        | Layer.Context<typeof make.contextProvider.Default>
+      >
+
+    return Object.assign(MiddlewareMaker, { Default: middlewareLayer })
+  }
 
 // it just provides the right types without cluttering the implementation with them
-function makeRpcEffect<RequestContextMap extends Record<string, RPCContextMap.Any>, MiddlewareR, ContextProviderA>() {
+function makeRpcEffect<
+  RequestContextMap extends Record<string, RPCContextMap.Any>,
+  MiddlewareR,
+  ContextProviderA
+>() {
   return (
     cb: <
       T extends {
@@ -154,9 +340,9 @@ function makeRpcEffect<RequestContextMap extends Record<string, RPCContextMap.An
       headers: any
     ) => Effect.Effect<
       Request.Request.Success<Req>,
-      Request.Request.Error<Req>,
-      | Scope.Scope // the context provider may require a Scope to run
-      | Exclude<MiddlewareR, ContextProviderA> // for sure ContextProviderA is provided, so it can be removed from the MiddlewareR
+      Request.Request.Error<Req> | RequestContextMapErrors<RequestContextMap>,
+      | HttpRouter.HttpRouter.Provided // the context provider may require HttpRouter.Provided to run
+      | Exclude<MiddlewareR, ContextProviderA> // for sure ContextProviderA is provided, so it can be removed from the MiddlewareR\
       | Exclude<
         Exclude<HandlerR, GetEffectContext<RequestContextMap, (T & S.Schema<Req, any, never>)["config"]>>,
         ContextProviderA
@@ -164,52 +350,3 @@ function makeRpcEffect<RequestContextMap extends Record<string, RPCContextMap.An
     >
   ) => cb
 }
-
-export const makeRpc = <
-  MiddlewareR,
-  RequestContextMap extends Record<string, RPCContextMap.Any>,
-  MakeMiddlewareR,
-  MiddlewareDependencies extends NonEmptyArray<Layer.Layer.Any>,
-  ContextProviderId,
-  ContextProviderKey extends string,
-  ContextProviderA,
-  MakeContextProviderE,
-  MakeContextProviderR
->(
-  middleware: Middleware<
-    MiddlewareR,
-    RequestContextMap,
-    MakeMiddlewareR,
-    MiddlewareDependencies,
-    ContextProviderId,
-    ContextProviderKey,
-    ContextProviderA,
-    MakeContextProviderE,
-    MakeContextProviderR
-  >
-) =>
-  Effect
-    .all({
-      middleware: MiddlewareMaker as Context.Tag<
-        "MiddlewareMaker",
-        RPCHandlerFactory<RequestContextMap, MiddlewareR>
-      >,
-      contextProvider: middleware.contextProvider // uses the middleware.contextProvider tag to get the context provider service
-    })
-    .pipe(Effect.map(({ contextProvider, middleware }) => ({
-      effect: makeRpcEffect<RequestContextMap, MiddlewareR, ContextProviderA>()((schema, handler, moduleName) => {
-        const h = middleware(schema, handler, moduleName)
-        return (req, headers) =>
-          // the contextProvider is an Effect that builds the context for the request
-          contextProvider.pipe(
-            Effect.flatMap((ctx) =>
-              h(req, headers)
-                .pipe(
-                  Effect.provide(ctx),
-                  // TODO: make this depend on query/command, and consider if middleware also should be affected or not.
-                  Effect.uninterruptible
-                )
-            )
-          )
-      })
-    })))