@effect/platform 0.87.12 → 0.88.0

package/src/HttpApp.ts

@@ -5,13 +5,14 @@ import * as Context from "effect/Context"
 import * as Effect from "effect/Effect"
 import * as Exit from "effect/Exit"
 import * as Fiber from "effect/Fiber"
-import * as FiberRef from "effect/FiberRef"
+import type * as FiberRef from "effect/FiberRef"
 import * as GlobalValue from "effect/GlobalValue"
 import * as Layer from "effect/Layer"
 import * as Option from "effect/Option"
 import * as Runtime from "effect/Runtime"
 import * as Scope from "effect/Scope"
 import * as Stream from "effect/Stream"
+import type * as Types from "effect/Types"
 import { unify } from "effect/Unify"
 import * as HttpBody from "./HttpBody.js"
 import type { HttpMiddleware } from "./HttpMiddleware.js"
@@ -204,7 +205,8 @@ export const withPreResponseHandler = internal.withPreResponseHandler
  * @category conversions
  */
 export const toWebHandlerRuntime = <R>(runtime: Runtime.Runtime<R>) => {
-  const run = Runtime.runFork(runtime)
+  const httpRuntime: Types.Mutable<Runtime.Runtime<R>> = Runtime.make(runtime)
+  const run = Runtime.runFork(httpRuntime)
   return <E>(self: Default<E, R | Scope.Scope>, middleware?: HttpMiddleware | undefined) => {
     const resolveSymbol = Symbol.for("@effect/platform/HttpApp/resolve")
     const httpApp = toHandled(self, (request, response) => {
@@ -225,7 +227,8 @@ export const toWebHandlerRuntime = <R>(runtime: Runtime.Runtime<R>) => {
         const httpServerRequest = ServerRequest.fromWeb(request)
         contextMap.set(ServerRequest.HttpServerRequest.key, httpServerRequest)
         ;(httpServerRequest as any)[resolveSymbol] = resolve
-        const fiber = run(Effect.locally(httpApp as any, FiberRef.currentContext, Context.unsafeMake(contextMap)))
+        httpRuntime.context = Context.unsafeMake(contextMap)
+        const fiber = run(httpApp as any)
         request.signal?.addEventListener("abort", () => {
           fiber.unsafeInterruptAsFork(ServerError.clientAbortFiberId)
         }, { once: true })
@@ -248,19 +251,66 @@ export const toWebHandler: <E>(
  * @since 1.0.0
  * @category conversions
  */
-export const toWebHandlerLayer = <E, R, RE>(
-  self: Default<E, R | Scope.Scope>,
+export const toWebHandlerLayerWith = <E, R, RE, EX>(
   layer: Layer.Layer<R, RE>,
-  middleware?: HttpMiddleware | undefined
+  options: {
+    readonly toHandler: (
+      runtime: Runtime.Runtime<R>
+    ) => Effect.Effect<
+      Effect.Effect<ServerResponse.HttpServerResponse, E, R | Scope.Scope | ServerRequest.HttpServerRequest>,
+      EX
+    >
+    readonly middleware?: HttpMiddleware | undefined
+    readonly memoMap?: Layer.MemoMap | undefined
+  }
 ): {
-  readonly close: () => Promise<void>
+  readonly dispose: () => Promise<void>
   readonly handler: (request: Request, context?: Context.Context<never> | undefined) => Promise<Response>
 } => {
   const scope = Effect.runSync(Scope.make())
-  const close = () => Effect.runPromise(Scope.close(scope, Exit.void))
-  const build = Effect.map(Layer.toRuntime(layer), (_) => toWebHandlerRuntime(_)(self, middleware))
-  const runner = Effect.runPromise(Scope.extend(build, scope))
-  const handler = (request: Request, context?: Context.Context<never> | undefined): Promise<Response> =>
-    runner.then((handler) => handler(request, context))
-  return { close, handler } as const
+  const dispose = () => Effect.runPromise(Scope.close(scope, Exit.void))
+
+  let handlerCache: ((request: Request, context?: Context.Context<never> | undefined) => Promise<Response>) | undefined
+  let handlerPromise:
+    | Promise<(request: Request, context?: Context.Context<never> | undefined) => Promise<Response>>
+    | undefined
+  function handler(request: Request, context?: Context.Context<never> | undefined): Promise<Response> {
+    if (handlerCache) {
+      return handlerCache(request, context)
+    }
+    handlerPromise ??= Effect.gen(function*() {
+      const runtime = yield* (options.memoMap
+        ? Layer.toRuntimeWithMemoMap(layer, options.memoMap)
+        : Layer.toRuntime(layer))
+      return handlerCache = toWebHandlerRuntime(runtime)(
+        yield* options.toHandler(runtime),
+        options.middleware
+      )
+    }).pipe(
+      Scope.extend(scope),
+      Effect.runPromise
+    )
+    return handlerPromise.then((f) => f(request, context))
+  }
+  return { dispose, handler } as const
 }
+
+/**
+ * @since 1.0.0
+ * @category conversions
+ */
+export const toWebHandlerLayer = <E, R, RE>(
+  self: Default<E, R | Scope.Scope>,
+  layer: Layer.Layer<R, RE>,
+  options?: {
+    readonly memoMap?: Layer.MemoMap | undefined
+    readonly middleware?: HttpMiddleware | undefined
+  }
+): {
+  readonly dispose: () => Promise<void>
+  readonly handler: (request: Request, context?: Context.Context<never> | undefined) => Promise<Response>
+} =>
+  toWebHandlerLayerWith(layer, {
+    ...options,
+    toHandler: () => Effect.succeed(self)
+  })

package/src/HttpLayerRouter.ts

@@ -9,7 +9,6 @@ import * as Effect from "effect/Effect"
 import * as FiberRef from "effect/FiberRef"
 import { compose, constant, dual, identity } from "effect/Function"
 import * as Layer from "effect/Layer"
-import * as ManagedRuntime from "effect/ManagedRuntime"
 import * as Option from "effect/Option"
 import * as Scope from "effect/Scope"
 import * as Tracer from "effect/Tracer"
@@ -1165,29 +1164,15 @@ export const toWebHandler = <
   if (options?.disableLogger !== true) {
     middleware = middleware ? compose(middleware, HttpMiddleware.logger) : HttpMiddleware.logger
   }
-  const RouterLayer = options?.routerConfig
-    ? Layer.provide(layer, Layer.succeed(RouterConfig, options.routerConfig))
-    : layer
-  const runtime = ManagedRuntime.make(
-    Layer.provideMerge(appLayer, RouterLayer) as any,
-    options?.memoMap
-  )
-  let handlerCached:
-    | ((request: globalThis.Request, context?: Context.Context<never> | undefined) => Promise<Response>)
-    | undefined
-  const handlerPromise = Effect.gen(function*() {
-    const router = yield* HttpRouter
-    const effect = router.asHttpEffect()
-    const rt = yield* runtime.runtimeEffect
-    const handler = HttpApp.toWebHandlerRuntime(rt)(effect, middleware)
-    handlerCached = handler
-    return handler
-  }).pipe(runtime.runPromise)
-  function handler(request: globalThis.Request, context?: Context.Context<never> | undefined): Promise<Response> {
-    if (handlerCached !== undefined) {
-      return handlerCached(request, context)
-    }
-    return handlerPromise.then((handler) => handler(request, context))
-  }
-  return { handler, dispose: runtime.dispose } as const
+  const RouterLayer: Layer.Layer<HttpRouter | A, E> = Layer.provideMerge(
+    appLayer,
+    options?.routerConfig
+      ? Layer.provide(layer, Layer.succeed(RouterConfig, options.routerConfig))
+      : layer
+  ) as any
+  return HttpApp.toWebHandlerLayerWith(RouterLayer, {
+    toHandler: (r) => Effect.succeed(Context.get(r.context, HttpRouter).asHttpEffect()),
+    middleware,
+    memoMap: options?.memoMap
+  })
 }