@effect/platform 0.37.7 → 0.37.8

package/src/Http/Server.ts

@@ -104,17 +104,25 @@ export const make: (
  * @category accessors
  */
 export const serve: {
-  (): <R, E>(httpApp: App.Default<R, E>) => Layer.Layer<Server | Exclude<R, ServerRequest.ServerRequest>, never, never>
+  (): <R, E>(
+    httpApp: App.Default<R, E>
+  ) => Layer.Layer<Server | Exclude<R, ServerRequest.ServerRequest | Scope.Scope>, never, never>
   <R, E, App extends App.Default<any, any>>(
     middleware: Middleware.Middleware.Applied<R, E, App>
   ): (
     httpApp: App.Default<R, E>
-  ) => Layer.Layer<Server | Exclude<Effect.Effect.Context<App>, ServerRequest.ServerRequest>, never, never>
-  <R, E>(httpApp: App.Default<R, E>): Layer.Layer<Server | Exclude<R, ServerRequest.ServerRequest>, never, never>
+  ) => Layer.Layer<
+    Server | Exclude<Effect.Effect.Context<App>, ServerRequest.ServerRequest | Scope.Scope>,
+    never,
+    never
+  >
+  <R, E>(
+    httpApp: App.Default<R, E>
+  ): Layer.Layer<Server | Exclude<R, ServerRequest.ServerRequest | Scope.Scope>, never, never>
   <R, E, App extends App.Default<any, any>>(
     httpApp: App.Default<R, E>,
     middleware: Middleware.Middleware.Applied<R, E, App>
-  ): Layer.Layer<Server | Exclude<Effect.Effect.Context<App>, ServerRequest.ServerRequest>, never, never>
+  ): Layer.Layer<Server | Exclude<Effect.Effect.Context<App>, ServerRequest.ServerRequest | Scope.Scope>, never, never>
 } = internal.serve
 
 /**

package/src/Http/ServerError.ts

@@ -1,7 +1,9 @@
 /**
  * @since 1.0.0
  */
+import type * as Cause from "effect/Cause"
 import type * as Data from "effect/Data"
+import type * as FiberId from "effect/FiberId"
 import * as internal from "../internal/http/serverError.js"
 import type * as ServerRequest from "./ServerRequest.js"
 import type * as ServerResponse from "./ServerResponse.js"
@@ -54,6 +56,12 @@ export interface RequestError extends HttpError.Proto {
   readonly error: unknown
 }
 
+/**
+ * @since 1.0.0
+ * @category predicates
+ */
+export const isServerError: (u: unknown) => u is HttpServerError = internal.isServerError
+
 /**
  * @since 1.0.0
  * @category error
@@ -109,3 +117,13 @@ export interface ServeError extends HttpError.Proto {
  * @category error
  */
 export const ServeError: (props: Omit<ServeError, HttpError.ProvidedFields>) => ServeError = internal.serveError
+
+/**
+ * @since 1.0.0
+ */
+export const clientAbortFiberId: FiberId.FiberId = internal.clientAbortFiberId
+
+/**
+ * @since 1.0.0
+ */
+export const isClientAbortCause: <E>(cause: Cause.Cause<E>) => boolean = internal.isClientAbortCause

package/src/Http/ServerRequest.ts

