effect 4.0.0-beta.4 → 4.0.0-beta.40

package/src/unstable/http/HttpMethod.ts

@@ -14,6 +14,7 @@ export type HttpMethod =
   | "PATCH"
   | "HEAD"
   | "OPTIONS"
+  | "TRACE"
 
 /**
  * @since 4.0.0
@@ -24,7 +25,7 @@ export declare namespace HttpMethod {
    * @since 4.0.0
    * @category models
    */
-  export type NoBody = "GET" | "HEAD" | "OPTIONS"
+  export type NoBody = "GET" | "HEAD" | "OPTIONS" | "TRACE"
 
   /**
    * @since 4.0.0
@@ -36,12 +37,22 @@ export declare namespace HttpMethod {
 /**
  * @since 4.0.0
  */
-export const hasBody = (method: HttpMethod): boolean => method !== "GET" && method !== "HEAD" && method !== "OPTIONS"
+export const hasBody = (method: HttpMethod): method is HttpMethod.WithBody =>
+  method !== "GET" && method !== "HEAD" && method !== "OPTIONS" && method !== "TRACE"
 
 /**
  * @since 4.0.0
  */
-export const all: ReadonlySet<HttpMethod> = new Set(["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"])
+export const all: ReadonlySet<HttpMethod> = new Set([
+  "GET",
+  "POST",
+  "PUT",
+  "DELETE",
+  "PATCH",
+  "HEAD",
+  "OPTIONS",
+  "TRACE"
+])
 
 /**
  * @since 4.0.0
@@ -53,7 +64,8 @@ export const allShort = [
   ["DELETE", "del"],
   ["PATCH", "patch"],
   ["HEAD", "head"],
-  ["OPTIONS", "options"]
+  ["OPTIONS", "options"],
+  ["TRACE", "trace"]
 ] as const
 
 /**

package/src/unstable/http/HttpMiddleware.ts

@@ -6,19 +6,20 @@ import * as Effect from "../../Effect.ts"
 import { constant, constFalse } from "../../Function.ts"
 import * as internalEffect from "../../internal/effect.ts"
 import * as Layer from "../../Layer.ts"
+import * as Option from "../../Option.ts"
 import type { Predicate } from "../../Predicate.ts"
 import type { ReadonlyRecord } from "../../Record.ts"
 import { TracerEnabled } from "../../References.ts"
 import * as ServiceMap from "../../ServiceMap.ts"
 import { ParentSpan } from "../../Tracer.ts"
 import * as Headers from "./Headers.ts"
-import type { PreResponseHandler } from "./HttpEffect.ts"
 import { causeResponseStripped, exitResponse } from "./HttpServerError.ts"
 import { HttpServerRequest } from "./HttpServerRequest.ts"
 import * as Request from "./HttpServerRequest.ts"
 import * as Response from "./HttpServerResponse.ts"
 import type { HttpServerResponse } from "./HttpServerResponse.ts"
 import * as TraceContext from "./HttpTraceContext.ts"
+import { appendPreResponseHandlerUnsafe } from "./internal/preResponseHandler.ts"
 
 /**
  * @since 4.0.0
@@ -46,21 +47,16 @@ export declare namespace HttpMiddleware {
  */
 export const make = <M extends HttpMiddleware>(middleware: M): M => middleware
 
-/**
- * @since 4.0.0
- * @category Logger
- */
-export const LoggerDisabled = ServiceMap.Reference<boolean>("effect/http/HttpMiddleware/LoggerDisabled", {
-  defaultValue: constFalse
-})
+const loggerDisabledRequests = new WeakSet<object>()
 
 /**
  * @since 4.0.0
  * @category Logger
  */
-export const withLoggerDisabled = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
+export const withLoggerDisabled = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, E, R | HttpServerRequest> =>
   Effect.withFiber((fiber) => {
-    fiber.setServices(ServiceMap.add(fiber.services, LoggerDisabled, true))
+    const request = ServiceMap.getUnsafe(fiber.services, HttpServerRequest)
+    loggerDisabledRequests.add(request.source)
     return self
   })
 
