@effect/platform 0.13.0 → 0.13.2

package/src/internal/http/middleware.ts

@@ -11,16 +11,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,13 +51,14 @@ 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 */

package/src/internal/http/router.ts

@@ -95,15 +95,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(_: any, __: any) {
+      return route
+    }
     if (route.method === "*") {
       router.all(route.path, fn)
     } else {
@@ -113,27 +110,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>
+      )
     }
   )
 }

package/src/internal/http/serverResponse.ts

@@ -19,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)
@@ -77,7 +90,7 @@ export const uint8Array = (
     options?.status ?? 200,
     options?.statusText,
     options?.headers ?? Headers.empty,
-    internalBody.uint8Array(body, options?.contentType)
+    internalBody.uint8Array(body, getContentType(options))
   )
 
 /** @internal */
@@ -86,7 +99,7 @@ export const text = (body: string, options?: ServerResponse.Options.WithContentT
     options?.status ?? 200,
     options?.statusText,
     options?.headers ?? Headers.empty,
-    internalBody.text(body, options?.contentType)
+    internalBody.text(body, getContentType(options))
   )
 
 /** @internal */
@@ -188,9 +201,20 @@ export const stream = (
     options?.status ?? 200,
     options?.statusText,
     options?.headers ?? Headers.empty,
-    internalBody.stream(body, options?.contentType, options?.contentLength)
+    internalBody.stream(body, getContentType(options), options?.contentLength)
   )
 
+/** @internal */
+export const getContentType = (options?: ServerResponse.Options): string | undefined => {
+  if (options?.contentType) {
+    return options.contentType
+  } else if (options?.headers) {
+    return options.headers["content-type"]
+  } else {
+    return
+  }
+}
+
 /** @internal */
 export const setHeader = dual<
   (key: string, value: string) => (self: ServerResponse.ServerResponse) => ServerResponse.ServerResponse,
@@ -235,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,