@effect/platform 0.48.27 → 0.48.28

package/src/Http/App.ts

@@ -2,16 +2,18 @@
  * @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"
 import * as FiberRef from "effect/FiberRef"
 import { dual } from "effect/Function"
 import { globalValue } from "effect/GlobalValue"
 import * as Layer from "effect/Layer"
-import * as ReadonlyArray from "effect/ReadonlyArray"
+import * as Option from "effect/Option"
 import * as Runtime from "effect/Runtime"
 import * as Scope from "effect/Scope"
 import * as internalMiddleware from "../internal/http/middleware.js"
+import type { Middleware } from "./Middleware.js"
 import * as ServerError from "./ServerError.js"
 import * as ServerRequest from "./ServerRequest.js"
 import * as ServerResponse from "./ServerResponse.js"
@@ -32,9 +34,41 @@ export type Default<R, E> = HttpApp<R, E, ServerResponse.ServerResponse>
  * @since 1.0.0
  * @category combinators
  */
-export const withDefaultMiddleware = <R, E>(
-  self: Default<R, E>
-): Default<R, E> => internalMiddleware.tracer(self)
+export const toHandled = <R, E, _, RH>(
+  self: Default<R, E>,
+  handleResponse: (
+    request: ServerRequest.ServerRequest,
+    exit: Exit.Exit<ServerResponse.ServerResponse, E | ServerError.ResponseError>
+  ) => Effect.Effect<_, never, RH>,
+  middleware?: Middleware | undefined
+): Default<Exclude<R | RH, Scope.Scope>, E | ServerError.ResponseError> =>
+  Effect.uninterruptibleMask((restore) => {
+    const withTracer = internalMiddleware.tracer(restore(self))
+    const responded = Effect.withFiberRuntime<
+      ServerResponse.ServerResponse,
+      E | ServerError.ResponseError,
+      R | RH | ServerRequest.ServerRequest
+    >((fiber) => {
+      const request = Context.unsafeGet(fiber.getFiberRef(FiberRef.currentContext), ServerRequest.ServerRequest)
+      const handler = fiber.getFiberRef(currentPreResponseHandlers)
+      const preHandled = handler._tag === "Some"
+        ? Effect.flatMap(withTracer, (response) => handler.value(request, response))
+        : withTracer
+      return Effect.flatMap(
+        Effect.exit(preHandled),
+        (exit) => {
+          if (exit._tag === "Failure") {
+            const dieOption = Cause.dieOption(exit.cause)
+            if (dieOption._tag === "Some" && ServerResponse.isServerResponse(dieOption.value)) {
+              exit = Exit.succeed(dieOption.value)
+            }
+          }
+          return Effect.zipRight(handleResponse(request, exit), exit)
+        }
+      )
+    })
+    return Effect.scoped(middleware === undefined ? responded : middleware(responded))
+  })
 
 /**
  * @since 1.0.0
@@ -49,32 +83,9 @@ export type PreResponseHandler = (
  * @since 1.0.0
  * @category fiber refs
  */
