@effect/platform 0.13.1 → 0.13.3

package/src/internal/http/middleware.ts

@@ -1,6 +1,5 @@
-import { dual } from "@effect/data/Function"
+import { flow } from "@effect/data/Function"
 import * as Effect from "@effect/io/Effect"
-import type * as App from "@effect/platform/Http/App"
 import * as Headers from "@effect/platform/Http/Headers"
 import type * as Middleware from "@effect/platform/Http/Middleware"
 import * as ServerRequest from "@effect/platform/Http/ServerRequest"
@@ -11,16 +10,21 @@ export const make = <M extends Middleware.Middleware>(middleware: M): M => middl
 /** @internal */
 export const logger = make((httpApp) =>
   Effect.withLogSpan(
-    Effect.onExit(
-      httpApp,
-      (exit) =>
-        Effect.flatMap(
-          ServerRequest.ServerRequest,
-          (request) =>
-            Effect.annotateLogs(Effect.log("", exit._tag === "Failure" ? exit.cause : undefined), {
+    Effect.flatMap(
+      ServerRequest.ServerRequest,
+      (request) =>
+        Effect.tap(
+          Effect.tapErrorCause(httpApp, (cause) =>
+            Effect.annotateLogs(Effect.log(cause), {
+              "http.method": request.method,
+              "http.url": request.url,
+              "http.status": 500
+            })),
+          (response) =>
+            Effect.annotateLogs(Effect.log(""), {
               "http.method": request.method,
               "http.url": request.url,
-              "http.status": exit._tag === "Success" ? exit.value.status : 500
+              "http.status": response.status
             })
         )
     ),
@@ -46,27 +50,15 @@ export const tracer = make((httpApp) =>
 
 /** @internal */
 export const xForwardedHeaders = make((httpApp) =>
-  Effect.flatMap(ServerRequest.ServerRequest, (request) => {
-    const forwardedHost = Headers.get(request.headers, "x-forwarded-host")
-    return forwardedHost._tag === "Some"
-      ? Effect.updateService(httpApp, ServerRequest.ServerRequest, (_) =>
-        _.replaceHeaders(Headers.set(request.headers, "host", forwardedHost.value)))
-      : httpApp
-  })
+  Effect.updateService(httpApp, ServerRequest.ServerRequest, (request) =>
+    request.headers["x-forwarded-host"]
+      ? request.replaceHeaders(Headers.set(
+        request.headers,
+        "host",
+        request.headers["x-forwarded-host"]
+      ))
+      : request)
 )
 
 /** @internal */
-export const compose = dual<
-  <B extends App.Default<any, any>, C extends App.Default<any, any>>(
-    that: (b: B) => C
-  ) => <A extends App.Default<any, any>>(
-    self: (a: A) => B
-  ) => (a: A) => C,
-  <A extends App.Default<any, any>, B extends App.Default<any, any>, C extends App.Default<any, any>>(
-    self: (a: A) => B,
-    that: (b: B) => C
-  ) => (a: A) => C
->(2, (self, that) => (inApp) => that(self(inApp)))
-
-/** @internal */
-export const loggerTracer = compose(tracer, logger)
+export const loggerTracer = flow(tracer, logger)

package/src/internal/http/router.ts

@@ -5,6 +5,7 @@ import { dual } from "@effect/data/Function"
 import * as Hash from "@effect/data/Hash"
 import * as Option from "@effect/data/Option"
 import { pipeArguments } from "@effect/data/Pipeable"
+import type * as Cause from "@effect/io/Cause"
 import * as Effect from "@effect/io/Effect"
 import type * as App from "@effect/platform/Http/App"
 import type * as Method from "@effect/platform/Http/Method"
@@ -95,15 +96,12 @@ const toHttpApp = <R, E>(
   self: Router.Router<R, E>
 ): App.Default<Exclude<R, Router.RouteContext>, E | Error.RouteNotFound> => {
   const router = FindMyWay()
-  Chunk.forEach(self.mounts, ([path, app]) => {
-    const fn = () => {}
-    fn.handler = Effect.updateService(app, ServerRequest.ServerRequest, (request) => sliceRequestUrl(request, path))
-    router.all(path, fn)
-    router.all(path + "/*", fn)
-  })
+  const mounts = Chunk.toReadonlyArray(self.mounts)
+  const mountsLen = mounts.length
   Chunk.forEach(self.routes, (route) => {
-    const fn = () => {}
-    fn.handler = route
+    function fn() {
+      return route
+    }
     if (route.method === "*") {
       router.all(route.path, fn)
     } else {
@@ -113,27 +111,36 @@ const toHttpApp = <R, E>(
   return Effect.flatMap(
     ServerRequest.ServerRequest,
     (request): App.Default<Exclude<R, Router.RouteContext>, E | Error.RouteNotFound> => {
+      if (mountsLen > 0) {
+        for (let i = 0; i < mountsLen; i++) {
+          const [path, app] = mounts[i]
+          if (request.url.startsWith(path)) {
+            return Effect.provideService(
+              app,
+              ServerRequest.ServerRequest,
+              sliceRequestUrl(request, path)
+            ) as App.Default<Exclude<R, Router.RouteContext>, E>
+          }
+        }
+      }
+
       const result = router.find(request.method as HTTPMethod, request.url)
       if (result === null) {
         return Effect.fail(Error.RouteNotFound({ request }))
       }
-      const handler = (result.handler as any).handler
-      if (RouteTypeId in handler) {
-        const route = handler as Router.Route<R, E>
-        if (route.prefix._tag === "Some") {
-          request = sliceRequestUrl(request, route.prefix.value)
-        }
-        return Effect.mapInputContext(
-          route.handler,
-          (context) =>
-            Context.add(
-              Context.add(context, ServerRequest.ServerRequest, request),
-              RouteContext,
-              new RouteContextImpl(result.params, result.searchParams)
-            ) as Context.Context<R>
-        )
+      const route = (result.handler as any)() as Router.Route<R, E>
+      if (route.prefix._tag === "Some") {
+        request = sliceRequestUrl(request, route.prefix.value)
       }
-      return (handler as App.Default<Exclude<R, Router.RouteContext>, E>)
+      return Effect.mapInputContext(
+        route.handler,
+        (context) =>
+          Context.add(
+            Context.add(context, ServerRequest.ServerRequest, request),
+            RouteContext,
+            new RouteContextImpl(result.params, result.searchParams)
+          ) as Context.Context<R>
+      )
     }
   )
 }
@@ -296,3 +303,130 @@ export const head = route("HEAD")
 
 /** @internal */
 export const options = route("OPTIONS")
+
+/** @internal */
+export const transform = dual<
+  <R, E, R1, E1>(
+    f: (self: Router.Route.Handler<R, E>) => Router.Route.Handler<R1, E1>
+  ) => (self: Router.Router<R, E>) => Router.Router<R1, E1>,
+  <R, E, R1, E1>(
+    self: Router.Router<R, E>,
+    f: (self: Router.Route.Handler<R, E>) => Router.Route.Handler<R1, E1>
+  ) => Router.Router<R1, E1>
+>(2, (self, f) =>
+  new RouterImpl(
+    Chunk.map(
+      self.routes,
+      (route) => new RouteImpl(route.method, route.path, f(route.handler), route.prefix)
+    ),
+    Chunk.map(
+      self.mounts,
+      ([path, app]) => [path, f(app as any)]
+    )
+  ))
+
+/** @internal */
+export const catchAll = dual<
+  <E, R2, E2>(
+    f: (e: E) => Router.Route.Handler<R2, E2>
+  ) => <R>(self: Router.Router<R, E>) => Router.Router<R2 | R, E2>,
+  <R, E, R2, E2>(
+    self: Router.Router<R, E>,
+    f: (e: E) => Router.Route.Handler<R2, E2>
+  ) => Router.Router<R2 | R, E2>
+>(2, (self, f) => transform(self, Effect.catchAll(f)))
+
+/** @internal */
+export const catchAllCause = dual<
+  <E, R2, E2>(
+    f: (e: Cause.Cause<E>) => Router.Route.Handler<R2, E2>
+  ) => <R>(self: Router.Router<R, E>) => Router.Router<R2 | R, E2>,
+  <R, E, R2, E2>(
+    self: Router.Router<R, E>,
+    f: (e: Cause.Cause<E>) => Router.Route.Handler<R2, E2>
+  ) => Router.Router<R2 | R, E2>
+>(2, (self, f) => transform(self, Effect.catchAllCause(f)))
+
+/** @internal */
+export const catchTag = dual<
+  <K extends (E extends { _tag: string } ? E["_tag"] : never), E, R1, E1>(
+    k: K,
+    f: (e: Extract<E, { _tag: K }>) => Router.Route.Handler<R1, E1>
+  ) => <R>(self: Router.Router<R, E>) => Router.Router<R | R1, Exclude<E, { _tag: K }> | E1>,
+  <R, E, K extends (E extends { _tag: string } ? E["_tag"] : never), R1, E1>(
+    self: Router.Router<R, E>,
+    k: K,
+    f: (e: Extract<E, { _tag: K }>) => Router.Route.Handler<R1, E1>
+  ) => Router.Router<R | R1, Exclude<E, { _tag: K }> | E1>
+>(3, (self, k, f) => transform(self, Effect.catchTag(k, f)))
+
+/** @internal */
+export const catchTags: {
+  <
+    E,
+    Cases extends (E extends { _tag: string } ? {
+        [K in E["_tag"]]+?: (error: Extract<E, { _tag: K }>) => Router.Route.Handler<any, any>
+      } :
+      {})
+  >(
+    cases: Cases
+  ): <R>(self: Router.Router<R, E>) => Router.Router<
+    | R
+    | {
+      [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Effect.Effect<infer R, any, any>) ? R : never
+    }[keyof Cases],
+    | Exclude<E, { _tag: keyof Cases }>
+    | {
+      [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Effect.Effect<any, infer E, any>) ? E : never
+    }[keyof Cases]
+  >
+  <
+    R,
+    E,
+    Cases extends (E extends { _tag: string } ? {
+        [K in E["_tag"]]+?: (error: Extract<E, { _tag: K }>) => Router.Route.Handler<any, any>
+      } :
+      {})
+  >(
+    self: Router.Router<R, E>,
+    cases: Cases
+  ): Router.Router<
+    | R
+    | {
+      [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Effect.Effect<infer R, any, any>) ? R : never
+    }[keyof Cases],
+    | Exclude<E, { _tag: keyof Cases }>
+    | {
+      [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Effect.Effect<any, infer E, any>) ? E : never
+    }[keyof Cases]
+  >
+} = dual(2, (self: Router.Router<any, any>, cases: {}) => transform(self, Effect.catchTags(cases)))
+
+export const provideService = dual<
+  <T extends Context.Tag<any, any>>(
+    tag: T,
+    service: Context.Tag.Service<T>
+  ) => <R, E>(self: Router.Router<R, E>) => Router.Router<Exclude<R, Context.Tag.Identifier<T>>, E>,
+  <R, E, T extends Context.Tag<any, any>>(
+    self: Router.Router<R, E>,
+    tag: T,
+    service: Context.Tag.Service<T>
+  ) => Router.Router<Exclude<R, Context.Tag.Identifier<T>>, E>
+>(3, (self, tag, service) => transform(self, Effect.provideService(tag, service)))
+
+/* @internal */
+export const provideServiceEffect = dual<
+  <T extends Context.Tag<any, any>, R1, E1>(
+    tag: T,
+    effect: Effect.Effect<R1, E1, Context.Tag.Service<T>>
+  ) => <R, E>(self: Router.Router<R, E>) => Router.Router<R1 | Exclude<R, Context.Tag.Identifier<T>>, E | E1>,
+  <R, E, T extends Context.Tag<any, any>, R1, E1>(
+    self: Router.Router<R, E>,
+    tag: T,
+    effect: Effect.Effect<R1, E1, Context.Tag.Service<T>>
+  ) => Router.Router<R1 | Exclude<R, Context.Tag.Identifier<T>>, E | E1>
+>(3, <R, E, T extends Context.Tag<any, any>, R1, E1>(
+  self: Router.Router<R, E>,
+  tag: T,
+  effect: Effect.Effect<R1, E1, Context.Tag.Service<T>>
+) => transform(self, Effect.provideServiceEffect(tag, effect)))

package/src/internal/http/serverResponse.ts

@@ -1,5 +1,4 @@
 import { dual } from "@effect/data/Function"
-import * as Option from "@effect/data/Option"
 import { pipeArguments } from "@effect/data/Pipeable"
 import * as Effect from "@effect/io/Effect"
 import type * as PlatformError from "@effect/platform/Error"
@@ -20,13 +19,26 @@ export const TypeId: ServerResponse.TypeId = Symbol.for("@effect/platform/Http/S
 
 class ServerResponseImpl implements ServerResponse.ServerResponse {
   readonly [TypeId]: ServerResponse.TypeId
+  readonly headers: Headers.Headers
   constructor(
     readonly status: number,
     readonly statusText: string | undefined,
-    readonly headers: Headers.Headers,
+    headers: Headers.Headers,
     readonly body: Body.Body
   ) {
     this[TypeId] = TypeId
+    if (body.contentType || body.contentLength) {
+      const newHeaders = { ...headers }
+      if (body.contentType) {
+        newHeaders["content-type"] = body.contentType
+      }
+      if (body.contentLength) {
+        newHeaders["content-length"] = body.contentLength.toString()
+      }
+      this.headers = newHeaders
+    } else {
+      this.headers = headers
+    }
   }
   pipe() {
     return pipeArguments(this, arguments)
@@ -197,7 +209,7 @@ export const getContentType = (options?: ServerResponse.Options): string | undef
   if (options?.contentType) {
     return options.contentType
   } else if (options?.headers) {
-    return Option.getOrUndefined(Headers.get("content-type")(options.headers))
+    return options.headers["content-type"]
   } else {
     return
   }
@@ -247,16 +259,6 @@ export const setBody = dual<
   let headers = self.headers
   if (body._tag === "Empty") {
     headers = Headers.remove(Headers.remove(headers, "Content-Type"), "Content-length")
-  } else {
-    const contentType = body.contentType
-    if (contentType) {
-      headers = Headers.set(headers, "content-type", contentType)
-    }
-
-    const contentLength = body.contentLength
-    if (contentLength) {
-      headers = Headers.set(headers, "content-length", contentLength.toString())
-    }
   }
   return new ServerResponseImpl(
     self.status,