Function causeResponse

packages/platform/src/internal/httpServerError.ts:28–75

(
  cause: Cause.Cause<E>
)

/** @internal */
export const causeResponse = <E>(
  cause: Cause.Cause<E>
): Effect.Effect<readonly [HttpServerResponse, Cause.Cause<E>]> => {
  let effect: Effect.Effect<HttpServerResponse> = Effect.succeed(internalServerError)
  let stripped: Cause.Cause<E> = Cause.empty as Cause.Cause<E>
  let isClientInterrupt = false
  let hasResponse = false

  Cause.reduce(cause, void 0 as void, (_, current) => {
    const withoutInterrupt = Cause.isInterruptType(stripped) ? Cause.empty : stripped
    switch (current._tag) {
      case "Fail": {
        effect = Respondable.toResponseOrElse(current.error, internalServerError)
        stripped = combineCauses(withoutInterrupt, current)
        break
      }
      case "Die": {
        const isResponse = internalServerResponse.isServerResponse(current.defect)
        effect = Respondable.toResponseOrElseDefect(current.defect, internalServerError)
        stripped = isResponse ? withoutInterrupt : combineCauses(withoutInterrupt, current)
        hasResponse = hasResponse || isResponse
        break
      }
      case "Interrupt": {
        isClientInterrupt = isClientInterrupt || current.fiberId === clientAbortFiberId
        if (Cause.isEmptyType(stripped) && !hasResponse) {
          stripped = current
        }
        break
      }
    }
    return Option.none()
  })

  const responseEffect = !hasResponse && Cause.isInterruptType(stripped)
    ? Effect.succeed(isClientInterrupt ? clientAbortError : serverAbortError)
    : effect
  const strippedCause: Cause.Cause<E> = !hasResponse && Cause.isInterruptType(stripped) && isClientInterrupt
    ? Cause.interrupt(clientAbortFiberId) as Cause.Cause<E>
    : stripped

  return Effect.map(responseEffect, (response) => {
    if (Cause.isEmptyType(strippedCause)) {
      return [response, Cause.empty] as const
    }
    return [response, Cause.sequential(strippedCause, Cause.die(response))] as const
  })
}

const combineCauses = <A = never, B = never>(left: Cause.Cause<A>, right: Cause.Cause<B>): Cause.Cause<A | B> => {
  if (Cause.isEmptyType(left)) {