-export const currentPreResponseHandlers: FiberRef.FiberRef<ReadonlyArray<PreResponseHandler>> = globalValue(
+export const currentPreResponseHandlers: FiberRef.FiberRef<Option.Option<PreResponseHandler>> = globalValue(
   Symbol.for("@effect/platform/Http/App/preResponseHandlers"),
-  () => FiberRef.unsafeMake<ReadonlyArray<PreResponseHandler>>([])
-)
-
-function noopHandler(_request: ServerRequest.ServerRequest, response: ServerResponse.ServerResponse) {
-  return Effect.succeed(response)
-}
-
-/**
- * @since 1.0.0
- * @category fiber refs
- */
-export const preResponseHandler: Effect.Effect<PreResponseHandler> = Effect.map(
-  FiberRef.get(currentPreResponseHandlers),
-  (handlers): PreResponseHandler =>
-    handlers.length === 0 ?
-      noopHandler :
-      handlers.reduce((acc, handler) => (function(request, response) {
-        return Effect.flatMap(
-          acc(request, response),
-          function(response) {
-            return handler(request, response)
-          }
-        )
-      }))
+  () => FiberRef.unsafeMake<Option.Option<PreResponseHandler>>(Option.none())
 )
 
 /**
@@ -86,7 +97,13 @@ export const appendPreResponseHandler: (handler: PreResponseHandler) => Effect.E
 ) =>
   FiberRef.update(
     currentPreResponseHandlers,
-    ReadonlyArray.append(handler)
+    Option.match({
+      onNone: () => Option.some(handler),
+      onSome: (prev) =>
+        Option.some((request, response) =>
+          Effect.flatMap(prev(request, response), (response) => handler(request, response))
+        )
+    })
   )
 
 /**
@@ -100,7 +117,13 @@ export const withPreResponseHandler = dual<
   Effect.locallyWith(
     self,
     currentPreResponseHandlers,
-    ReadonlyArray.append(handler)
+    Option.match({
+      onNone: () => Option.some(handler),
+      onSome: (prev) =>
+        Option.some((request, response) =>
+          Effect.flatMap(prev(request, response), (response) => handler(request, response))
+        )
+    })
   ))
 
 /**
@@ -110,25 +133,27 @@ export const withPreResponseHandler = dual<
 export const toWebHandlerRuntime = <R>(runtime: Runtime.Runtime<R>) => {
   const run = Runtime.runFork(runtime)
   return <E>(self: Default<R | Scope.Scope, E>) => {
-    self = withDefaultMiddleware(self)
+    const handled = Effect.scoped(toHandled(self, (request, exit) => {
+      const webRequest = request.source as Request
+      if (Exit.isSuccess(exit)) {
+        ;(request as any)._resolve(ServerResponse.toWeb(exit.value, request.method === "HEAD"))
+      } else if (Cause.isInterruptedOnly(exit.cause)) {
+        ;(request as any)._resolve(new Response(null, { status: webRequest.signal.aborted ? 499 : 503 }))
+      } else {
+        ;(request as any)._reject(Cause.pretty(exit.cause))
+      }
+      return Effect.unit
+    }))
     return (request: Request): Promise<Response> =>
       new Promise((resolve, reject) => {
         const req = ServerRequest.fromWeb(request)
-        const fiber = run(Effect.scoped(Effect.map(
-          Effect.provideService(self, ServerRequest.ServerRequest, req),
-          (res) => ServerResponse.toWeb(res, req.method === "HEAD")
-        )))
+        ;(req as any)._resolve = resolve
+        ;(req as any)._reject = reject
+        const fiber = run(
+          Effect.provideService(handled, ServerRequest.ServerRequest, req)
+        )
         request.signal.addEventListener("abort", () => {
-          Effect.runFork(fiber.interruptAsFork(ServerError.clientAbortFiberId))
-        })
-        fiber.addObserver((exit) => {
-          if (Exit.isSuccess(exit)) {
-            resolve(exit.value)
-          } else if (Cause.isInterruptedOnly(exit.cause)) {
-            resolve(new Response(null, { status: request.signal.aborted ? 499 : 503 }))
-          } else {
-            reject(Cause.pretty(exit.cause))
-          }
+          fiber.unsafeInterruptAsFork(ServerError.clientAbortFiberId)
         })
       })
   }

package/src/Http/Headers.ts

@@ -52,10 +52,9 @@ export const schemaFromSelf: Schema.Schema<Headers> = Schema.declare(isHeaders,
  */
 export const schema: Schema.Schema<Headers, ReadonlyRecord.ReadonlyRecord<string, string | ReadonlyArray<string>>> =
   Schema.transform(
-    Schema.record(Schema.string, Schema.union(Schema.string, Schema.array(Schema.string))),
+    Schema.Record(Schema.String, Schema.Union(Schema.String, Schema.Array(Schema.String))),
     schemaFromSelf,
-    (record) => fromInput(record),
-    identity
+    { decode: (record) => fromInput(record), encode: identity }
   )
 
 /**

package/src/Http/Router.ts

@@ -622,3 +622,10 @@ export const provideServiceEffect: {
     E | E1
   >
 } = internal.provideServiceEffect
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const uninterruptible: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R> =
+  internal.uninterruptible

package/src/Http/UrlParams.ts

@@ -36,8 +36,8 @@ export const fromInput = (input: Input): UrlParams => {
  * @since 1.0.0
  * @category schemas
  */
-export const schema: Schema.Schema<UrlParams, ReadonlyArray<readonly [string, string]>> = Schema.array(
-  Schema.tuple(Schema.string, Schema.string)
+export const schema: Schema.Schema<UrlParams, ReadonlyArray<readonly [string, string]>> = Schema.Array(
+  Schema.Tuple(Schema.String, Schema.String)
 ).pipe(
   Schema.identifier("UrlParams")
 )

package/src/Transferable.ts

@@ -93,8 +93,7 @@ export const schema: {
   Schema.transformOrFail(
     Schema.encodedSchema(self),
     self,
-    ParseResult.succeed,
-    (i) => Effect.as(addAll(f(i)), i)
+    { decode: ParseResult.succeed, encode: (i) => Effect.as(addAll(f(i)), i) }
   ))
 
 /**
@@ -102,7 +101,7 @@ export const schema: {
  * @category schema
  */
 export const ImageData: Schema.Schema<ImageData> = schema(
-  Schema.any,
+  Schema.Any,
   (_) => [(_ as ImageData).data.buffer]
 )
 
@@ -111,7 +110,7 @@ export const ImageData: Schema.Schema<ImageData> = schema(
  * @category schema
  */
 export const MessagePort: Schema.Schema<MessagePort> = schema(
-  Schema.any,
+  Schema.Any,
   (_) => [_ as MessagePort]
 )
 

package/src/WorkerError.ts

@@ -26,14 +26,16 @@ export type WorkerErrorTypeId = typeof WorkerErrorTypeId
 export const isWorkerError = (u: unknown): u is WorkerError => Predicate.hasProperty(u, WorkerErrorTypeId)
 
 const causeDefectPretty: Schema.Schema<unknown> = Schema.transform(
-  Schema.unknown,
-  Schema.unknown,
-  identity,
-  (defect) => {
-    if (Predicate.isObject(defect)) {
-      return Cause.pretty(Cause.die(defect))
+  Schema.Unknown,
+  Schema.Unknown,
+  {
+    decode: identity,
+    encode: (defect) => {
+      if (Predicate.isObject(defect)) {
+        return Cause.pretty(Cause.die(defect))
+      }
+      return String(defect)
     }
-    return String(defect)
   }
 )
 
@@ -42,7 +44,7 @@ const causeDefectPretty: Schema.Schema<unknown> = Schema.transform(
  * @category errors
  */
 export class WorkerError extends Schema.TaggedError<WorkerError>()("WorkerError", {
-  reason: Schema.literal("spawn", "decode", "send", "unknown", "encode"),
+  reason: Schema.Literal("spawn", "decode", "send", "unknown", "encode"),
   error: causeDefectPretty
 }) {
   /**
@@ -56,7 +58,7 @@ export class WorkerError extends Schema.TaggedError<WorkerError>()("WorkerError"
   static readonly Cause: Schema.Schema<
     Cause.Cause<WorkerError>,
     Schema.CauseEncoded<WorkerErrorFrom>
-  > = Schema.cause({ defect: causeDefectPretty, error: this })
+  > = Schema.Cause({ defect: causeDefectPretty, error: this })
 
   /**
    * @since 1.0.0

package/src/internal/http/middleware.ts

@@ -78,18 +78,18 @@ export const logger = make((httpApp) => {
 })
 
 /** @internal */
-export const tracer = make((httpApp) => {
-  const appWithStatus = Effect.tap(
-    httpApp,
-    (response) => Effect.annotateCurrentSpan("http.status", response.status)
-  )
-  return Effect.withFiberRuntime((fiber) => {
+export const tracer = make((httpApp) =>
+  Effect.withFiberRuntime((fiber) => {
     const context = fiber.getFiberRef(FiberRef.currentContext)
     const request = Context.unsafeGet(context, ServerRequest.ServerRequest)
     const disabled = fiber.getFiberRef(currentTracerDisabledWhen)(request)
     if (disabled) {
       return httpApp
     }
+    const appWithStatus = Effect.tap(
+      httpApp,
+      (response) => Effect.annotateCurrentSpan("http.status", response.status)
+    )
     return Effect.withSpan(
       appWithStatus,
       `http.server ${request.method}`,
@@ -99,7 +99,7 @@ export const tracer = make((httpApp) => {
       }
     )
   })
-})
+)
 
 /** @internal */
 export const xForwardedHeaders = make((httpApp) =>

package/src/internal/http/multipart.ts

@@ -105,7 +105,7 @@ const fileSchema: Schema.Schema<Multipart.PersistedFile> = Schema.declare(isPers
 })
 
 /** @internal */
-export const filesSchema: Schema.Schema<ReadonlyArray<Multipart.PersistedFile>> = Schema.array(fileSchema)
+export const filesSchema: Schema.Schema<ReadonlyArray<Multipart.PersistedFile>> = Schema.Array(fileSchema)
 
 /** @internal */
 export const schemaPersisted = <R, I extends Partial<Multipart.Persisted>, A>(
@@ -140,7 +140,7 @@ export const schemaJson = <A, I, R>(schema: Schema.Schema<A, I, R>, options?: Pa
   >(2, (persisted, field) =>
     Effect.map(
       Schema.decodeUnknown(
-        Schema.struct({
+        Schema.Struct({
           [field]: fromJson
         }),
         options

package/src/internal/http/router.ts

@@ -5,6 +5,7 @@ import * as Chunk from "effect/Chunk"
 import * as Context from "effect/Context"
 import * as Effect from "effect/Effect"
 import * as Effectable from "effect/Effectable"
+import * as FiberRef from "effect/FiberRef"
 import { dual } from "effect/Function"
 import * as Inspectable from "effect/Inspectable"
 import * as Option from "effect/Option"
@@ -202,50 +203,48 @@ const toHttpApp = <R, E>(
       router.on(route.method, route.path, route)
     }
   })
-  return Effect.flatMap(
-    ServerRequest.ServerRequest,
-    (request): App.Default<R, E | Error.RouteNotFound> => {
-      if (mountsLen > 0) {
-        for (let i = 0; i < mountsLen; i++) {
-          const [path, context, options] = mounts[i]
-          if (request.url.startsWith(path)) {
-            return Effect.provideService(
-              Effect.provideService(
-                context.route.handler as App.Default<R, E>,
-                RouteContext,
-                context
-              ),
-              ServerRequest.ServerRequest,
-              options?.includePrefix ?
-                request :
-                sliceRequestUrl(request, path)
-            )
+  return Effect.withFiberRuntime<
+    ServerResponse.ServerResponse,
+    E | Error.RouteNotFound,
+    R | ServerRequest.ServerRequest
+  >((fiber) => {
+    let context = fiber.getFiberRef(FiberRef.currentContext)
+    const request = Context.unsafeGet(context, ServerRequest.ServerRequest)
+    if (mountsLen > 0) {
+      for (let i = 0; i < mountsLen; i++) {
+        const [path, routeContext, options] = mounts[i]
+        if (request.url.startsWith(path)) {
+          context = Context.add(context, RouteContext, routeContext)
+          if (options?.includePrefix !== true) {
+            context = Context.add(context, ServerRequest.ServerRequest, sliceRequestUrl(request, path))
           }
+          return Effect.locally(
+            routeContext.route.handler as App.Default<R, E>,
+            FiberRef.currentContext,
+            context
+          )
         }
       }
+    }
 
-      let result = router.find(request.method, request.url)
-      if (result === undefined && request.method === "HEAD") {
-        result = router.find("GET", request.url)
-      }
-      if (result === undefined) {
-        return Effect.fail(new Error.RouteNotFound({ request }))
-      }
-      const route = result.handler
-      if (route.prefix._tag === "Some") {
-        request = sliceRequestUrl(request, route.prefix.value)
-      }
-      return Effect.mapInputContext(
-        route.handler as Effect.Effect<ServerResponse.ServerResponse, E, Router.Router.ExcludeProvided<R>>,
-        (context) =>
-          Context.add(
-            Context.add(context, ServerRequest.ServerRequest, request),
-            RouteContext,
-            new RouteContextImpl(route, result!.params, result!.searchParams)
-          ) as Context.Context<R>
-      )
+    let result = router.find(request.method, request.url)
+    if (result === undefined && request.method === "HEAD") {
+      result = router.find("GET", request.url)
     }
-  )
+    if (result === undefined) {
+      return Effect.fail(new Error.RouteNotFound({ request }))
+    }
+    const route = result.handler
+    if (route.prefix._tag === "Some") {
+      context = Context.add(context, ServerRequest.ServerRequest, sliceRequestUrl(request, route.prefix.value))
+    }
+    context = Context.add(context, RouteContext, new RouteContextImpl(route, result.params, result.searchParams))
+    return Effect.locally(
+      route.handler as Effect.Effect<ServerResponse.ServerResponse, E, Router.Router.ExcludeProvided<R>>,
+      FiberRef.currentContext,
+      context
+    )
+  })
 }
 
 function sliceRequestUrl(request: ServerRequest.ServerRequest, prefix: string) {
@@ -600,3 +599,10 @@ export const provideServiceEffect = dual<
   >,
   E | E1
 > => use(self, Effect.provideServiceEffect(tag, effect)) as any)
+
+/* @internal */
+export const uninterruptible = <A, E, R>(effect: Effect.Effect<A, E, R>) =>
+  Effect.uninterruptible(Effect.flatMap(
+    effect,
+    Effect.die
+  ))