effect 4.0.0-beta.6 → 4.0.0-beta.60

package/src/unstable/http/HttpEffect.ts

@@ -1,23 +1,24 @@
 /**
  * @since 4.0.0
  */
-import type { Cause } from "../../Cause.ts"
+import type * as Cause from "../../Cause.ts"
+import * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
 import * as Exit from "../../Exit.ts"
 import * as Fiber from "../../Fiber.ts"
 import { dual } from "../../Function.ts"
+import { reportCauseUnsafe } from "../../internal/effect.ts"
 import * as Layer from "../../Layer.ts"
 import * as Scope from "../../Scope.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import * as Stream from "../../Stream.ts"
-import * as UndefinedOr from "../../UndefinedOr.ts"
 import * as HttpBody from "./HttpBody.ts"
 import { type HttpMiddleware, tracer } from "./HttpMiddleware.ts"
-import { causeResponse, clientAbortFiberId, HttpServerError, InternalError } from "./HttpServerError.ts"
+import { causeResponse, ClientAbort, HttpServerError, InternalError } from "./HttpServerError.ts"
 import { HttpServerRequest } from "./HttpServerRequest.ts"
 import * as Request from "./HttpServerRequest.ts"
 import type { HttpServerResponse } from "./HttpServerResponse.ts"
 import * as Response from "./HttpServerResponse.ts"
+import { appendPreResponseHandlerUnsafe, requestPreResponseHandlers } from "./internal/preResponseHandler.ts"
 
 /**
  * @since 4.0.0
@@ -31,11 +32,12 @@ export const toHandled = <E, R, EH, RH>(
   ) => Effect.Effect<unknown, EH, RH>,
   middleware?: HttpMiddleware | undefined
 ): Effect.Effect<void, never, Exclude<R | RH | HttpServerRequest, Scope.Scope>> => {
-  const handleCause = (cause: Cause<E | EH | HttpServerError>) =>
+  const handleCause = (cause: Cause.Cause<E | EH | HttpServerError>) =>
     Effect.flatMapEager(causeResponse(cause), ([response, cause]) => {
       const fiber = Fiber.getCurrent()!
-      const request = ServiceMap.getUnsafe(fiber.services, HttpServerRequest)
-      const handler = fiber.getRef(PreResponseHandlers)
+      reportCauseUnsafe(fiber, cause)
+      const request = Context.getUnsafe(fiber.context, HttpServerRequest)
+      const handler = requestPreResponseHandlers.get(request.source)
       const cont = cause.reasons.length === 0 ? Effect.succeed(response) : Effect.failCause(cause)
       if (handler === undefined) {
         ;(request as any)[handledSymbol] = true
@@ -57,8 +59,8 @@ export const toHandled = <E, R, EH, RH>(
   const responded = Effect.matchCauseEffect(self, {
     onSuccess: (response) => {
       const fiber = Fiber.getCurrent()!
-      const request = ServiceMap.getUnsafe(fiber.services, HttpServerRequest)
-      const handler = fiber.getRef(PreResponseHandlers)
+      const request = Context.getUnsafe(fiber.context, HttpServerRequest)
+      const handler = requestPreResponseHandlers.get(request.source)
       if (handler === undefined) {
         ;(request as any)[handledSymbol] = true
         return Effect.mapEager(handleResponse(request, response), () => response)
@@ -80,18 +82,21 @@ export const toHandled = <E, R, EH, RH>(
     Effect.matchCauseEffect(tracer(middleware(responded)), {
       onFailure(cause): Effect.Effect<void, EH, RH> {
         const fiber = Fiber.getCurrent()!
-        const request = ServiceMap.getUnsafe(fiber.services, HttpServerRequest)
-        if (handledSymbol in request) {
-          return Effect.void
-        }
+        reportCauseUnsafe(fiber, cause)
+        const request = Context.getUnsafe(fiber.context, HttpServerRequest)
+        if (handledSymbol in request) return Effect.void
         return Effect.matchCauseEffectEager(causeResponse(cause), {
-          onFailure: (_cause) => handleResponse(request, Response.empty({ status: 500 })),
-          onSuccess: ([response]) => handleResponse(request, response)
+          onFailure(_) {
+            return handleResponse(request, Response.empty({ status: 500 }))
+          },
+          onSuccess([response]) {
+            return handleResponse(request, response)
+          }
         })
       },
       onSuccess(response): Effect.Effect<void, EH, RH> {
         const fiber = Fiber.getCurrent()!
-        const request = ServiceMap.getUnsafe(fiber.services, Request.HttpServerRequest)
+        const request = Context.getUnsafe(fiber.context, Request.HttpServerRequest)
         return handledSymbol in request ? Effect.void : handleResponse(request, response)
       }
     })
@@ -123,7 +128,7 @@ export const scopeTransferToStream = (
     return response
   }
   const fiber = Fiber.getCurrent()!
-  const scope = ServiceMap.getUnsafe(fiber.services, Scope.Scope) as Scope.Closeable
+  const scope = Context.getUnsafe(fiber.context, Scope.Scope) as Scope.Closeable
   scopeDisableClose(scope)
   return Response.setBody(
     response,
@@ -140,10 +145,10 @@ const scopeEjected = Symbol.for("effect/http/HttpEffect/scopeEjected")
 const scoped = <A, E, R>(effect: Effect.Effect<A, E, R>) =>
   Effect.withFiber((fiber) => {
     const scope = Scope.makeUnsafe()
-    const prev = ServiceMap.getOption(fiber.services, Scope.Scope)
-    fiber.setServices(ServiceMap.add(fiber.services, Scope.Scope, scope))
+    const prevServices = fiber.context
+    fiber.setContext(Context.add(fiber.context, Scope.Scope, scope))
     return Effect.onExitPrimitive(effect, (exit) => {
-      fiber.setServices(ServiceMap.addOrOmit(fiber.services, Scope.Scope, prev))
+      fiber.setContext(prevServices)
       if (scopeEjected in scope) return undefined
       return Scope.closeUnsafe(scope, exit)
     }, true)
@@ -158,30 +163,24 @@ export type PreResponseHandler = (
   response: HttpServerResponse
 ) => Effect.Effect<HttpServerResponse, HttpServerError>
 
-/**
- * @since 4.0.0
- * @category Pre-response handlers
- */
-export const PreResponseHandlers = ServiceMap.Reference<PreResponseHandler | undefined>(
-  "effect/http/HttpEffect/PreResponseHandlers",
-  { defaultValue: () => undefined }
-)
-
 /**
  * @since 4.0.0
  * @category fiber refs
  */
