@effect/platform 0.58.9 → 0.58.11

package/src/HttpServerError.ts

@@ -2,10 +2,13 @@
  * @since 1.0.0
  */
 import type * as Cause from "effect/Cause"
+import type * as Exit from "effect/Exit"
 import type * as FiberId from "effect/FiberId"
+import type * as Option from "effect/Option"
 import { RefailError, TypeIdError } from "./Error.js"
 import type * as ServerRequest from "./HttpServerRequest.js"
-import type * as ServerResponse from "./HttpServerResponse.js"
+import * as Respondable from "./HttpServerRespondable.js"
+import * as ServerResponse from "./HttpServerResponse.js"
 import * as internal from "./internal/httpServerError.js"
 
 /**
@@ -33,7 +36,14 @@ export type HttpServerError = RequestError | ResponseError | RouteNotFound | Ser
 export class RequestError extends RefailError(TypeId, "RequestError")<{
   readonly request: ServerRequest.HttpServerRequest
   readonly reason: "Transport" | "Decode"
-}> {
+}> implements Respondable.Respondable {
+  /**
+   * @since 1.0.0
+   */
+  [Respondable.symbol]() {
+    return ServerResponse.empty({ status: 400 })
+  }
+
   get methodAndUrl() {
     return `${this.request.method} ${this.request.url}`
   }
