@effect/platform 0.13.1 → 0.13.2

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

@@ -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,