-export const appendPreResponseHandler = (handler: PreResponseHandler): Effect.Effect<void> =>
-  Effect.withFiber((fiber) => {
-    const next = UndefinedOr.match(fiber.getRef(PreResponseHandlers), {
-      onUndefined: () => handler,
-      onDefined: (prev) => (request, response) =>
-        Effect.flatMap(prev(request, response), (response) => handler(request, response))
-    })
-    fiber.setServices(ServiceMap.add(fiber.services, PreResponseHandlers, next))
+export const appendPreResponseHandler = (handler: PreResponseHandler): Effect.Effect<void, never, HttpServerRequest> =>
+  HttpServerRequest.use((request) => {
+    appendPreResponseHandlerUnsafe(request, handler)
     return Effect.void
   })
 
+export {
+  /**
+   * @since 4.0.0
+   * @category fiber refs
+   */
+  appendPreResponseHandlerUnsafe
+}
+
 /**
  * @since 4.0.0
  * @category fiber refs
@@ -191,70 +190,65 @@ export const withPreResponseHandler: {
    * @since 4.0.0
    * @category fiber refs
    */
-  (handler: PreResponseHandler): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
+  (handler: PreResponseHandler): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R | HttpServerRequest>
   /**
    * @since 4.0.0
    * @category fiber refs
    */
-  <A, E, R>(self: Effect.Effect<A, E, R>, handler: PreResponseHandler): Effect.Effect<A, E, R>
+  <A, E, R>(self: Effect.Effect<A, E, R>, handler: PreResponseHandler): Effect.Effect<A, E, R | HttpServerRequest>
 } = dual<
   /**
    * @since 4.0.0
    * @category fiber refs
    */
-  (handler: PreResponseHandler) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
+  (handler: PreResponseHandler) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R | HttpServerRequest>,
   /**
    * @since 4.0.0
    * @category fiber refs
    */
-  <A, E, R>(self: Effect.Effect<A, E, R>, handler: PreResponseHandler) => Effect.Effect<A, E, R>
+  <A, E, R>(self: Effect.Effect<A, E, R>, handler: PreResponseHandler) => Effect.Effect<A, E, R | HttpServerRequest>
 >(2, (self, handler) =>
-  Effect.updateService(
-    self,
-    PreResponseHandlers,
-    UndefinedOr.match({
-      onUndefined: () => handler,
-      onDefined: (prev) => (request, response) =>
-        Effect.flatMap(prev(request, response), (response) => handler(request, response))
-    })
-  ))
+  HttpServerRequest.use((request) => {
+    appendPreResponseHandlerUnsafe(request, handler)
+    return self
+  }))
 
 /**
  * @since 4.0.0
  * @category conversions
  */
 export const toWebHandlerWith = <Provided, R = never, ReqR = Exclude<R, Provided | Scope.Scope | HttpServerRequest>>(
-  services: ServiceMap.ServiceMap<Provided>
+  context: Context.Context<Provided>
 ) =>
 <E>(
   self: Effect.Effect<HttpServerResponse, E, R>,
   middleware?: HttpMiddleware | undefined
 ): [ReqR] extends [never] ?
