@effect/platform 0.87.6 → 0.87.8

package/src/HttpLayerRouter.ts

@@ -14,7 +14,7 @@ import * as Scope from "effect/Scope"
 import * as Tracer from "effect/Tracer"
 import type * as Types from "effect/Types"
 import * as FindMyWay from "find-my-way-ts"
-import * as HttpApi from "./HttpApi.js"
+import type * as HttpApi from "./HttpApi.js"
 import * as HttpApiBuilder from "./HttpApiBuilder.js"
 import type * as HttpApiGroup from "./HttpApiGroup.js"
 import type * as HttpMethod from "./HttpMethod.js"
@@ -73,6 +73,19 @@ export interface HttpRouter {
     | Type.From<"Error", Route.Error<Routes[number]>>
   >
 
+  readonly addGlobalMiddleware: <E, R>(
+    middleware:
+      & ((
+        effect: Effect.Effect<HttpServerResponse.HttpServerResponse, unhandled>
+      ) => Effect.Effect<HttpServerResponse.HttpServerResponse, E, R>)
+      & (unhandled extends E ? unknown : "You cannot handle any errors")
+  ) => Effect.Effect<
+    void,
+    never,
+    | Type.From<"GlobalRequires", Exclude<R, GlobalProvided>>
+    | Type.From<"GlobalError", Exclude<E, unhandled>>
+  >
+
   readonly asHttpEffect: () => Effect.Effect<
     HttpServerResponse.HttpServerResponse,
     unknown,
@@ -94,6 +107,7 @@ export const HttpRouter: Context.Tag<HttpRouter, HttpRouter> = Context.GenericTa
  */
 export const make = Effect.gen(function*() {
   const router = FindMyWay.make<Route<any, never>>(yield* RouterConfig)
+  const middleware = new Set<middleware.Fn>()
 
   const addAll = <const Routes extends ReadonlyArray<Route<any, any>>>(
     routes: Routes
@@ -128,8 +142,7 @@ export const make = Effect.gen(function*() {
     [TypeId]: TypeId,
     prefixed(this: HttpRouter, prefix: string) {
       return HttpRouter.of({
-        [TypeId]: TypeId,
-        asHttpEffect: this.asHttpEffect,
+        ...this,
         prefixed: (newPrefix: string) => this.prefixed(prefixPath(prefix, newPrefix)),
         addAll: (routes) => addAll(routes.map(prefixRoute(prefix))) as any,
         add: (method, path, handler, options) =>
@@ -148,8 +161,12 @@ export const make = Effect.gen(function*() {
     },
     addAll,
     add: (method, path, handler, options) => addAll([route(method, path, handler, options)]),
+    addGlobalMiddleware: (middleware_) =>
+      Effect.sync(() => {
+        middleware.add(middleware_ as any)
+      }),
     asHttpEffect() {
-      return Effect.withFiberRuntime((fiber) => {
+      let handler = Effect.withFiberRuntime<HttpServerResponse.HttpServerResponse, unknown>((fiber) => {
         const contextMap = new Map(fiber.currentContext.unsafeMap)
         const request = contextMap.get(HttpServerRequest.HttpServerRequest.key) as HttpServerRequest.HttpServerRequest
         let result = router.find(request.method, request.url)
@@ -185,6 +202,11 @@ export const make = Effect.gen(function*() {
           Context.unsafeMake(contextMap)
         )
       })
+      if (middleware.size === 0) return handler
+      for (const fn of Arr.reverse(middleware)) {
+        handler = fn(handler as any)
+      }
+      return handler
     }
   })
 })
@@ -246,7 +268,7 @@ export {
  * const MyRoute = Layer.scopedDiscard(Effect.gen(function*() {
  *   const router = yield* HttpLayerRouter.HttpRouter
  *
- *   // then use `router.add` to add a route
+ *   // then use `yield* router.add(...)` to add a route
  * }))
  * ```
  *
@@ -257,6 +279,68 @@ export const use = <A, E, R>(
   f: (router: HttpRouter) => Effect.Effect<A, E, R>
 ): Layer.Layer<never, E, HttpRouter | Exclude<R, Scope.Scope>> => Layer.scopedDiscard(Effect.flatMap(HttpRouter, f))
 
+/**
+ * Create a layer that adds a single route to the HTTP router.
+ *
+ * ```ts
+ * import * as HttpLayerRouter from "@effect/platform/HttpLayerRouter"
+ * import * as HttpServerResponse from "@effect/platform/HttpServerResponse"
+ *
+ * const Route = HttpLayerRouter.add("GET", "/hello", HttpServerResponse.text("Hello, World!"))
+ * ```
+ *
+ * @since 1.0.0
+ * @category HttpRouter
+ */
+export const add = <E, R>(
+  method: "*" | "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "OPTIONS",
+  path: PathInput,
+  handler:
+    | Effect.Effect<HttpServerResponse.HttpServerResponse, E, R>
+    | ((request: HttpServerRequest.HttpServerRequest) => Effect.Effect<HttpServerResponse.HttpServerResponse, E, R>),
+  options?: {
+    readonly uninterruptible?: boolean | undefined
+  }
+): Layer.Layer<never, never, HttpRouter | Type.From<"Requires", Exclude<R, Provided>> | Type.From<"Error", E>> =>
+  use((router) => router.add(method, path, handler, options))
+
+/**
+ * Create a layer that adds multiple routes to the HTTP router.
+ *
+ * ```ts
+ * import * as HttpLayerRouter from "@effect/platform/HttpLayerRouter"
+ * import * as HttpServerResponse from "@effect/platform/HttpServerResponse"
+ *
+ * const Routes = HttpLayerRouter.addAll([
+ *   HttpLayerRouter.route("GET", "/hello", HttpServerResponse.text("Hello, World!"))
+ * ])
+ * ```
+ *
+ * @since 1.0.0
+ * @category HttpRouter
+ */
+export const addAll = <Routes extends ReadonlyArray<Route<any, any>>, EX = never, RX = never>(
+  routes: Routes | Effect.Effect<Routes, EX, RX>,
+  options?: {
+    readonly prefix?: string | undefined
+  }
+): Layer.Layer<
+  never,
+  EX,
+  | HttpRouter
+  | Exclude<RX, Scope.Scope>
+  | Type.From<"Requires", Exclude<Route.Context<Routes[number]>, Provided>>
+  | Type.From<"Error", Route.Error<Routes[number]>>
+> =>
+  Layer.scopedDiscard(Effect.gen(function*() {
+    const toAdd = Effect.isEffect(routes) ? yield* routes : routes
+    let router = yield* HttpRouter
+    if (options?.prefix) {
+      router = router.prefixed(options.prefix)
+    }
+    yield* router.addAll(toAdd)
+  }))
+
 /**
  * @since 1.0.0
  * @category HttpRouter
@@ -272,8 +356,8 @@ export const toHttpEffect = <A, E, R>(
 ): Effect.Effect<
   Effect.Effect<
     HttpServerResponse.HttpServerResponse,
-    Type.Only<"Error", R> | HttpServerError.RouteNotFound,
-    Scope.Scope | HttpServerRequest.HttpServerRequest | Type.Only<"Requires", R>
+    Type.Only<"Error", R> | Type.Only<"GlobalRequires", R> | HttpServerError.RouteNotFound,
+    Scope.Scope | HttpServerRequest.HttpServerRequest | Type.Only<"Requires", R> | Type.Only<"GlobalRequires", R>
   >,
   Type.Without<E>,
   Exclude<Type.Without<R>, HttpRouter> | Scope.Scope
@@ -474,6 +558,16 @@ export type Provided =
   | HttpServerRequest.ParsedSearchParams
   | RouteContext
 
+/**
+ * Services provided to global middleware.
+ *
+ * @since 1.0.0
+ * @category Request types
+ */
+export type GlobalProvided =
+  | HttpServerRequest.HttpServerRequest
+  | Scope.Scope
+
 /**
  * @since 1.0.0
  * @category Middleware
@@ -516,7 +610,9 @@ export interface Middleware<
   readonly layer: [Config["requires"]] extends [never] ? Layer.Layer<
       Type.From<"Requires", Config["provides"]>,
       Config["layerError"],
-      Config["layerRequires"] | Type.From<"Requires", Config["requires"]>
+      | Config["layerRequires"]
+      | Type.From<"Requires", Config["requires"]>
+      | Type.From<"Error", Config["error"]>
     >
     : "Need to .combine(middleware) that satisfy the missing request dependencies"
 
@@ -542,6 +638,11 @@ export interface Middleware<
 /**
  * Create a middleware layer that can be used to modify requests and responses.
  *
+ * By default, the middleware only affects the routes that it is provided to.
+ *
+ * If you want to create a middleware that applies globally to all routes, pass
+ * the `global` option as `true`.
+ *
  * ```ts
  * import * as HttpLayerRouter from "@effect/platform/HttpLayerRouter"
  * import * as HttpMiddleware from "@effect/platform/HttpMiddleware"
@@ -607,15 +708,23 @@ export const middleware:
     if (arguments.length === 0) {
       return makeMiddleware as any
     }
-    return makeMiddleware(arguments[0])
+    return makeMiddleware(arguments[0], arguments[1]) as any
   }
 
-const makeMiddleware = (middleware: any) =>
-  new MiddlewareImpl(
-    Effect.isEffect(middleware) ?
-      Layer.scopedContext(Effect.map(middleware, (fn) => Context.unsafeMake(new Map([[fnContextKey, fn]])))) :
-      Layer.succeedContext(Context.unsafeMake(new Map([[fnContextKey, middleware]]))) as any
-  )
+const makeMiddleware = (middleware: any, options?: {
+  readonly global?: boolean | undefined
+}) =>
+  options?.global ?
+    Layer.scopedDiscard(Effect.gen(function*() {
+      const router = yield* HttpRouter
+      const fn = Effect.isEffect(middleware) ? yield* middleware : middleware
+      yield* router.addGlobalMiddleware(fn)
+    }))
+    : new MiddlewareImpl(
+      Effect.isEffect(middleware) ?
+        Layer.scopedContext(Effect.map(middleware, (fn) => Context.unsafeMake(new Map([[fnContextKey, fn]])))) :
+        Layer.succeedContext(Context.unsafeMake(new Map([[fnContextKey, middleware]]))) as any
+    )
 
 let middlewareId = 0
 const fnContextKey = "@effect/platform/HttpLayerRouter/MiddlewareFn"
@@ -711,7 +820,7 @@ export declare namespace middleware {
    * @category Middleware
    */
   export type Make<Provides = never, Handles = never> = {
-    <E, R, EX, RX>(
+    <E, R, EX, RX, const Global extends boolean = false>(
       middleware: Effect.Effect<
         (
           effect: Effect.Effect<
@@ -728,16 +837,30 @@ export declare namespace middleware {
           & (unhandled extends E ? unknown : "You must only handle the configured errors"),
         EX,
         RX
-      >
-    ): Middleware<{
-      provides: Provides
-      handles: Handles
-      error: Exclude<E, unhandled>
-      requires: Exclude<R, Provided>
-      layerError: EX
-      layerRequires: Exclude<RX, Scope.Scope>
-    }>
-    <E, R>(
+      >,
+      options?: {
+        readonly global?: Global | undefined
+      }
+    ): Global extends true ? Layer.Layer<
+        | Type.From<"Requires", Provides>
+        | Type.From<"Error", Handles>
+        | Type.From<"GlobalRequires", Provides>
+        | Type.From<"GlobalError", Handles>,
+        EX,
+        | HttpRouter
+        | Exclude<RX, Scope.Scope>
+        | Type.From<"GlobalRequires", Exclude<R, GlobalProvided>>
+        | Type.From<"GlobalError", Exclude<E, unhandled>>
+      > :
+      Middleware<{
+        provides: Provides
+        handles: Handles
+        error: Exclude<E, unhandled>
+        requires: Exclude<R, Provided>
+        layerError: EX
+        layerRequires: Exclude<RX, Scope.Scope>
+      }>
+    <E, R, const Global extends boolean = false>(
       middleware:
         & ((
           effect: Effect.Effect<
@@ -750,15 +873,28 @@ export declare namespace middleware {
           E,
           R
         >)
-        & (unhandled extends E ? unknown : "You must only handle the configured errors")
-    ): Middleware<{
-      provides: Provides
-      handles: Handles
-      error: Exclude<E, unhandled>
-      requires: Exclude<R, Provided>
-      layerError: never
-      layerRequires: never
-    }>
+        & (unhandled extends E ? unknown : "You must only handle the configured errors"),
+      options?: {
+        readonly global?: Global | undefined
+      }
+    ): Global extends true ? Layer.Layer<
+        | Type.From<"Requires", Provides>
+        | Type.From<"Error", Handles>
+        | Type.From<"GlobalRequires", Provides>
+        | Type.From<"GlobalError", Handles>,
+        never,
+        | HttpRouter
+        | Type.From<"GlobalRequires", Exclude<R, GlobalProvided>>
+        | Type.From<"GlobalError", Exclude<E, unhandled>>
+      > :
+      Middleware<{
+        provides: Provides
+        handles: Handles
+        error: Exclude<E, unhandled>
+        requires: Exclude<R, Provided>
+        layerError: never
+        layerRequires: never
+      }>
   }
 
   /**
@@ -785,7 +921,26 @@ export const cors = (
     readonly maxAge?: number | undefined
     readonly credentials?: boolean | undefined
   } | undefined
-): Layer.Layer<never> => middleware(HttpMiddleware.cors(options)).layer
+): Layer.Layer<never, never, HttpRouter> => middleware(HttpMiddleware.cors(options), { global: true })
+
+/**
+ * A middleware that disables the logger for some routes.
+ *
+ * ```ts
+ * import * as HttpLayerRouter from "@effect/platform/HttpLayerRouter"
+ * import * as HttpServerResponse from "@effect/platform/HttpServerResponse"
+ * import * as Layer from "effect/Layer"
+ *
+ * const Route = HttpLayerRouter.add("GET", "/hello", HttpServerResponse.text("Hello, World!")).pipe(
+ *   // disable the logger for this route
+ *   Layer.provide(HttpLayerRouter.disableLogger)
+ * )
+ * ```
+ *
+ * @since 1.0.0
+ * @category Middleware
+ */
+export const disableLogger: Layer.Layer<never> = middleware(HttpMiddleware.withLoggerDisabled).layer
 
 /**
  * ```ts
@@ -853,20 +1008,14 @@ export const addHttpApi = <Id extends string, Groups extends HttpApiGroup.HttpAp
     readonly openapiPath?: `/${string}` | undefined
   }
 ): Layer.Layer<
-  HttpApi.Api,
+  never,
   never,
   HttpRouter | HttpApiGroup.HttpApiGroup.ToService<Id, Groups> | R | HttpApiGroup.HttpApiGroup.ErrorContext<Groups>
 > => {
-  const ApiMiddleware = middleware(HttpApiBuilder.buildMiddleware(api)).layer
-
+  const ApiMiddleware = middleware(HttpApiBuilder.buildMiddleware(api)).layer as Layer.Layer<never>
   return HttpApiBuilder.Router.unwrap(Effect.fnUntraced(function*(router_) {
-    const contextMap = new Map<string, unknown>()
     const router = yield* HttpRouter
     const routes = Arr.empty<Route<any, any>>()
-    const context = yield* Effect.context<never>()
-
-    contextMap.set(HttpApi.Api.key, { api, context })
-
     for (const route of router_.routes) {
       routes.push(makeRoute(route as any))
     }
@@ -877,9 +1026,7 @@ export const addHttpApi = <Id extends string, Groups extends HttpApiGroup.HttpAp
       const spec = OpenApi.fromApi(api)
       yield* router.add("GET", options.openapiPath, Effect.succeed(HttpServerResponse.unsafeJson(spec)))
     }
-
-    return Context.unsafeMake<any>(contextMap)
-  }, Layer.effectContext)).pipe(
+  }, Layer.effectDiscard)).pipe(
     Layer.provide(ApiMiddleware)
   )
 }
@@ -890,7 +1037,7 @@ export const addHttpApi = <Id extends string, Groups extends HttpApiGroup.HttpAp
  * @since 1.0.0
  * @category Server
  */
-export const serve = <A, E, R, HE, HR = Type.Only<"Requires", R>>(
+export const serve = <A, E, R, HE, HR = Type.Only<"Requires", R> | Type.Only<"GlobalRequires", R>>(
   appLayer: Layer.Layer<A, E, R>,
   options?: {
     readonly routerConfig?: Partial<FindMyWay.RouterConfig> | undefined
@@ -910,8 +1057,8 @@ export const serve = <A, E, R, HE, HR = Type.Only<"Requires", R>>(
     readonly middleware?: (
       effect: Effect.Effect<
         HttpServerResponse.HttpServerResponse,
-        Type.Only<"Error", R> | HttpServerError.RouteNotFound,
-        Scope.Scope | HttpServerRequest.HttpServerRequest | Type.Only<"Requires", R>
+        Type.Only<"Error", R> | Type.Only<"GlobalError", R> | HttpServerError.RouteNotFound,
+        Scope.Scope | HttpServerRequest.HttpServerRequest | Type.Only<"Requires", R> | Type.Only<"GlobalRequires", R>
       >
     ) => Effect.Effect<HttpServerResponse.HttpServerResponse, HE, HR>
   }
@@ -933,8 +1080,8 @@ export const serve = <A, E, R, HE, HR = Type.Only<"Requires", R>>(
     return middleware ? HttpServer.serve(handler, middleware) : HttpServer.serve(handler)
   }).pipe(
     Layer.unwrapScoped,
-    options?.disableListenLog ? identity : HttpServer.withLogAddress,
     Layer.provide(appLayer),
-    Layer.provide(RouterLayer)
+    Layer.provide(RouterLayer),
+    options?.disableListenLog ? identity : HttpServer.withLogAddress
   ) as any
 }

package/src/UrlParams.ts

@@ -325,7 +325,7 @@ const baseUrl = (): string | undefined => {
  * @category conversions
  */
 export const toRecord = (self: UrlParams): Record<string, string | Arr.NonEmptyArray<string>> => {
-  const out: Record<string, string | Arr.NonEmptyArray<string>> = {}
+  const out: Record<string, string | Arr.NonEmptyArray<string>> = Object.create(null)
   for (const [k, value] of self) {
     const curr = out[k]
     if (curr === undefined) {
@@ -336,7 +336,7 @@ export const toRecord = (self: UrlParams): Record<string, string | Arr.NonEmptyA
       curr.push(value)
     }
   }
-  return out
+  return { ...out }
 }
 
 /**