@effect/platform 0.58.20 → 0.58.22

package/src/HttpApp.ts

@@ -1,7 +1,6 @@
 /**
  * @since 1.0.0
  */
-import * as Cause from "effect/Cause"
 import * as Context from "effect/Context"
 import * as Effect from "effect/Effect"
 import * as Exit from "effect/Exit"
@@ -15,7 +14,6 @@ import * as Scope from "effect/Scope"
 import type { HttpMiddleware } from "./HttpMiddleware.js"
 import * as ServerError from "./HttpServerError.js"
 import * as ServerRequest from "./HttpServerRequest.js"
-import * as Respondable from "./HttpServerRespondable.js"
 import * as ServerResponse from "./HttpServerResponse.js"
 import * as internalMiddleware from "./internal/httpMiddleware.js"
 
@@ -37,49 +35,45 @@ export type Default<E = never, R = never> = HttpApp<ServerResponse.HttpServerRes
  * @since 1.0.0
  * @category combinators
  */
-export const toHandled = <E, R, _, RH>(
+export const toHandled = <E, R, _, EH, RH>(
   self: Default<E, R>,
   handleResponse: (
     request: ServerRequest.HttpServerRequest,
-    exit: Exit.Exit<ServerResponse.HttpServerResponse, E | ServerError.ResponseError>
-  ) => Effect.Effect<_, never, RH>,
+    response: ServerResponse.HttpServerResponse
+  ) => Effect.Effect<_, EH, RH>,
   middleware?: HttpMiddleware | undefined
-): Default<E | ServerError.ResponseError, Exclude<R | RH, Scope.Scope>> => {
+): Effect.Effect<void, never, Exclude<R | RH, Scope.Scope>> => {
   const responded = Effect.withFiberRuntime<
     ServerResponse.HttpServerResponse,
-    E | ServerError.ResponseError,
+    E | EH | ServerError.ResponseError,
     R | RH | ServerRequest.HttpServerRequest
   >((fiber) => {
     const request = Context.unsafeGet(fiber.getFiberRef(FiberRef.currentContext), ServerRequest.HttpServerRequest)
-    const preHandled = Effect.flatMap(self, (response) => {
+    const preprocessResponse = (response: ServerResponse.HttpServerResponse) => {
       const handler = fiber.getFiberRef(currentPreResponseHandlers)
       return handler._tag === "Some" ? handler.value(request, response) : Effect.succeed(response)
+    }
+    return Effect.matchCauseEffect(self, {
+      onFailure: (cause) =>
+        Effect.flatMap(ServerError.causeResponse(cause), ([response, cause]) =>
+          preprocessResponse(response).pipe(
+            Effect.flatMap((response) => handleResponse(request, response)),
+            Effect.zipRight(Effect.failCause(cause))
+          )),
+      onSuccess: (response) =>
+        Effect.tap(
+          preprocessResponse(response),
+          (response) => handleResponse(request, response)
+        )
     })
-    return Effect.flatMap(
-      Effect.exit(preHandled),
-      (exit) => {
-        if (exit._tag === "Failure") {
-          const cause = exit.cause
-          const thing = Cause.squash(exit.cause)
-          if (ServerResponse.isServerResponse(thing)) {
-            exit = Exit.succeed(thing)
-          } else {
-            return Effect.matchCauseEffect(Respondable.toResponseError(thing), {
-              onFailure: (_) => Effect.zipRight(handleResponse(request, exit), exit),
-              onSuccess: (response) =>
-                Effect.zipRight(
-                  handleResponse(request, Exit.succeed(response)),
-                  Effect.failCause(Cause.sequential(cause, Cause.die(response)))
-                )
-            })
-          }
-        }
-        return Effect.zipRight(handleResponse(request, exit), exit)
-      }
-    )
   })
   const withTracer = internalMiddleware.tracer(responded)
-  return Effect.uninterruptible(Effect.scoped(middleware === undefined ? withTracer : middleware(withTracer)))
+  return Effect.uninterruptible(
+    Effect.catchAllCause(
+      Effect.scoped(middleware === undefined ? withTracer : middleware(withTracer)),
+      (_) => Effect.void
+    )
+  )
 }
 
 /**
@@ -144,39 +138,31 @@ export const withPreResponseHandler = dual<
  */
 export const toWebHandlerRuntime = <R>(runtime: Runtime.Runtime<R>) => {
   const run = Runtime.runFork(runtime)
-  const resolveSymbol = Symbol()
-  const rejectSymbol = Symbol()
-  return <E>(self: Default<E, R | Scope.Scope>) => {
-    const handled = Effect.scoped(toHandled(self, (request, exit) => {
-      const webRequest = request.source as Request
-      if (Exit.isSuccess(exit)) {
-        ;(request as any)[resolveSymbol](ServerResponse.toWeb(exit.value, request.method === "HEAD"))
-      } else if (Cause.isInterruptedOnly(exit.cause)) {
-        ;(request as any)[resolveSymbol](new Response(null, { status: webRequest.signal.aborted ? 499 : 503 }))
-      } else {
-        ;(request as any)[rejectSymbol](Cause.pretty(exit.cause))
-      }
-      return Effect.void
-    }))
-    return (request: Request): Promise<Response> =>
-      new Promise((resolve, reject) => {
-        const req = ServerRequest.fromWeb(request)
-        ;(req as any)[resolveSymbol] = resolve
-        ;(req as any)[rejectSymbol] = reject
-        const fiber = run(Effect.provideService(handled, ServerRequest.HttpServerRequest, req))
-        request.signal.addEventListener("abort", () => {
-          fiber.unsafeInterruptAsFork(ServerError.clientAbortFiberId)
-        }, { once: true })
-      })
-  }
+  return <E>(self: Default<E, R | Scope.Scope>, middleware: HttpMiddleware | undefined) =>
+  (request: Request): Promise<Response> =>
+    new Promise((resolve) => {
+      const fiber = run(Effect.provideService(
+        toHandled(self, (request, response) => {
+          resolve(ServerResponse.toWeb(response, request.method === "HEAD"))
+          return Effect.void
+        }, middleware),
+        ServerRequest.HttpServerRequest,
+        ServerRequest.fromWeb(request)
+      ))
+      request.signal.addEventListener("abort", () => {
+        fiber.unsafeInterruptAsFork(ServerError.clientAbortFiberId)
+      }, { once: true })
+    })
 }
 
 /**
  * @since 1.0.0
  * @category conversions
  */
-export const toWebHandler: <E>(self: Default<E, Scope.Scope>) => (request: Request) => Promise<Response> =
-  toWebHandlerRuntime(Runtime.defaultRuntime)
+export const toWebHandler: <E>(
+  self: Default<E, Scope.Scope>,
+  middleware?: HttpMiddleware | undefined
+) => (request: Request) => Promise<Response> = toWebHandlerRuntime(Runtime.defaultRuntime)
 
 /**
  * @since 1.0.0
@@ -184,14 +170,15 @@ export const toWebHandler: <E>(self: Default<E, Scope.Scope>) => (request: Reque
  */
 export const toWebHandlerLayer = <E, R, RE>(
   self: Default<E, R | Scope.Scope>,
-  layer: Layer.Layer<R, RE>
+  layer: Layer.Layer<R, RE>,
+  middleware?: HttpMiddleware | undefined
 ): {
   readonly close: () => Promise<void>
   readonly handler: (request: Request) => Promise<Response>
 } => {
   const scope = Effect.runSync(Scope.make())
   const close = () => Effect.runPromise(Scope.close(scope, Exit.void))
-  const build = Effect.map(Layer.toRuntime(layer), (_) => toWebHandlerRuntime(_)(self))
+  const build = Effect.map(Layer.toRuntime(layer), (_) => toWebHandlerRuntime(_)(self, middleware))
   const runner = Effect.runPromise(Scope.extend(build, scope))
   const handler = (request: Request): Promise<Response> => runner.then((handler) => handler(request))
   return { close, handler } as const

package/src/HttpServerError.ts

@@ -2,6 +2,7 @@
  * @since 1.0.0
  */
 import type * as Cause from "effect/Cause"
+import type * as Effect from "effect/Effect"
 import type * as Exit from "effect/Exit"
 import type * as FiberId from "effect/FiberId"
 import type * as Option from "effect/Option"
@@ -120,14 +121,17 @@ export const clientAbortFiberId: FiberId.FiberId = internal.clientAbortFiberId
 /**
  * @since 1.0.0
  */
-export const isClientAbortCause: <E>(cause: Cause.Cause<E>) => boolean = internal.isClientAbortCause
+export const causeResponse: <E>(
+  cause: Cause.Cause<E>
+) => Effect.Effect<readonly [ServerResponse.HttpServerResponse, Cause.Cause<E>]> = internal.causeResponse
 
 /**
  * @since 1.0.0
  */
-export const causeStatusStripped: <E>(
+export const causeResponseStripped: <E>(
   cause: Cause.Cause<E>
-) => readonly [status: number, cause: Option.Option<Cause.Cause<E>>] = internal.causeStatusStripped
+) => readonly [response: ServerResponse.HttpServerResponse, cause: Option.Option<Cause.Cause<E>>] =
+  internal.causeResponseStripped
 
 /**
  * @since 1.0.0

package/src/HttpServerRespondable.ts

@@ -28,7 +28,6 @@ export interface Respondable {
 export const isRespondable = (u: unknown): u is Respondable => hasProperty(u, symbol)
 
 const badRequest = ServerResponse.empty({ status: 400 })
-const internalServerError = () => ServerResponse.empty({ status: 500 })
 
 /**
  * @since 1.0.0
@@ -45,22 +44,14 @@ export const toResponse = (self: Respondable): Effect.Effect<HttpServerResponse>
  * @since 1.0.0
  * @category accessors
  */
-export const toResponseOrElse = (
-  u: unknown,
-  orElse: () => Effect.Effect<HttpServerResponse, unknown>
-): Effect.Effect<HttpServerResponse, unknown> => {
-  if (isRespondable(u)) {
-    return u[symbol]()
+export const toResponseOrElse = (u: unknown, orElse: HttpServerResponse): Effect.Effect<HttpServerResponse> => {
+  if (ServerResponse.isServerResponse(u)) {
+    return Effect.succeed(u)
+  } else if (isRespondable(u)) {
+    return Effect.catchAllCause(u[symbol](), () => Effect.succeed(orElse))
     // add support for some commmon types
   } else if (ParseResult.isParseError(u)) {
     return Effect.succeed(badRequest)
   }
-  return orElse()
+  return Effect.succeed(orElse)
 }
-
-/**
- * @since 1.0.0
- * @category accessors
- */
-export const toResponseError = (u: unknown): Effect.Effect<HttpServerResponse, unknown> =>
-  toResponseOrElse(u, internalServerError)

package/src/internal/httpMiddleware.ts

@@ -83,12 +83,12 @@ export const logger = make((httpApp) => {
         if (fiber.getFiberRef(loggerDisabled)) {
           return exit
         } else if (exit._tag === "Failure") {
-          const [status, cause] = ServerError.causeStatusStripped(exit.cause)
+          const [response, cause] = ServerError.causeResponseStripped(exit.cause)
           return Effect.zipRight(
             Effect.annotateLogs(Effect.log(cause._tag === "Some" ? cause.value : "Sent HTTP Response"), {
               "http.method": request.method,
               "http.url": request.url,
-              "http.status": status
+              "http.status": response.status
             }),
             exit
           )

package/src/internal/httpServerError.ts

@@ -1,10 +1,12 @@
 import * as Cause from "effect/Cause"
+import * as Effect from "effect/Effect"
 import type * as Exit from "effect/Exit"
 import * as FiberId from "effect/FiberId"
 import { globalValue } from "effect/GlobalValue"
 import * as Option from "effect/Option"
 import * as Predicate from "effect/Predicate"
 import type * as Error from "../HttpServerError.js"
+import * as Respondable from "../HttpServerRespondable.js"
 import type { HttpServerResponse } from "../HttpServerResponse.js"
 import * as internalServerResponse from "./httpServerResponse.js"
 
@@ -23,44 +25,67 @@ export const clientAbortFiberId = globalValue(
 )
 
 /** @internal */
-export const isClientAbortCause = <E>(cause: Cause.Cause<E>): boolean =>
-  Cause.reduce(
+export const causeResponse = <E>(
+  cause: Cause.Cause<E>
+): Effect.Effect<readonly [HttpServerResponse, Cause.Cause<E>]> => {
+  const [effect, stripped] = Cause.reduce(
     cause,
-    false,
-    (_, cause) => cause._tag === "Interrupt" && cause.fiberId === clientAbortFiberId ? Option.some(true) : Option.none()
+    [Effect.succeed(internalServerError), Cause.empty as Cause.Cause<E>] as const,
+    (acc, cause) => {
+      switch (cause._tag) {
+        case "Empty": {
+          return Option.some(acc)
+        }
+        case "Fail": {
+          return Option.some([Respondable.toResponseOrElse(cause.error, internalServerError), cause] as const)
+        }
+        case "Die": {
+          return Option.some([Respondable.toResponseOrElse(cause.defect, internalServerError), cause] as const)
+        }
+        case "Interrupt": {
+          if (acc[1]._tag !== "Empty") {
+            return Option.none()
+          }
+          const response = cause.fiberId === clientAbortFiberId ? clientAbortError : serverAbortError
+          return Option.some([Effect.succeed(response), cause] as const)
+        }
+        default: {
+          return Option.none()
+        }
+      }
+    }
   )
+  return Effect.map(effect, (response) => {
+    if (Cause.isEmptyType(stripped)) {
+      return [response, Cause.die(response)] as const
+    }
+    return [response, Cause.sequential(stripped, Cause.die(response))] as const
+  })
+}
 
 /** @internal */
-export const causeStatusStripped = <E>(
+export const causeResponseStripped = <E>(
   cause: Cause.Cause<E>
-): readonly [status: number, cause: Option.Option<Cause.Cause<E>>] => {
-  if (Cause.isInterruptedOnly(cause)) {
-    return [isClientAbortCause(cause) ? 499 : 503, Option.some(cause)]
-  }
+): readonly [response: HttpServerResponse, cause: Option.Option<Cause.Cause<E>>] => {
   let response: HttpServerResponse | undefined
   const stripped = Cause.stripSomeDefects(cause, (defect) => {
     if (internalServerResponse.isServerResponse(defect)) {
       response = defect
-      return Option.some(Cause.die(defect))
+      return Option.some(Cause.empty)
     }
     return Option.none()
   })
-  return [response?.status ?? 500, stripped]
+  return [response ?? internalServerError, stripped]
 }
 
 const internalServerError = internalServerResponse.empty({ status: 500 })
+const clientAbortError = internalServerResponse.empty({ status: 499 })
+const serverAbortError = internalServerResponse.empty({ status: 503 })
 
 /** @internal */
 export const exitResponse = <E>(exit: Exit.Exit<HttpServerResponse, E>): HttpServerResponse => {
   if (exit._tag === "Success") {
     return exit.value
   }
-  return Cause.reduce(
-    exit.cause,
-    internalServerError,
-    (_, cause) =>
-      cause._tag === "Die" && internalServerResponse.isServerResponse(cause.defect)
-        ? Option.some(cause.defect)
-        : Option.none()
-  )
+  return causeResponseStripped(exit.cause)[0]
 }