@@ -102,12 +98,12 @@ export const logger: <E, R>(
     const request = ServiceMap.getUnsafe(fiber.services, HttpServerRequest)
     return Effect.withLogSpan(
       Effect.flatMap(Effect.exit(httpApp), (exit) => {
-        if (fiber.getRef(LoggerDisabled)) {
+        if (loggerDisabledRequests.has(request.source)) {
           return exit
         } else if (exit._tag === "Failure") {
           const [response, cause] = causeResponseStripped(exit.cause)
           return Effect.andThen(
-            Effect.annotateLogs(Effect.log(cause ?? "Sent HTTP Response"), {
+            Effect.annotateLogs(Effect.log(Option.getOrElse(cause, () => "Sent HTTP Response")), {
               "http.method": request.method,
               "http.url": request.url,
               "http.status": response.status
@@ -144,31 +140,31 @@ export const tracer: <E, R>(
     }
     const nameGenerator = fiber.getRef(SpanNameGenerator)
     const span = internalEffect.makeSpanUnsafe(fiber, nameGenerator(request), {
-      parent: TraceContext.fromHeaders(request.headers),
+      parent: Option.getOrUndefined(TraceContext.fromHeaders(request.headers)),
       kind: "server"
     })
-    const prevSpan = ServiceMap.getOption(fiber.services, ParentSpan)
+    const prevServices = fiber.services
     fiber.setServices(ServiceMap.add(fiber.services, ParentSpan, span))
     return Effect.onExitPrimitive(httpApp, (exit) => {
-      fiber.setServices(ServiceMap.addOrOmit(fiber.services, ParentSpan, prevSpan))
+      fiber.setServices(prevServices)
       const endTime = fiber.getRef(Clock).currentTimeNanosUnsafe()
-      fiber.currentScheduler.scheduleTask(() => {
+      fiber.currentDispatcher.scheduleTask(() => {
         const url = Request.toURL(request)
-        if (url !== undefined && (url.username !== "" || url.password !== "")) {
-          url.username = "REDACTED"
-          url.password = "REDACTED"
+        if (Option.isSome(url) && (url.value.username !== "" || url.value.password !== "")) {
+          url.value.username = "REDACTED"
+          url.value.password = "REDACTED"
         }
         const redactedHeaderNames = fiber.getRef(Headers.CurrentRedactedNames)
         const requestHeaders = Headers.redact(request.headers, redactedHeaderNames)
         span.attribute("http.request.method", request.method)
-        if (url !== undefined) {
-          span.attribute("url.full", url.toString())
-          span.attribute("url.path", url.pathname)
-          const query = url.search.slice(1)
+        if (Option.isSome(url)) {
+          span.attribute("url.full", url.value.toString())
+          span.attribute("url.path", url.value.pathname)
+          const query = url.value.search.slice(1)
           if (query !== "") {
-            span.attribute("url.query", url.search.slice(1))
+            span.attribute("url.query", url.value.search.slice(1))
           }
-          span.attribute("url.scheme", url.protocol.slice(0, -1))
+          span.attribute("url.scheme", url.value.protocol.slice(0, -1))
         }
         if (request.headers["user-agent"] !== undefined) {
           span.attribute("user_agent.original", request.headers["user-agent"])
@@ -176,8 +172,8 @@ export const tracer: <E, R>(
         for (const name in requestHeaders) {
           span.attribute(`http.request.header.${name}`, String(requestHeaders[name]))
         }
-        if (request.remoteAddress !== undefined) {
-          span.attribute("client.address", request.remoteAddress)
+        if (Option.isSome(request.remoteAddress)) {
+          span.attribute("client.address", request.remoteAddress.value)
         }
         const response = exitResponse(exit)
         span.attribute("http.response.status_code", response.status)
@@ -205,7 +201,7 @@ export const xForwardedHeaders = make((httpApp) =>
           "host",
           request.headers["x-forwarded-host"]
         ),
-        remoteAddress: request.headers["x-forwarded-for"]?.split(",")[0].trim()
+        remoteAddress: Option.fromNullishOr(request.headers["x-forwarded-for"]?.split(",")[0].trim())
       })
       : request)
 )
@@ -343,17 +339,7 @@ export const cors = (options?: {
           headers: headersFromRequestOptions(request)
         }))
       }
-      const prev = fiber.getRef(PreResponseHandlers)
-      const next = prev
-        ? ((req: HttpServerRequest, res: HttpServerResponse) =>
-          Effect.flatMap(prev(req, res), (res) => preResponseHandler(req, res)))
-        : preResponseHandler
-      fiber.setServices(ServiceMap.add(fiber.services, PreResponseHandlers, next))
+      appendPreResponseHandlerUnsafe(request, preResponseHandler)
       return httpApp
     })
 }
-
-const PreResponseHandlers = ServiceMap.Reference<PreResponseHandler | undefined>(
-  "effect/http/HttpEffect/PreResponseHandlers",
-  { defaultValue: () => undefined }
-)

package/src/unstable/http/HttpPlatform.ts

@@ -5,6 +5,7 @@ import * as Effect from "../../Effect.ts"
 import * as FileSystem from "../../FileSystem.ts"
 import { identity } from "../../Function.ts"
 import * as Layer from "../../Layer.ts"
+import * as Option from "../../Option.ts"
 import type { PlatformError } from "../../PlatformError.ts"
 import * as ServiceMap from "../../ServiceMap.ts"
 import * as Stream from "../../Stream.ts"
@@ -80,8 +81,8 @@ export const make: (impl: {
         "etag",
         Etag.toString(etag)
       )
-      if (info.mtime) {
-        ;(headers as any)["last-modified"] = info.mtime.toUTCString()
+      if (Option.isSome(info.mtime)) {
+        ;(headers as any)["last-modified"] = info.mtime.value.toUTCString()
       }
       const contentLength = end !== undefined ? end - start : Number(info.size) - start
       return impl.fileResponse(

package/src/unstable/http/HttpRouter.ts

@@ -5,6 +5,7 @@ import * as Arr from "../../Array.ts"
 import * as Effect from "../../Effect.ts"
 import { compose, dual, identity } from "../../Function.ts"
 import * as Layer from "../../Layer.ts"
+import * as Option from "../../Option.ts"
 import type { ReadonlyRecord } from "../../Record.ts"
 import * as Schema from "../../Schema.ts"
 import type { ParseOptions } from "../../SchemaAST.ts"
@@ -12,7 +13,6 @@ import * as Scope from "../../Scope.ts"
 import * as ServiceMap from "../../ServiceMap.ts"
 import * as Tracer from "../../Tracer.ts"
 import type * as Types from "../../Types.ts"
-import * as UndefinedOr from "../../UndefinedOr.ts"
 import * as FindMyWay from "./FindMyWay.ts"
 import * as HttpEffect from "./HttpEffect.ts"
 import type * as HttpMethod from "./HttpMethod.ts"
@@ -177,8 +177,8 @@ export const make = Effect.gen(function*() {
           )
         }
         const route = result.handler
-        if (route.prefix !== undefined) {
-          contextMap.set(HttpServerRequest.HttpServerRequest.key, sliceRequestUrl(request, route.prefix))
+        if (Option.isSome(route.prefix)) {
+          contextMap.set(HttpServerRequest.HttpServerRequest.key, sliceRequestUrl(request, route.prefix.value))
         }
         contextMap.set(HttpServerRequest.ParsedSearchParams.key, result.searchParams)
         contextMap.set(RouteContext.key, {
@@ -501,7 +501,7 @@ export interface Route<E = never, R = never> {
   readonly path: PathInput
   readonly handler: Effect.Effect<HttpServerResponse.HttpServerResponse, E, R>
   readonly uninterruptible: boolean
-  readonly prefix: string | undefined
+  readonly prefix: Option.Option<string>
 }
 
 /**
@@ -527,12 +527,12 @@ const makeRoute = <E, R>(options: {
   readonly path: PathInput
   readonly handler: Effect.Effect<HttpServerResponse.HttpServerResponse, E, R>
   readonly uninterruptible?: boolean | undefined
-  readonly prefix?: string | undefined
+  readonly prefix?: Option.Option<string> | string | undefined
 }): Route<E, Exclude<R, Provided>> =>
   (({
     ...options,
     uninterruptible: options.uninterruptible ?? false,
-    prefix: options.prefix,
+    prefix: typeof options.prefix === "string" ? Option.some(options.prefix) : options.prefix ?? Option.none(),
     [RouteTypeId]: RouteTypeId
   }) as Route<E, Exclude<R, Provided>>)
 
@@ -614,9 +614,9 @@ export const prefixRoute: {
   makeRoute({
     ...self,
     path: prefixPath(self.path, prefix) as PathInput,
-    prefix: UndefinedOr.match(self.prefix, {
-      onUndefined: () => prefix as string,
-      onDefined: (existingPrefix) => prefixPath(existingPrefix, prefix) as string
+    prefix: Option.match(self.prefix, {
+      onNone: () => prefix as string,
+      onSome: (existingPrefix) => prefixPath(existingPrefix, prefix) as string
     })
   }))
 

package/src/unstable/http/HttpServer.ts

@@ -36,6 +36,7 @@ export class HttpServer extends ServiceMap.Service<HttpServer, {
       Exclude<R, HttpServerRequest> | Scope.Scope
     >
   }
+
   readonly address: Address
 }>()("effect/http/HttpServer") {}
 
@@ -127,10 +128,7 @@ export const serve: {
   HttpServer | Exclude<Effect.Services<App>, HttpServerRequest | Scope.Scope>
 > =>
   Layer.effectDiscard(
-    Effect.flatMap(
-      HttpServer.asEffect(),
-      (server) => server.serve(effect, middleware!)
-    )
+    HttpServer.use((server) => server.serve(effect, middleware!))
   ) as any)
 
 /**
@@ -180,11 +178,7 @@ export const serveEffect: {
   void,
   never,
   Scope.Scope | HttpServer | Exclude<Effect.Services<App>, HttpServerRequest>
-> =>
-  Effect.flatMap(
-    HttpServer.asEffect(),
-    (server) => server.serve(effect, middleware!)
-  ) as any)
+> => HttpServer.use((server) => server.serve(effect, middleware!)) as any)
 
 /**
  * @since 4.0.0

package/src/unstable/http/HttpServerError.ts

@@ -4,8 +4,12 @@
 import * as Cause from "../../Cause.ts"
 import * as Data from "../../Data.ts"
 import * as Effect from "../../Effect.ts"
+import * as ErrorReporter from "../../ErrorReporter.ts"
 import type * as Exit from "../../Exit.ts"
+import { constUndefined } from "../../Function.ts"
+import * as Option from "../../Option.ts"
 import { hasProperty } from "../../Predicate.ts"
+import * as ServiceMap from "../../ServiceMap.ts"
 import type * as Request from "./HttpServerRequest.ts"
 import * as Respondable from "./HttpServerRespondable.ts"
 import * as Response from "./HttpServerResponse.ts"
@@ -32,35 +36,24 @@ export class HttpServerError extends Data.TaggedError("HttpServerError")<{
     }
   }
 
-  /**
-   * @since 4.0.0
-   */
   readonly [TypeId] = TypeId
 
-  /**
-   * @since 4.0.0
-   */
   override stack = `${this.name}: ${this.message}`
 
-  /**
-   * @since 4.0.0
-   */
   get request(): Request.HttpServerRequest {
     return this.reason.request
   }
 
-  /**
-   * @since 4.0.0
-   */
   get response(): Response.HttpServerResponse | undefined {
     return "response" in this.reason ? this.reason.response : undefined
   }
 
-  /**
-   * @since 4.0.0
-   */
-  [Respondable.TypeId]() {
-    return this.reason[Respondable.TypeId]()
+  [Respondable.symbol]() {
+    return this.reason[Respondable.symbol]()
+  }
+
+  override get [ErrorReporter.ignore](): boolean {
+    return this.reason[ErrorReporter.ignore] ?? false
   }
 
   override get message(): string {
@@ -80,7 +73,7 @@ export class RequestParseError extends Data.TaggedError("RequestParseError")<{
   /**
    * @since 4.0.0
    */
-  [Respondable.TypeId]() {
+  [Respondable.symbol]() {
     return Effect.succeed(Response.empty({ status: 400 }))
   }
 
@@ -102,13 +95,12 @@ export class RouteNotFound extends Data.TaggedError("RouteNotFound")<{
   readonly description?: string
   readonly cause?: unknown
 }> implements Respondable.Respondable {
-  /**
-   * @since 4.0.0
-   */
-  [Respondable.TypeId]() {
+  [Respondable.symbol]() {
     return Effect.succeed(Response.empty({ status: 404 }))
   }
 
+  override readonly [ErrorReporter.ignore] = true
+
   get methodAndUrl() {
     return `${this.request.method} ${this.request.url}`
   }
@@ -130,7 +122,7 @@ export class InternalError extends Data.TaggedError("InternalError")<{
   /**
    * @since 4.0.0
    */
-  [Respondable.TypeId]() {
+  [Respondable.symbol]() {
     return Effect.succeed(Response.empty({ status: 500 }))
   }
 
@@ -159,10 +151,7 @@ export class ResponseError extends Data.TaggedError("ResponseError")<{
   readonly description?: string
   readonly cause?: unknown
 }> implements Respondable.Respondable {
-  /**
-   * @since 4.0.0
-   */
-  [Respondable.TypeId]() {
+  [Respondable.symbol]() {
     return Effect.succeed(Response.empty({ status: 500 }))
   }
 
@@ -196,16 +185,25 @@ export class ServeError extends Data.TaggedError("ServeError")<{
   readonly cause: unknown
 }> {}
 
+/**
+ * @since 4.0.0
+ * @category Annotations
+ */
+export class ClientAbort extends ServiceMap.Service<ClientAbort, true>()("effect/http/HttpServerError/ClientAbort") {
+  static annotation = this.serviceMap(true).pipe(
+    ServiceMap.add(Cause.StackTrace, {
+      name: "ClientAbort",
+      stack: constUndefined,
+      parent: undefined
+    })
+  )
+}
+
 const formatRequestMessage = (reason: string, description: string | undefined, info: string) => {
   const prefix = `${reason} (${info})`
   return description ? `${prefix}: ${description}` : prefix
 }
 
-/**
- * @since 4.0.0
- */
-export const clientAbortFiberId = -499
-
 /**
  * @since 4.0.0
  */
@@ -215,37 +213,37 @@ export const causeResponse = <E>(
   let response: Response.HttpServerResponse | undefined
   let effect = succeedInternalServerError
   const failures: Array<Cause.Reason<E>> = []
-  let interrupt: Cause.Interrupt | undefined
+  let interrupts: Array<Cause.Interrupt> = []
   let isClientInterrupt = false
   for (let i = 0; i < cause.reasons.length; i++) {
-    const f = cause.reasons[i]
-    switch (f._tag) {
+    const reason = cause.reasons[i]
+    switch (reason._tag) {
       case "Fail": {
-        effect = Respondable.toResponseOrElse(f.error, internalServerError)
-        failures.push(f)
+        effect = Respondable.toResponseOrElse(reason.error, internalServerError)
+        failures.push(reason)
         break
       }
       case "Die": {
-        if (Response.isHttpServerResponse(f.defect)) {
-          response = f.defect
+        if (Response.isHttpServerResponse(reason.defect)) {
+          response = reason.defect
         } else {
-          effect = Respondable.toResponseOrElseDefect(f.defect, internalServerError)
-          failures.push(f)
+          effect = Respondable.toResponseOrElseDefect(reason.defect, internalServerError)
+          failures.push(reason)
         }
         break
       }
       case "Interrupt": {
-        isClientInterrupt = isClientInterrupt || f.fiberId === clientAbortFiberId
+        isClientInterrupt = reason.annotations.has(ClientAbort.key)
         if (failures.length > 0) break
-        interrupt = f
+        interrupts.push(reason)
         break
       }
     }
   }
   if (response) {
     return Effect.succeed([response, Cause.fromReasons(failures)] as const)
-  } else if (interrupt && failures.length === 0) {
-    failures.push(isClientInterrupt ? Cause.makeInterruptReason(clientAbortFiberId) : interrupt)
+  } else if (interrupts.length > 0 && failures.length === 0) {
+    failures.push(...interrupts)
     effect = isClientInterrupt ? clientAbortError : serverAbortError
   }
   return Effect.mapEager(effect, (response) => {
@@ -259,7 +257,7 @@ export const causeResponse = <E>(
  */
 export const causeResponseStripped = <E>(
   cause: Cause.Cause<E>
-): readonly [response: Response.HttpServerResponse, cause: Cause.Cause<E> | undefined] => {
+): readonly [response: Response.HttpServerResponse, cause: Option.Option<Cause.Cause<E>>] => {
   let response: Response.HttpServerResponse | undefined
   const failures = cause.reasons.filter((f) => {
     if (f._tag === "Die" && Response.isHttpServerResponse(f.defect)) {
@@ -270,7 +268,7 @@ export const causeResponseStripped = <E>(
   })
   return [
     response ?? internalServerError,
-    failures.length > 0 ? Cause.fromReasons(failures) : undefined
+    failures.length > 0 ? Option.some(Cause.fromReasons(failures)) : Option.none()
   ]
 }