effect-cf 0.20.0 → 0.20.1

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # effect-cf
 
+## 0.20.1
+
+### Patch Changes
+
+- [#67](https://github.com/danieljvdm/effect-cf/pull/67) [`d8e1d64`](https://github.com/danieljvdm/effect-cf/commit/d8e1d64e8117fd8b86fabef6a61de01251557d2b) Thanks [@danieljvdm](https://github.com/danieljvdm)! - Route `Worker.make` fetch handlers through `HttpEffect.toHandled`, matching the first-party Effect HTTP adapters.
+
+  - Pre-response handlers (`HttpEffect.appendPreResponseHandler`, and things built on it such as `HttpApiBuilder.securitySetCookie`) now run before `HttpServerResponse` results are rendered. Previously they were silently dropped, which broke cookie-based auth flows on Workers.
+  - Streaming response bodies keep request-scoped resources alive until the stream completes, instead of finalizing them as soon as the `Response` is returned.
+  - `HttpServerResponse` bodies are suppressed for `HEAD` requests.
+  - Handler failures are now rendered as HTTP error responses (with the cause reported) instead of rejecting the `fetch` promise. Note that exceptions no longer escape `fetch`, so `passThroughOnException` will not trigger origin fallback for Effect-level failures.
+  - Native `Response` values returned from a fetch handler continue to bypass all response processing, including pre-response handlers — WebSocket upgrade responses and app-level `HttpEffect.toHandled` wrappers pass through untouched.
+
 ## 0.20.0
 
 ### Minor Changes

package/dist/index.mjs

@@ -1,6 +1,6 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
 import { Cause, Clock, Config, ConfigProvider, Context, Data, DateTime, Duration, Effect, Exit, Layer, ManagedRuntime, Option, Queue, Result, Schema } from "effect";
-import { FetchHttpClient, HttpClient, HttpClientRequest, HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
+import { FetchHttpClient, HttpClient, HttpClientRequest, HttpEffect, HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
 import { OtlpLogger, OtlpMetrics, OtlpSerialization, OtlpTracer } from "effect/unstable/observability";
 import { D1Client } from "@effect/sql-d1";
 import { DurableObject, RpcStub, RpcTarget, WorkerEntrypoint, WorkflowEntrypoint } from "cloudflare:workers";
@@ -1874,7 +1874,27 @@ const reservedMethodNames$2 = /* @__PURE__ */ new Set([
 ]);
 const RunSymbol$1 = Symbol.for("effect-cf/Worker/run");
 const renderHttpResponse = (effect) => Effect.flatMap(effect, (response) => Effect.map(Effect.context(), (context) => HttpServerResponse.toWeb(response, { context })));
-const renderFetchSuccess = (effect) => Effect.flatMap(effect, (response) => response instanceof Response ? Effect.succeed(response) : Effect.map(Effect.context(), (context) => HttpServerResponse.toWeb(response, { context })));
+const renderFetchSuccess = (effect) => Effect.suspend(() => {
+	let nativeResponse;
+	let webResponse;
+	const handled = HttpEffect.toHandled(Effect.flatMap(effect, (response) => {
+		if (response instanceof Response) {
+			nativeResponse = response;
+			return Effect.succeed(HttpServerResponse.empty());
+		}
+		return Effect.succeed(response);
+	}), (request, response) => nativeResponse !== void 0 ? Effect.void : Effect.map(Effect.context(), (context) => {
+		webResponse = HttpServerResponse.toWeb(HttpEffect.scopeTransferToStream(response), {
+			withoutBody: request.method === "HEAD",
+			context
+		});
+	}));
+	const captured = () => nativeResponse ?? webResponse ?? new Response(null, { status: 500 });
+	return Effect.matchCause(handled, {
+		onFailure: captured,
+		onSuccess: captured
+	});
+});
 const isWorkerOptions = (options) => typeof options === "object" && options !== null && ("eventLayer" in options || "fetch" in options || "queue" in options || "rpc" in options);
 function make$9(layer, optionsOrFetch) {
 	const options = isWorkerOptions(optionsOrFetch) ? optionsOrFetch : { fetch: optionsOrFetch };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-cf",
-  "version": "0.20.0",
+  "version": "0.20.1",
   "description": "Effect-native primitives for Cloudflare Workers and bindings.",
   "license": "MIT",
   "repository": {

package/src/Worker.ts

@@ -9,7 +9,7 @@ import {
   type Schema as S,
   type Scope,
 } from "effect";
-import { HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
+import { HttpEffect, HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
 
 import type * as Binding from "./Binding";
 import { WorkerConfig, WorkerEnvironment, type WorkerEnv } from "./Environment";
@@ -196,14 +196,41 @@ export const renderHttpResponse = <A extends HttpServerResponse.HttpServerRespon
 
 const renderFetchSuccess = <E, R>(
   effect: Effect.Effect<WorkerFetchSuccess, E, R>,
-): Effect.Effect<Response, E, R> =>
-  Effect.flatMap(effect, (response) =>
-    response instanceof Response
-      ? Effect.succeed(response)
-      : Effect.map(Effect.context<never>(), (context) =>
-          HttpServerResponse.toWeb(response, { context }),
-        ),
-  );
+): Effect.Effect<Response, E, Exclude<R, Scope.Scope> | HttpServerRequest.HttpServerRequest> =>
+  Effect.suspend(() => {
+    // Native `Response` values bypass all HTTP response processing (including
+    // pre-response handlers), so app-level `HttpEffect.toHandled` wrappers and
+    // WebSocket upgrade responses pass through untouched.
+    let nativeResponse: Response | undefined;
+    let webResponse: Response | undefined;
+
+    const handled = HttpEffect.toHandled(
+      Effect.flatMap(effect, (response) => {
+        if (response instanceof Response) {
+          nativeResponse = response;
+
+          return Effect.succeed(HttpServerResponse.empty());
+        }
+
+        return Effect.succeed(response);
+      }),
+      (request, response) =>
+        nativeResponse !== undefined
+          ? Effect.void
+          : Effect.map(Effect.context<never>(), (context) => {
+              webResponse = HttpServerResponse.toWeb(HttpEffect.scopeTransferToStream(response), {
+                withoutBody: request.method === "HEAD",
+                context,
+              });
+            }),
+    );
+
+    // `toHandled` re-fails with the original cause after rendering the error
+    // response, so both branches return the response captured above.
+    const captured = () => nativeResponse ?? webResponse ?? new Response(null, { status: 500 });
+
+    return Effect.matchCause(handled, { onFailure: captured, onSuccess: captured });
+  });
 
 const isWorkerOptions = <ROut, REvent, EventLayerError, Rpc extends WorkerRpc<ROut | REvent>>(
   options: WorkerOptions<ROut, REvent, EventLayerError, Rpc> | WorkerHandler<ROut>,