@effect/platform 0.69.14 → 0.69.16

package/src/HttpApiBuilder.ts

@@ -5,7 +5,7 @@ import * as Chunk from "effect/Chunk"
 import * as Context from "effect/Context"
 import * as Effect from "effect/Effect"
 import * as Encoding from "effect/Encoding"
-import * as FiberRef from "effect/FiberRef"
+import * as Fiber from "effect/Fiber"
 import { identity } from "effect/Function"
 import { globalValue } from "effect/GlobalValue"
 import * as HashMap from "effect/HashMap"
@@ -163,17 +163,13 @@ export const toWebHandler = <LA, LE>(
     options?.memoMap
   )
   let handlerCached: ((request: Request) => Promise<Response>) | undefined
-  const handlerPromise = httpApp.pipe(
-    Effect.bindTo("httpApp"),
-    Effect.bind("runtime", () => runtime.runtimeEffect),
-    Effect.map(({ httpApp, runtime }) =>
-      HttpApp.toWebHandlerRuntime(runtime)(options?.middleware ? options.middleware(httpApp as any) as any : httpApp)
-    ),
-    Effect.tap((handler) => {
-      handlerCached = handler
-    }),
-    runtime.runPromise
-  )
+  const handlerPromise = Effect.gen(function*() {
+    const app = yield* httpApp
+    const rt = yield* runtime.runtimeEffect
+    const handler = HttpApp.toWebHandlerRuntime(rt)(options?.middleware ? options.middleware(app as any) as any : app)
+    handlerCached = handler
+    return handler
+  }).pipe(runtime.runPromise)
   function handler(request: Request): Promise<Response> {
     if (handlerCached !== undefined) {
       return handlerCached(request)
@@ -570,52 +566,35 @@ const handlerToRoute = (
     endpoint.path,
     applyMiddleware(
       middleware,
-      Effect.withFiberRuntime((fiber) => {
-        const context = fiber.getFiberRef(FiberRef.currentContext)
-        const request = Context.unsafeGet(context, HttpServerRequest.HttpServerRequest)
+      Effect.gen(function*() {
+        const fiber = Option.getOrThrow(Fiber.getCurrentFiber())
+        const context = fiber.currentContext
+        const httpRequest = Context.unsafeGet(context, HttpServerRequest.HttpServerRequest)
         const routeContext = Context.unsafeGet(context, HttpRouter.RouteContext)
         const urlParams = Context.unsafeGet(context, HttpServerRequest.ParsedSearchParams)
-        return (
-          decodePath._tag === "Some"
-            ? decodePath.value(routeContext.params)
-            : Effect.succeed(routeContext.params)
-        ).pipe(
-          Effect.bindTo("pathParams"),
-          decodePayload._tag === "Some"
-            ? Effect.bind(
-              "payload",
-              (_) =>
-                Effect.flatMap(
-                  requestPayload(request, urlParams, isMultipart),
-                  decodePayload.value
-                )
-            ) as typeof identity
-            : identity,
-          decodeHeaders._tag === "Some"
-            ? Effect.bind("headers", (_) => decodeHeaders.value(request.headers)) as typeof identity
-            : identity,
-          decodeUrlParams._tag === "Some"
-            ? Effect.bind("urlParams", (_) => decodeUrlParams.value(urlParams)) as typeof identity
-            : identity,
-          Effect.flatMap((input) => {
-            const request: any = { path: input.pathParams }
-            if ("payload" in input) {
-              request.payload = input.payload
-            }
-            if ("headers" in input) {
-              request.headers = input.headers
-            }
-            if ("urlParams" in input) {
-              request.urlParams = input.urlParams
-            }
-            return handler(request)
-          }),
-          isFullResponse ?
-            identity as (_: any) => Effect.Effect<HttpServerResponse.HttpServerResponse> :
-            Effect.flatMap(encodeSuccess),
-          Effect.catchIf(ParseResult.isParseError, HttpApiDecodeError.refailParseError)
-        )
-      })
+        const request: any = {}
+        if (decodePath._tag === "Some") {
+          request.path = yield* decodePath.value(routeContext.params)
+        }
+        if (decodePayload._tag === "Some") {
+          request.payload = yield* Effect.flatMap(
+            requestPayload(httpRequest, urlParams, isMultipart),
+            decodePayload.value
+          )
+        }
+        if (decodeHeaders._tag === "Some") {
+          request.headers = yield* decodeHeaders.value(httpRequest.headers)
+        }
+        if (decodeUrlParams._tag === "Some") {
+          request.urlParams = yield* decodeUrlParams.value(urlParams)
+        }
+        const response = isFullResponse
+          ? yield* handler(request)
+          : yield* Effect.flatMap(handler(request), encodeSuccess)
+        return response as HttpServerResponse.HttpServerResponse
+      }).pipe(
+        Effect.catchIf(ParseResult.isParseError, HttpApiDecodeError.refailParseError)
+      )
     )
   )
 }

package/src/HttpApiClient.ts

@@ -152,51 +152,41 @@ export const make = <Groups extends HttpApiGroup.Any, ApiError, ApiR>(
           readonly payload: any
           readonly headers: any
           readonly withResponse?: boolean
-        }) => {
-          const url = request && request.path ? makeUrl(request.path) : endpoint.path
-          const baseRequest = HttpClientRequest.make(endpoint.method)(url)
-          return (isMultipart ?
-            Effect.succeed(baseRequest.pipe(
-              HttpClientRequest.bodyFormData(request.payload)
-            ))
-            : encodePayload._tag === "Some"
-            ? encodePayload.value(request.payload).pipe(
-              Effect.flatMap((payload) =>
-                HttpMethod.hasBody(endpoint.method)
-                  ? HttpClientRequest.bodyJson(baseRequest, payload)
-                  : Effect.succeed(HttpClientRequest.setUrlParams(baseRequest, payload as any))
-              ),
-              Effect.orDie
+        }) =>
+          Effect.gen(function*() {
+            let httpRequest = HttpClientRequest.make(endpoint.method)(
+              request && request.path ? makeUrl(request.path) : endpoint.path
             )
-            : Effect.succeed(baseRequest)).pipe(
-              encodeHeaders._tag === "Some"
-                ? Effect.flatMap((httpRequest) =>
-                  encodeHeaders.value(request.headers).pipe(
-                    Effect.orDie,
-                    Effect.map((headers) => HttpClientRequest.setHeaders(httpRequest, headers as any))
-                  )
-                )
-                : identity,
-              encodeUrlParams._tag === "Some"
-                ? Effect.flatMap((httpRequest) =>
-                  encodeUrlParams.value(request.urlParams).pipe(
-                    Effect.orDie,
-                    Effect.map((params) => HttpClientRequest.appendUrlParams(httpRequest, params as any))
-                  )
-                )
-                : identity,
-              Effect.flatMap(httpClient.execute),
-              Effect.flatMap((response) => {
-                const value = options?.transformResponse === undefined
-                  ? decodeResponse(response)
-                  : options.transformResponse(decodeResponse(response))
-                return request?.withResponse === true ? Effect.map(value, (value) => [value, response]) : value
-              }),
-              Effect.scoped,
-              Effect.catchIf(ParseResult.isParseError, Effect.die),
-              Effect.mapInputContext((input) => Context.merge(context, input))
-            )
-        }
+            if (isMultipart) {
+              httpRequest = HttpClientRequest.bodyFormData(httpRequest, request.payload)
+            } else if (encodePayload._tag === "Some") {
+              const payload = yield* encodePayload.value(request.payload)
+              httpRequest = HttpMethod.hasBody(endpoint.method)
+                ? yield* Effect.orDie(HttpClientRequest.bodyJson(httpRequest, payload))
+                : HttpClientRequest.setUrlParams(httpRequest, payload as any)
+            }
+            if (encodeHeaders._tag === "Some") {
+              httpRequest = HttpClientRequest.setHeaders(
+                httpRequest,
+                (yield* encodeHeaders.value(request.headers)) as any
+              )
+            }
+            if (encodeUrlParams._tag === "Some") {
+              httpRequest = HttpClientRequest.appendUrlParams(
+                httpRequest,
+                (yield* encodeUrlParams.value(request.urlParams)) as any
+              )
+            }
+            const response = yield* httpClient.execute(httpRequest)
+            const value = yield* (options?.transformResponse === undefined
+              ? decodeResponse(response)
+              : options.transformResponse(decodeResponse(response)))
+            return request?.withResponse === true ? [value, response] : value
+          }).pipe(
+            Effect.scoped,
+            Effect.catchIf(ParseResult.isParseError, Effect.die),
+            Effect.mapInputContext((input) => Context.merge(context, input))
+          )
       }
     })
     return client as any