@@ -56,6 +66,13 @@ export const isServerError: (u: unknown) => u is HttpServerError = internal.isSe
 export class RouteNotFound extends TypeIdError(TypeId, "RouteNotFound")<{
   readonly request: ServerRequest.HttpServerRequest
 }> {
+  /**
+   * @since 1.0.0
+   */
+  [Respondable.symbol]() {
+    return ServerResponse.empty({ status: 404 })
+  }
+
   get message() {
     return `${this.request.method} ${this.request.url} not found`
   }
@@ -70,6 +87,13 @@ export class ResponseError extends RefailError(TypeId, "ResponseError")<{
   readonly response: ServerResponse.HttpServerResponse
   readonly reason: "Decode"
 }> {
+  /**
+   * @since 1.0.0
+   */
+  [Respondable.symbol]() {
+    return ServerResponse.empty({ status: 500 })
+  }
+
   get methodAndUrl() {
     return `${this.request.method} ${this.request.url}`
   }
@@ -83,8 +107,7 @@ export class ResponseError extends RefailError(TypeId, "ResponseError")<{
  * @since 1.0.0
  * @category error
  */
-export class ServeError extends RefailError(TypeId, "ServeError")<{}> {
-}
+export class ServeError extends RefailError(TypeId, "ServeError")<{}> {}
 
 /**
  * @since 1.0.0
@@ -99,4 +122,13 @@ export const isClientAbortCause: <E>(cause: Cause.Cause<E>) => boolean = interna
 /**
  * @since 1.0.0
  */
-export const causeStatusCode: <E>(cause: Cause.Cause<E>) => number = internal.causeStatusCode
+export const causeStatusStripped: <E>(
+  cause: Cause.Cause<E>
+) => readonly [status: number, cause: Option.Option<Cause.Cause<E>>] = internal.causeStatusStripped
+
+/**
+ * @since 1.0.0
+ */
+export const exitResponse: <E>(
+  exit: Exit.Exit<ServerResponse.HttpServerResponse, E>
+) => ServerResponse.HttpServerResponse = internal.exitResponse

package/src/HttpServerRequest.ts

@@ -8,6 +8,7 @@ import type { Channel } from "effect/Channel"
 import type { Chunk } from "effect/Chunk"
 import type * as Context from "effect/Context"
 import type * as Effect from "effect/Effect"
+import type { Option } from "effect/Option"
 import type { ReadonlyRecord } from "effect/Record"
 import type * as Scope from "effect/Scope"
 import type * as Stream from "effect/Stream"
@@ -220,3 +221,9 @@ export const schemaBodyFormJson: <A, I, R>(
  * @category conversions
  */
 export const fromWeb: (request: Request) => HttpServerRequest = internal.fromWeb
+
+/**
+ * @since 1.0.0
+ * @category conversions
+ */
+export const toURL: (self: HttpServerRequest) => Option<URL> = internal.toURL

package/src/HttpServerRespondable.ts

@@ -0,0 +1,66 @@
+/**
+ * @since 1.0.0
+ */
+import * as ParseResult from "@effect/schema/ParseResult"
+import * as Effect from "effect/Effect"
+import { hasProperty } from "effect/Predicate"
+import type { HttpServerResponse } from "./HttpServerResponse.js"
+import * as ServerResponse from "./HttpServerResponse.js"
+
+/**
+ * @since 1.0.0
+ * @category symbols
+ */
+export const symbol: unique symbol = Symbol.for("@effect/platform/HttpServerRespondable")
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export interface Respondable {
+  readonly [symbol]: () => Effect.Effect<HttpServerResponse, unknown>
+}
+
+/**
+ * @since 1.0.0
+ * @category guards
+ */
+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
+ * @category accessors
+ */
+export const toResponse = (self: Respondable): Effect.Effect<HttpServerResponse> => {
+  if (ServerResponse.isServerResponse(self)) {
+    return Effect.succeed(self)
+  }
+  return Effect.orDie(self[symbol]())
+}
+
+/**
+ * @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]()
+    // add support for some commmon types
+  } else if (ParseResult.isParseError(u)) {
+    return Effect.succeed(badRequest)
+  }
+  return orElse()
+}
+
+/**
+ * @since 1.0.0
+ * @category accessors
+ */
+export const toResponseError = (u: unknown): Effect.Effect<HttpServerResponse, unknown> =>
+  toResponseOrElse(u, internalServerError)

package/src/HttpServerResponse.ts

@@ -12,6 +12,7 @@ import type * as FileSystem from "./FileSystem.js"
 import type * as Headers from "./Headers.js"
 import type * as Body from "./HttpBody.js"
 import type * as Platform from "./HttpPlatform.js"
+import type { Respondable } from "./HttpServerRespondable.js"
 import * as internal from "./internal/httpServerResponse.js"
 import type * as Template from "./Template.js"
 import type * as UrlParams from "./UrlParams.js"
@@ -32,7 +33,7 @@ export type TypeId = typeof TypeId
  * @since 1.0.0
  * @category models
  */
-export interface HttpServerResponse extends Effect.Effect<HttpServerResponse>, Inspectable {
+export interface HttpServerResponse extends Effect.Effect<HttpServerResponse>, Inspectable, Respondable {
   readonly [TypeId]: TypeId
   readonly status: number
   readonly statusText?: string | undefined

package/src/index.ts

@@ -114,6 +114,11 @@ export * as HttpServerError from "./HttpServerError.js"
  */
 export * as HttpServerRequest from "./HttpServerRequest.js"
 
+/**
+ * @since 1.0.0
+ */
+export * as HttpServerRespondable from "./HttpServerRespondable.js"
+
 /**
  * @since 1.0.0
  */

package/src/internal/httpClientResponse.ts

@@ -2,8 +2,10 @@ import type { ParseOptions } from "@effect/schema/AST"
 import type * as ParseResult from "@effect/schema/ParseResult"
 import * as Schema from "@effect/schema/Schema"
 import * as Effect from "effect/Effect"
+import { dual } from "effect/Function"
 import * as Inspectable from "effect/Inspectable"
 import * as Option from "effect/Option"
+import type { Scope } from "effect/Scope"
 import * as Stream from "effect/Stream"
 import * as Cookies from "../Cookies.js"
 import * as Headers from "../Headers.js"
@@ -248,3 +250,83 @@ export const schemaNoBodyScoped = <
   return <E, R2>(effect: Effect.Effect<ClientResponse.HttpClientResponse, E, R2>) =>
     Effect.scoped(Effect.flatMap(effect, decode))
 }
+
+/** @internal */
+export const matchStatus = dual<
+  <
+    const Cases extends {
+      readonly [status: number]: (_: ClientResponse.HttpClientResponse) => any
+      readonly "2xx"?: (_: ClientResponse.HttpClientResponse) => any
+      readonly "3xx"?: (_: ClientResponse.HttpClientResponse) => any
+      readonly "4xx"?: (_: ClientResponse.HttpClientResponse) => any
+      readonly "5xx"?: (_: ClientResponse.HttpClientResponse) => any
+      readonly orElse: (_: ClientResponse.HttpClientResponse) => any
+    }
+  >(
+    cases: Cases
+  ) => (self: ClientResponse.HttpClientResponse) => Cases[keyof Cases] extends (_: any) => infer R ? R : never,
+  <
+    const Cases extends {
+      readonly [status: number]: (_: ClientResponse.HttpClientResponse) => any
+      readonly "2xx"?: (_: ClientResponse.HttpClientResponse) => any
+      readonly "3xx"?: (_: ClientResponse.HttpClientResponse) => any
+      readonly "4xx"?: (_: ClientResponse.HttpClientResponse) => any
+      readonly "5xx"?: (_: ClientResponse.HttpClientResponse) => any
+      readonly orElse: (_: ClientResponse.HttpClientResponse) => any
+    }
+  >(self: ClientResponse.HttpClientResponse, cases: Cases) => Cases[keyof Cases] extends (_: any) => infer R ? R : never
+>(2, (self, cases) => {
+  const status = self.status
+  if (cases[status]) {
+    return cases[status](self)
+  } else if (status >= 200 && status < 300 && cases["2xx"]) {
+    return cases["2xx"](self)
+  } else if (status >= 300 && status < 400 && cases["3xx"]) {
+    return cases["3xx"](self)
+  } else if (status >= 400 && status < 500 && cases["4xx"]) {
+    return cases["4xx"](self)
+  } else if (status >= 500 && status < 600 && cases["5xx"]) {
+    return cases["5xx"](self)
+  }
+  return cases.orElse(self)
+})
+
+/** @internal */
+export const matchStatusScoped = dual<
+  <
+    const Cases extends {
+      readonly [status: number]: (_: ClientResponse.HttpClientResponse) => Effect.Effect<any, any, any>
+      readonly "2xx"?: (_: ClientResponse.HttpClientResponse) => Effect.Effect<any, any, any>
+      readonly "3xx"?: (_: ClientResponse.HttpClientResponse) => Effect.Effect<any, any, any>
+      readonly "4xx"?: (_: ClientResponse.HttpClientResponse) => Effect.Effect<any, any, any>
+      readonly "5xx"?: (_: ClientResponse.HttpClientResponse) => Effect.Effect<any, any, any>
+      readonly orElse: (_: ClientResponse.HttpClientResponse) => Effect.Effect<any, any, any>
+    }
+  >(cases: Cases) => <E, R>(self: Effect.Effect<ClientResponse.HttpClientResponse, E, R>) => Effect.Effect<
+    Cases[keyof Cases] extends (_: any) => Effect.Effect<infer _A, infer _E, infer _R> ? _A : never,
+    E | (Cases[keyof Cases] extends (_: any) => Effect.Effect<infer _A, infer _E, infer _R> ? _E : never),
+    Exclude<
+      R | (Cases[keyof Cases] extends (_: any) => Effect.Effect<infer _A, infer _E, infer _R> ? _R : never),
+      Scope
+    >
+  >,
+  <
+    E,
+    R,
+    const Cases extends {
+      readonly [status: number]: (_: ClientResponse.HttpClientResponse) => Effect.Effect<any, any, any>
+      readonly "2xx"?: (_: ClientResponse.HttpClientResponse) => Effect.Effect<any, any, any>
+      readonly "3xx"?: (_: ClientResponse.HttpClientResponse) => Effect.Effect<any, any, any>
+      readonly "4xx"?: (_: ClientResponse.HttpClientResponse) => Effect.Effect<any, any, any>
+      readonly "5xx"?: (_: ClientResponse.HttpClientResponse) => Effect.Effect<any, any, any>
+      readonly orElse: (_: ClientResponse.HttpClientResponse) => Effect.Effect<any, any, any>
+    }
+  >(self: Effect.Effect<ClientResponse.HttpClientResponse, E, R>, cases: Cases) => Effect.Effect<
+    Cases[keyof Cases] extends (_: any) => Effect.Effect<infer _A, infer _E, infer _R> ? _A : never,
+    E | (Cases[keyof Cases] extends (_: any) => Effect.Effect<infer _A, infer _E, infer _R> ? _E : never),
+    Exclude<
+      R | (Cases[keyof Cases] extends (_: any) => Effect.Effect<infer _A, infer _E, infer _R> ? _R : never),
+      Scope
+    >
+  >
+>(2, (self, cases) => Effect.scoped(Effect.flatMap(self, matchStatus(cases) as any)))

package/src/internal/httpMiddleware.ts

@@ -82,19 +82,23 @@ export const logger = make((httpApp) => {
       Effect.flatMap(Effect.exit(httpApp), (exit) => {
         if (fiber.getFiberRef(loggerDisabled)) {
           return exit
-        }
-        return Effect.zipRight(
-          exit._tag === "Failure" ?
-            Effect.annotateLogs(Effect.log(exit.cause), {
-              "http.method": request.method,
-              "http.url": request.url,
-              "http.status": ServerError.causeStatusCode(exit.cause)
-            }) :
-            Effect.annotateLogs(Effect.log("Sent HTTP response"), {
+        } else if (exit._tag === "Failure") {
+          const [status, cause] = ServerError.causeStatusStripped(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": exit.value.status
+              "http.status": status
             }),
+            exit
+          )
+        }
+        return Effect.zipRight(
+          Effect.annotateLogs(Effect.log("Sent HTTP response"), {
+            "http.method": request.method,
+            "http.url": request.url,
+            "http.status": exit.value.status
+          }),
           exit
         )
       }),
@@ -112,17 +116,10 @@ export const tracer = make((httpApp) =>
     if (disabled) {
       return httpApp
     }
-    const host = request.headers["host"] ?? "localhost"
-    const protocol = request.headers["x-forwarded-proto"] === "https" ? "https" : "http"
-    let url: URL | undefined = undefined
-    try {
-      url = new URL(request.url, `${protocol}://${host}`)
-      if (url.username !== "" || url.password !== "") {
-        url.username = "REDACTED"
-        url.password = "REDACTED"
-      }
-    } catch (_) {
-      //
+    const url = Option.getOrUndefined(ServerRequest.toURL(request))
+    if (url !== undefined && (url.username !== "" || url.password !== "")) {
+      url.username = "REDACTED"
+      url.password = "REDACTED"
     }
     const redactedHeaderNames = fiber.getFiberRef(Headers.currentRedactedNames)
     const redactedHeaders = Headers.redact(request.headers, redactedHeaderNames)
@@ -156,15 +153,11 @@ export const tracer = make((httpApp) =>
         return Effect.flatMap(
           Effect.exit(Effect.withParentSpan(httpApp, span)),
           (exit) => {
-            if (exit._tag === "Failure") {
-              span.attribute("http.response.status_code", ServerError.causeStatusCode(exit.cause))
-            } else {
-              const response = exit.value
-              span.attribute("http.response.status_code", response.status)
-              const redactedHeaders = Headers.redact(response.headers, redactedHeaderNames)
-              for (const name in redactedHeaders) {
-                span.attribute(`http.response.header.${name}`, String(redactedHeaders[name]))
-              }
+            const response = ServerError.exitResponse(exit)
+            span.attribute("http.response.status_code", response.status)
+            const redactedHeaders = Headers.redact(response.headers, redactedHeaderNames)
+            for (const name in redactedHeaders) {
+              span.attribute(`http.response.header.${name}`, String(redactedHeaders[name]))
             }
             return exit
           }

package/src/internal/httpRouter.ts

@@ -19,6 +19,7 @@ import type * as Method from "../HttpMethod.js"
 import type * as Router from "../HttpRouter.js"
 import * as Error from "../HttpServerError.js"
 import * as ServerRequest from "../HttpServerRequest.js"
+import * as Respondable from "../HttpServerRespondable.js"
 import type * as ServerResponse from "../HttpServerResponse.js"
 
 /** @internal */
@@ -149,7 +150,7 @@ class RouterImpl<E = never, R = never> extends Effectable.StructuralClass<
     readonly mounts: Chunk.Chunk<
       readonly [
         prefix: string,
-        httpApp: App.Default<E, R>,
+        httpApp: App.HttpApp<Respondable.Respondable, E, R>,
         options?: { readonly includePrefix?: boolean | undefined } | undefined
       ]
     >
@@ -225,7 +226,7 @@ const toHttpApp = <E, R>(
             context.unsafeMap.set(ServerRequest.HttpServerRequest.key, sliceRequestUrl(request, path))
           }
           return Effect.locally(
-            routeContext.route.handler as App.Default<E, R>,
+            Effect.flatMap(routeContext.route.handler, Respondable.toResponse) as App.Default<E, R>,
             FiberRef.currentContext,
             context
           )
@@ -252,10 +253,11 @@ const toHttpApp = <E, R>(
       span.value.attribute("http.route", route.path)
     }
 
+    const handlerResponse = Effect.flatMap(route.handler, Respondable.toResponse)
     return Effect.locally(
       (route.uninterruptible ?
-        route.handler :
-        Effect.interruptible(route.handler)) as Effect.Effect<
+        handlerResponse :
+        Effect.interruptible(handlerResponse)) as Effect.Effect<
           ServerResponse.HttpServerResponse,
           E,
           Router.HttpRouter.ExcludeProvided<R>
@@ -505,11 +507,11 @@ export const options = route("OPTIONS")
 /** @internal */
 export const use = dual<
   <E, R, R1, E1>(
-    f: (self: Router.Route.Handler<E, R>) => App.Default<E1, R1>
+    f: (self: Router.Route.Handler<E, R>) => App.HttpApp<Respondable.Respondable, E1, R1>
   ) => (self: Router.HttpRouter<E, R>) => Router.HttpRouter<E1, Router.HttpRouter.ExcludeProvided<R1>>,
   <E, R, R1, E1>(
     self: Router.HttpRouter<E, R>,
-    f: (self: Router.Route.Handler<E, R>) => App.Default<E1, R1>
+    f: (self: Router.Route.Handler<E, R>) => App.HttpApp<Respondable.Respondable, E1, R1>
   ) => Router.HttpRouter<E1, Router.HttpRouter.ExcludeProvided<R1>>
 >(2, (self, f) =>
   new RouterImpl<any, any>(
@@ -716,7 +718,7 @@ const makeService = <E, R>(): Router.HttpRouter.Service<E, R> => {
 /* @internal */
 export const Tag =
   <const Name extends string>(id: Name) =>
-  <Self, E = never, R = never>(): Router.HttpRouter.TagClass<Self, Name, E, R> => {
+  <Self, R = never, E = unknown>(): Router.HttpRouter.TagClass<Self, Name, E, R> => {
     const Err = globalThis.Error as any
     const limit = Err.stackTraceLimit
     Err.stackTraceLimit = 2

package/src/internal/httpServerError.ts

@@ -1,9 +1,12 @@
 import * as Cause from "effect/Cause"
+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 type { HttpServerResponse } from "../HttpServerResponse.js"
+import * as internalServerResponse from "./httpServerResponse.js"
 
 /** @internal */
 export const TypeId: Error.TypeId = Symbol.for(
@@ -28,10 +31,36 @@ export const isClientAbortCause = <E>(cause: Cause.Cause<E>): boolean =>
   )
 
 /** @internal */
+export const causeStatusStripped = <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)]
+  }
+  let response: HttpServerResponse | undefined
+  const stripped = Cause.stripSomeDefects(cause, (defect) => {
+    if (internalServerResponse.isServerResponse(defect)) {
+      response = defect
+      return Option.some(Cause.die(defect))
+    }
+    return Option.none()
+  })
+  return [response?.status ?? 500, stripped]
+}
 
-export const causeStatusCode = <E>(cause: Cause.Cause<E>): number =>
-  Cause.isInterruptedOnly(cause) ?
-    isClientAbortCause(cause) ?
-      499 :
-      503 :
-    500
+const internalServerError = internalServerResponse.empty({ status: 500 })
+
+/** @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()
+  )
+}

package/src/internal/httpServerRequest.ts

@@ -343,3 +343,14 @@ class ServerRequestImpl extends Inspectable.Class implements ServerRequest.HttpS
     )
   }
 }
+
+/** @internal */
+export const toURL = (self: ServerRequest.HttpServerRequest): Option.Option<URL> => {
+  const host = self.headers.host ?? "localhost"
+  const protocol = self.headers["x-forwarded-proto"] === "https" ? "https" : "http"
+  try {
+    return Option.some(new URL(self.url, `${protocol}://${host}`))
+  } catch (_) {
+    return Option.none()
+  }
+}

package/src/internal/httpServerResponse.ts

@@ -11,6 +11,7 @@ import type * as FileSystem from "../FileSystem.js"
 import * as Headers from "../Headers.js"
 import type * as Body from "../HttpBody.js"
 import * as Platform from "../HttpPlatform.js"
+import type * as Respondable from "../HttpServerRespondable.js"
 import type * as ServerResponse from "../HttpServerResponse.js"
 import * as Template from "../Template.js"
 import * as UrlParams from "../UrlParams.js"
@@ -19,6 +20,10 @@ import * as internalBody from "./httpBody.js"
 /** @internal */
 export const TypeId: ServerResponse.TypeId = Symbol.for("@effect/platform/HttpServerResponse") as ServerResponse.TypeId
 
+const respondableSymbol: typeof Respondable.symbol = Symbol.for(
+  "@effect/platform/HttpServerRespondable"
+) as typeof Respondable.symbol
+
 class ServerResponseImpl extends Effectable.StructuralClass<ServerResponse.HttpServerResponse>
   implements ServerResponse.HttpServerResponse
 {
@@ -51,6 +56,10 @@ class ServerResponseImpl extends Effectable.StructuralClass<ServerResponse.HttpS
     return Effect.succeed(this)
   }
 
+  [respondableSymbol](): Effect.Effect<ServerResponse.HttpServerResponse, unknown> {
+    return Effect.succeed(this)
+  }
+
   [Inspectable.NodeInspectSymbol]() {
     return this.toJSON()
   }