@effect/platform 0.48.27 → 0.48.29

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"
@@ -186,7 +187,8 @@ const toHttpApp = <R, E>(
           "*",
           options?.includePrefix ? `${path}/*` as Router.PathInput : "/*",
           app,
-          options?.includePrefix ? Option.none() : Option.some(path)
+          options?.includePrefix ? Option.none() : Option.some(path),
+          false
         ),
         {},
         {}
@@ -202,50 +204,54 @@ 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.uninterruptible ?
+        route.handler :
+        Effect.interruptible(route.handler)) as Effect.Effect<
+          ServerResponse.ServerResponse,
+          E,
+          Router.Router.ExcludeProvided<R>
+        >,
+      FiberRef.currentContext,
+      context
+    )
+  })
 }
 
 function sliceRequestUrl(request: ServerRequest.ServerRequest, prefix: string) {
@@ -259,7 +265,8 @@ class RouteImpl<R, E> extends Inspectable.Class implements Router.Route<R, E> {
     readonly method: Method.Method | "*",
     readonly path: Router.PathInput,
     readonly handler: Router.Route.Handler<R, E>,
-    readonly prefix = Option.none<string>()
+    readonly prefix = Option.none<string>(),
+    readonly uninterruptible = false
   ) {
     super()
     this[RouteTypeId] = RouteTypeId
@@ -301,8 +308,10 @@ export const makeRoute = <R, E>(
   method: Method.Method,
   path: Router.PathInput,
   handler: Router.Route.Handler<R, E>,
-  prefix: Option.Option<string> = Option.none()
-): Router.Route<Router.Router.ExcludeProvided<R>, E> => new RouteImpl(method, path, handler, prefix) as any
+  prefix: Option.Option<string> = Option.none(),
+  uninterruptible = false
+): Router.Route<Router.Router.ExcludeProvided<R>, E> =>
+  new RouteImpl(method, path, handler, prefix, uninterruptible) as any
 
 /** @internal */
 export const concat = dual<
@@ -331,7 +340,8 @@ export const prefixAll = dual<
           Option.orElse(
             Option.map(route.prefix, (_) => prefix + _),
             () => Option.some(prefix)
-          )
+          ),
+          route.uninterruptible
         )),
       Chunk.map(self.mounts, ([path, app]) => [path === "/" ? prefix : prefix + path, app])
     )
@@ -390,14 +400,20 @@ export const mountApp = dual<
 export const route = (method: Method.Method | "*"): {
   <R1, E1>(
     path: Router.PathInput,
-    handler: Router.Route.Handler<R1, E1>
+    handler: Router.Route.Handler<R1, E1>,
+    options?: {
+      readonly uninterruptible?: boolean | undefined
+    } | undefined
   ): <R, E>(
     self: Router.Router<R, E>
   ) => Router.Router<R | Router.Router.ExcludeProvided<R1>, E1 | E>
   <R, E, R1, E1>(
     self: Router.Router<R, E>,
     path: Router.PathInput,
-    handler: Router.Route.Handler<R1, E1>
+    handler: Router.Route.Handler<R1, E1>,
+    options?: {
+      readonly uninterruptible?: boolean | undefined
+    } | undefined
   ): Router.Router<R | Router.Router.ExcludeProvided<R1>, E1 | E>
 } =>
   dual<
@@ -410,11 +426,14 @@ export const route = (method: Method.Method | "*"): {
     <R, E, R1, E1>(
       self: Router.Router<R, E>,
       path: Router.PathInput,
-      handler: Router.Route.Handler<R1, E1>
+      handler: Router.Route.Handler<R1, E1>,
+      options?: {
+        readonly uninterruptible?: boolean | undefined
+      } | undefined
     ) => Router.Router<R | Router.Router.ExcludeProvided<R1>, E | E1>
-  >(3, (self, path, handler) =>
+  >((args) => Predicate.hasProperty(args[0], TypeId), (self, path, handler, options) =>
     new RouterImpl<any, any>(
-      Chunk.append(self.routes, new RouteImpl(method, path, handler)),
+      Chunk.append(self.routes, new RouteImpl(method, path, handler, Option.none(), options?.uninterruptible ?? false)),
       self.mounts
     ))
 
@@ -455,7 +474,7 @@ export const use = dual<
   new RouterImpl<any, any>(
     Chunk.map(
       self.routes,
-      (route) => new RouteImpl(route.method, route.path, f(route.handler) as any, route.prefix)
+      (route) => new RouteImpl(route.method, route.path, f(route.handler) as any, route.prefix, route.uninterruptible)
     ),
     Chunk.map(
       self.mounts,