-  (request: Request, services?: ServiceMap.ServiceMap<never> | undefined) => Promise<globalThis.Response>
-  : (request: Request, services: ServiceMap.ServiceMap<ReqR>) => Promise<globalThis.Response> =>
+  (request: Request, context?: Context.Context<never> | undefined) => Promise<globalThis.Response>
+  : (request: Request, context: Context.Context<ReqR>) => Promise<globalThis.Response> =>
 {
   const resolveSymbol = Symbol.for("@effect/platform/HttpApp/resolve")
   const httpApp = toHandled(self, (request, response) => {
     response = scopeTransferToStream(response)
     ;(request as any)[resolveSymbol](
-      Response.toWeb(response, { withoutBody: request.method === "HEAD", services })
+      Response.toWeb(response, { withoutBody: request.method === "HEAD", context })
     )
     return Effect.void
   }, middleware)
-  return (request: Request, reqServices?: ServiceMap.ServiceMap<never> | undefined): Promise<globalThis.Response> =>
+  return (request: Request, reqContext?: Context.Context<never> | undefined): Promise<globalThis.Response> =>
     new Promise((resolve) => {
-      const contextMap = new Map<string, any>(services.mapUnsafe)
-      if (ServiceMap.isServiceMap(reqServices)) {
-        for (const [key, value] of reqServices.mapUnsafe) {
+      const contextMap = new Map<string, any>(context.mapUnsafe)
+      if (Context.isContext(reqContext)) {
+        for (const [key, value] of reqContext.mapUnsafe) {
           contextMap.set(key, value)
         }
       }
       const httpServerRequest = Request.fromWeb(request)
       contextMap.set(HttpServerRequest.key, httpServerRequest)
       ;(httpServerRequest as any)[resolveSymbol] = resolve
-      const fiber = Effect.runForkWith(ServiceMap.makeUnsafe(contextMap))(httpApp as any)
+      const fiber = Effect.runForkWith(Context.makeUnsafe(contextMap))(httpApp as any)
       request.signal?.addEventListener("abort", () => {
-        fiber.interruptUnsafe(clientAbortFiberId)
+        fiber.interruptUnsafe(undefined, ClientAbort.annotation)
       }, { once: true })
     })
 }
@@ -266,8 +260,8 @@ export const toWebHandlerWith = <Provided, R = never, ReqR = Exclude<R, Provided
 export const toWebHandler: <E>(
   self: Effect.Effect<HttpServerResponse, E, HttpServerRequest | Scope.Scope>,
   middleware?: HttpMiddleware | undefined
-) => (request: Request, services?: ServiceMap.ServiceMap<never> | undefined) => Promise<globalThis.Response> =
-  toWebHandlerWith(ServiceMap.empty())
+) => (request: Request, context?: Context.Context<never> | undefined) => Promise<globalThis.Response> =
+  toWebHandlerWith(Context.empty())
 
 /**
  * @since 4.0.0
@@ -283,7 +277,7 @@ export const toWebHandlerLayerWith = <
   layer: Layer.Layer<Provided, LE>,
   options: {
     readonly toHandler: (
-      services: ServiceMap.ServiceMap<Provided>
+      context: Context.Context<Provided>
     ) => Effect.Effect<Effect.Effect<HttpServerResponse, E, R>, LE>
     readonly middleware?: HttpMiddleware | undefined
     readonly memoMap?: Layer.MemoMap | undefined
@@ -292,39 +286,39 @@ export const toWebHandlerLayerWith = <
   readonly dispose: () => Promise<void>
   readonly handler: [ReqR] extends [never] ? (
       request: Request,
-      services?: ServiceMap.ServiceMap<never> | undefined
+      context?: Context.Context<never> | undefined
     ) => Promise<globalThis.Response>
     : (
       request: Request,
-      services: ServiceMap.ServiceMap<ReqR>
+      context: Context.Context<ReqR>
     ) => Promise<globalThis.Response>
 } => {
   const scope = Scope.makeUnsafe()
   const dispose = () => Effect.runPromise(Scope.close(scope, Exit.void))
 
   let handlerCache:
-    | ((request: Request, services?: ServiceMap.ServiceMap<ReqR> | undefined) => Promise<globalThis.Response>)
+    | ((request: Request, context?: Context.Context<ReqR> | undefined) => Promise<globalThis.Response>)
     | undefined
   let handlerPromise:
-    | Promise<(request: Request, services?: ServiceMap.ServiceMap<ReqR> | undefined) => Promise<globalThis.Response>>
+    | Promise<(request: Request, context?: Context.Context<ReqR> | undefined) => Promise<globalThis.Response>>
     | undefined
   function handler(
     request: Request,
-    services?: ServiceMap.ServiceMap<ReqR> | undefined
+    context?: Context.Context<ReqR> | undefined
   ): Promise<globalThis.Response> {
     if (handlerCache) {
-      return handlerCache(request, services)
+      return handlerCache(request, context)
     }
     handlerPromise ??= Effect.runPromise(Effect.gen(function*() {
-      const services = yield* (options.memoMap
+      const context = yield* (options.memoMap
         ? Layer.buildWithMemoMap(layer, options.memoMap, scope)
         : Layer.buildWithScope(layer, scope))
-      return handlerCache = toWebHandlerWith<Provided, R>(services)(
-        yield* options.toHandler(services),
+      return handlerCache = toWebHandlerWith<Provided, R>(context)(
+        yield* options.toHandler(context),
         options.middleware
       ) as any
     }))
-    return handlerPromise.then((f) => f(request, services))
+    return handlerPromise.then((f) => f(request, context))
   }
   return { dispose, handler: handler as any } as const
 }
@@ -343,10 +337,10 @@ export const toWebHandlerLayer = <E, R, Provided, LE, ReqR = Exclude<R, Provided
 ): {
   readonly dispose: () => Promise<void>
   readonly handler: [ReqR] extends [never]
-    ? (request: Request, services?: ServiceMap.ServiceMap<never> | undefined) => Promise<globalThis.Response>
+    ? (request: Request, context?: Context.Context<never> | undefined) => Promise<globalThis.Response>
     : (
       request: Request,
-      services: ServiceMap.ServiceMap<ReqR>
+      context: Context.Context<ReqR>
     ) => Promise<globalThis.Response>
 } =>
   toWebHandlerLayerWith(layer, {
@@ -363,10 +357,10 @@ export const fromWebHandler = (
 ): Effect.Effect<HttpServerResponse, HttpServerError, HttpServerRequest> =>
   Effect.callback((resume, signal) => {
     const fiber = Fiber.getCurrent()!
-    const request = ServiceMap.getUnsafe(fiber.services, HttpServerRequest)
+    const request = Context.getUnsafe(fiber.context, HttpServerRequest)
     const requestResult = Request.toWebResult(request, {
       signal,
-      services: fiber.services
+      context: fiber.context
     })
     if (requestResult._tag === "Failure") {
       return resume(Effect.fail(new HttpServerError({ reason: requestResult.failure })))

package/src/unstable/http/HttpIncomingMessage.ts

@@ -1,14 +1,15 @@
 /**
  * @since 4.0.0
  */
+import * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
 import type * as FileSystem from "../../FileSystem.ts"
 import type * as Inspectable from "../../Inspectable.ts"
+import type * as Option from "../../Option.ts"
 import { hasProperty } from "../../Predicate.ts"
 import { redact } from "../../Redactable.ts"
 import * as Schema from "../../Schema.ts"
 import type { ParseOptions } from "../../SchemaAST.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import type * as Stream from "../../Stream.ts"
 import type * as Headers from "./Headers.ts"
 import * as UrlParams from "./UrlParams.ts"
@@ -32,8 +33,8 @@ export const isHttpIncomingMessage = (u: unknown): u is HttpIncomingMessage => h
 export interface HttpIncomingMessage<E = unknown> extends Inspectable.Inspectable {
   readonly [TypeId]: typeof TypeId
   readonly headers: Headers.Headers
-  readonly remoteAddress: string | undefined
-  readonly json: Effect.Effect<unknown, E>
+  readonly remoteAddress: Option.Option<string>
+  readonly json: Effect.Effect<Schema.Json, E>
   readonly text: Effect.Effect<string, E>
   readonly urlParamsBody: Effect.Effect<UrlParams.UrlParams, E>
   readonly arrayBuffer: Effect.Effect<ArrayBuffer, E>
@@ -45,10 +46,11 @@ export interface HttpIncomingMessage<E = unknown> extends Inspectable.Inspectabl
  * @category schema
  */
 export const schemaBodyJson = <S extends Schema.Top>(schema: S, options?: ParseOptions | undefined) => {
-  const decode = Schema.decodeEffect(Schema.toCodecJson(schema).annotate({ options }))
+  const decode = Schema.decodeEffect(Schema.toCodecJson(schema))
   return <E>(
     self: HttpIncomingMessage<E>
-  ): Effect.Effect<S["Type"], E | Schema.SchemaError, S["DecodingServices"]> => Effect.flatMap(self.json, decode)
+  ): Effect.Effect<S["Type"], E | Schema.SchemaError, S["DecodingServices"]> =>
+    Effect.flatMap(self.json, (u) => decode(u, options))
 }
 
 /**
@@ -66,11 +68,10 @@ export const schemaBodyUrlParams = <
 ) => {
   const decode = UrlParams.schemaRecord.pipe(
     Schema.decodeTo(schema),
-    Schema.annotate({ options }),
     Schema.decodeEffect
   )
   return <E>(self: HttpIncomingMessage<E>): Effect.Effect<A, E | Schema.SchemaError, RD> =>
-    Effect.flatMap(self.urlParamsBody, decode)
+    Effect.flatMap(self.urlParamsBody, (u) => decode(u, options))
 }
 
 /**
@@ -89,7 +90,7 @@ export const schemaHeaders = <A, I extends Readonly<Record<string, string | unde
  * @since 4.0.0
  * @category References
  */
-export const MaxBodySize = ServiceMap.Reference<FileSystem.Size | undefined>(
+export const MaxBodySize = Context.Reference<FileSystem.Size | undefined>(
   "effect/http/HttpIncomingMessage/MaxBodySize",
   { defaultValue: () => undefined }
 )

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
 
 /**