@@ -42,6 +42,7 @@ export type TypeId = typeof TypeId
  */
 export interface ServerRequest extends IncomingMessage.IncomingMessage<Error.RequestError> {
   readonly [TypeId]: TypeId
+  readonly source: unknown
   readonly url: string
   readonly originalUrl: string
   readonly method: Method

package/src/internal/http/middleware.ts

@@ -1,12 +1,13 @@
 import * as Cause from "effect/Cause"
 import * as Effect from "effect/Effect"
 import * as FiberRef from "effect/FiberRef"
-import * as Function from "effect/Function"
+import { constFalse, dual } from "effect/Function"
 import { globalValue } from "effect/GlobalValue"
 import type * as Predicate from "effect/Predicate"
 import * as Headers from "../../Http/Headers.js"
 import * as IncomingMessage from "../../Http/IncomingMessage.js"
 import type * as Middleware from "../../Http/Middleware.js"
+import * as ServerError from "../../Http/ServerError.js"
 import * as ServerRequest from "../../Http/ServerRequest.js"
 
 /** @internal */
@@ -28,11 +29,11 @@ export const withLoggerDisabled = <R, E, A>(self: Effect.Effect<R, E, A>): Effec
 /** @internal */
 export const currentTracerDisabledWhen = globalValue(
   Symbol.for("@effect/platform/Http/Middleware/tracerDisabledWhen"),
-  () => FiberRef.unsafeMake<Predicate.Predicate<ServerRequest.ServerRequest>>(Function.constFalse)
+  () => FiberRef.unsafeMake<Predicate.Predicate<ServerRequest.ServerRequest>>(constFalse)
 )
 
 /** @internal */
-export const withTracerDisabledWhen = Function.dual<
+export const withTracerDisabledWhen = dual<
   (
     predicate: Predicate.Predicate<ServerRequest.ServerRequest>
   ) => <R, E, A>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>,
@@ -60,7 +61,11 @@ export const logger = make((httpApp) => {
                 Effect.annotateLogs(Effect.log(exit.cause), {
                   "http.method": request.method,
                   "http.url": request.url,
-                  "http.status": Cause.isInterruptedOnly(exit.cause) ? 499 : 500
+                  "http.status": Cause.isInterruptedOnly(exit.cause)
+                    ? ServerError.isClientAbortCause(exit.cause)
+                      ? 499
+                      : 503
+                    : 500
                 }) :
                 Effect.annotateLogs(Effect.log(""), {
                   "http.method": request.method,

package/src/internal/http/router.ts

@@ -185,7 +185,7 @@ export const makeRoute = <R, E>(
   path: Router.PathInput,
   handler: Router.Route.Handler<R, E>,
   prefix: Option.Option<string> = Option.none()
-): Router.Route<R, E> => new RouteImpl(method, path, handler, prefix)
+): Router.Route<Router.Router.ExcludeProvided<R>, E> => new RouteImpl(method, path, handler, prefix) as any
 
 /** @internal */
 export const concat = dual<

package/src/internal/http/server.ts

@@ -38,14 +38,14 @@ export const serve = dual<
     (): <R, E>(
       httpApp: App.Default<R, E>
     ) => Layer.Layer<
-      Server.Server | Exclude<R, ServerRequest.ServerRequest>,
+      Server.Server | Exclude<R, ServerRequest.ServerRequest | Scope.Scope>,
       never,
       never
     >
     <R, E, App extends App.Default<any, any>>(middleware: Middleware.Middleware.Applied<R, E, App>): (
       httpApp: App.Default<R, E>
     ) => Layer.Layer<
-      Server.Server | Exclude<Effect.Effect.Context<App>, ServerRequest.ServerRequest>,
+      Server.Server | Exclude<Effect.Effect.Context<App>, ServerRequest.ServerRequest | Scope.Scope>,
       never,
       never
     >
@@ -53,12 +53,12 @@ export const serve = dual<
   {
     <R, E>(
       httpApp: App.Default<R, E>
-    ): Layer.Layer<Server.Server | Exclude<R, ServerRequest.ServerRequest>, never, never>
+    ): Layer.Layer<Server.Server | Exclude<R, ServerRequest.ServerRequest | Scope.Scope>, never, never>
     <R, E, App extends App.Default<any, any>>(
       httpApp: App.Default<R, E>,
       middleware: Middleware.Middleware.Applied<R, E, App>
     ): Layer.Layer<
-      Server.Server | Exclude<Effect.Effect.Context<App>, ServerRequest.ServerRequest>,
+      Server.Server | Exclude<Effect.Effect.Context<App>, ServerRequest.ServerRequest | Scope.Scope>,
       never,
       never
     >
@@ -69,7 +69,7 @@ export const serve = dual<
     httpApp: App.Default<R, E>,
     middleware?: Middleware.Middleware.Applied<R, E, App>
   ): Layer.Layer<
-    Server.Server | Exclude<Effect.Effect.Context<App>, ServerRequest.ServerRequest>,
+    Server.Server | Exclude<Effect.Effect.Context<App>, ServerRequest.ServerRequest | Scope.Scope>,
     never,
     never
   > =>

package/src/internal/http/serverError.ts

@@ -1,4 +1,9 @@
+import * as Cause from "effect/Cause"
 import * as Data from "effect/Data"
+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 "../../Http/ServerError.js"
 
 /** @internal */
@@ -13,6 +18,9 @@ const make = <A extends Error.HttpServerError>(tag: A["_tag"]) => (props: Omit<A
     ...props
   } as A)
 
+/** @internal */
+export const isServerError = (u: unknown): u is Error.HttpServerError => Predicate.hasProperty(u, TypeId)
+
 /** @internal */
 export const requestError = make<Error.RequestError>("RequestError")
 
@@ -24,3 +32,17 @@ export const routeNotFound = make<Error.RouteNotFound>("RouteNotFound")
 
 /** @internal */
 export const serveError = make<Error.ServeError>("ServeError")
+
+/** @internal */
+export const clientAbortFiberId = globalValue(
+  "@effect/platform/Http/ServerError/clientAbortFiberId",
+  () => FiberId.runtime(-499, 0)
+)
+
+/** @internal */
+export const isClientAbortCause = <E>(cause: Cause.Cause<E>): boolean =>
+  Cause.reduce(
+    cause,
+    false,
+    (_, cause) => cause._tag === "Interrupt" && cause.fiberId === clientAbortFiberId ? Option.some(true) : Option.none()
+  )