@fedify/fastify 2.0.29-dev.2053 → 2.0.29-dev.2055

package/dist/index.cjs

@@ -26,7 +26,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 //#endregion
 let fastify_plugin = require("fastify-plugin");
 fastify_plugin = __toESM(fastify_plugin);
-let node_stream = require("node:stream");
+let node_buffer = require("node:buffer");
 //#region src/index.ts
 /**
 * Fastify plugin that integrates with a Federation instance.
@@ -61,7 +61,7 @@ let node_stream = require("node:stream");
 const fedifyPluginCore = (fastify, options) => {
 	const { federation, contextDataFactory = () => void 0, errorHandlers } = options;
 	fastify.addHook("onRequest", async (request, reply) => {
-		const webRequest = toWebRequest(request);
+		const { request: webRequest, body } = toWebRequest(request);
 		const contextData = await contextDataFactory(request);
 		const response = await federation.fetch(webRequest, {
 			contextData,
@@ -69,7 +69,10 @@ const fedifyPluginCore = (fastify, options) => {
 			onNotFound: () => dummyNotFoundResponse,
 			...errorHandlers
 		});
-		if (response === dummyNotFoundResponse) return;
+		if (response === dummyNotFoundResponse) {
+			body?.restore();
+			return;
+		}
 		await reply.send(response);
 	});
 	return Promise.resolve();
@@ -94,34 +97,104 @@ function toWebRequest(fastifyReq) {
 	const headers = new Headers();
 	for (const [key, value] of Object.entries(fastifyReq.raw.headers)) if (Array.isArray(value)) for (const v of value) headers.append(key, v);
 	else if (value !== void 0) headers.set(key, String(value));
-	const body = fastifyReq.method === "GET" || fastifyReq.method === "HEAD" ? void 0 : fastifyReq.body !== void 0 ? typeof fastifyReq.body === "string" ? fastifyReq.body : JSON.stringify(fastifyReq.body) : lazyRequestBody(fastifyReq.raw);
-	return new Request(url, {
-		method: fastifyReq.method,
-		headers,
-		body,
-		duplex: "half"
-	});
+	let body;
+	let rawBody;
+	if (fastifyReq.method === "GET" || fastifyReq.method === "HEAD") body = void 0;
+	else if (fastifyReq.body !== void 0) body = typeof fastifyReq.body === "string" ? fastifyReq.body : JSON.stringify(fastifyReq.body);
+	else {
+		rawBody = createRequestBody(fastifyReq.raw);
+		body = rawBody.stream;
+	}
+	return {
+		request: new Request(url, {
+			method: fastifyReq.method,
+			headers,
+			body,
+			duplex: "half"
+		}),
+		body: rawBody
+	};
 }
 /**
 * Wraps the raw `IncomingMessage` in a `ReadableStream` that stays inert until
-* first read.  The `Request` is built in the `onRequest` hook, before Fedify
-* decides whether it handles the request; an eager `Readable.toWeb()` would
-* start draining the socket and break Fastify's own body parsing of the
-* declined requests.
+* first read, and that keeps the chunks it reads so that they can be put back.
+*
+* The `Request` is built before Fedify decides whether it handles the request.
+* Laziness alone is not enough: `Request.clone()` tees the body, and a tee pulls
+* a chunk right away, so a dispatcher calling `ctx.getSignedKey()` starts
+* reading the body even if Fedify then declines the request.  Reading in paused
+* mode, rather than through `Readable.toWeb()`, lets `restore()` unshift those
+* chunks back.
 */
-function lazyRequestBody(message) {
-	let reader;
-	return new ReadableStream({
-		async pull(controller) {
-			reader ??= node_stream.Readable.toWeb(message).getReader();
-			const { done, value } = await reader.read();
-			if (done) controller.close();
-			else controller.enqueue(value);
-		},
-		cancel(reason) {
-			return reader?.cancel(reason);
+function createRequestBody(message) {
+	const consumed = [];
+	const restoring = new AbortController();
+	let started = false;
+	let restored = false;
+	return {
+		stream: new ReadableStream({
+			async pull(controller) {
+				started = true;
+				while (!restored) {
+					const size = message.readableLength;
+					const chunk = size > 0 ? message.read(size) : null;
+					if (chunk != null) {
+						const bytes = typeof chunk === "string" ? node_buffer.Buffer.from(chunk) : chunk;
+						consumed.push(bytes);
+						controller.enqueue(bytes);
+						return;
+					}
+					if (isEnded(message)) break;
+					if (message.destroyed) throw new Error("The request was closed before its body ended.");
+					await waitForReadable(message, restoring.signal);
+				}
+				controller.close();
+			},
+			cancel(reason) {
+				if (started && !restored) message.destroy(reason instanceof Error ? reason : void 0);
+			}
+		}, { highWaterMark: 0 }),
+		restore() {
+			restored = true;
+			restoring.abort();
+			for (let i = consumed.length - 1; i >= 0; i--) message.unshift(consumed[i]);
+			consumed.length = 0;
 		}
-	}, { highWaterMark: 0 });
+	};
+}
+/**
+* Tells whether the stream has received all of its data, even if it has not
+* emitted `"end"` yet.  No public API exposes this, so it reads the internal
+* state, which Node.js, Deno, and Bun all provide, and falls back to
+* `readableEnded` elsewhere.
+*/
+function isEnded(message) {
+	return message._readableState?.ended ?? message.readableEnded;
+}
+function waitForReadable(message, signal) {
+	return new Promise((resolve, reject) => {
+		if (signal.aborted) return resolve();
+		const cleanup = () => {
+			message.off("readable", onReady);
+			message.off("end", onReady);
+			message.off("close", onReady);
+			message.off("error", onError);
+			signal.removeEventListener("abort", onReady);
+		};
+		const onReady = () => {
+			cleanup();
+			resolve();
+		};
+		const onError = (error) => {
+			cleanup();
+			reject(error);
+		};
+		message.on("readable", onReady);
+		message.on("end", onReady);
+		message.on("close", onReady);
+		message.on("error", onError);
+		signal.addEventListener("abort", onReady);
+	});
 }
 //#endregion
 exports.default = fedifyPlugin;

package/dist/index.js

@@ -1,5 +1,5 @@
 import fp from "fastify-plugin";
-import { Readable } from "node:stream";
+import { Buffer } from "node:buffer";
 //#region src/index.ts
 /**
 * Fastify plugin that integrates with a Federation instance.
@@ -34,7 +34,7 @@ import { Readable } from "node:stream";
 const fedifyPluginCore = (fastify, options) => {
 	const { federation, contextDataFactory = () => void 0, errorHandlers } = options;
 	fastify.addHook("onRequest", async (request, reply) => {
-		const webRequest = toWebRequest(request);
+		const { request: webRequest, body } = toWebRequest(request);
 		const contextData = await contextDataFactory(request);
 		const response = await federation.fetch(webRequest, {
 			contextData,
@@ -42,7 +42,10 @@ const fedifyPluginCore = (fastify, options) => {
 			onNotFound: () => dummyNotFoundResponse,
 			...errorHandlers
 		});
-		if (response === dummyNotFoundResponse) return;
+		if (response === dummyNotFoundResponse) {
+			body?.restore();
+			return;
+		}
 		await reply.send(response);
 	});
 	return Promise.resolve();
@@ -67,34 +70,104 @@ function toWebRequest(fastifyReq) {
 	const headers = new Headers();
 	for (const [key, value] of Object.entries(fastifyReq.raw.headers)) if (Array.isArray(value)) for (const v of value) headers.append(key, v);
 	else if (value !== void 0) headers.set(key, String(value));
-	const body = fastifyReq.method === "GET" || fastifyReq.method === "HEAD" ? void 0 : fastifyReq.body !== void 0 ? typeof fastifyReq.body === "string" ? fastifyReq.body : JSON.stringify(fastifyReq.body) : lazyRequestBody(fastifyReq.raw);
-	return new Request(url, {
-		method: fastifyReq.method,
-		headers,
-		body,
-		duplex: "half"
-	});
+	let body;
+	let rawBody;
+	if (fastifyReq.method === "GET" || fastifyReq.method === "HEAD") body = void 0;
+	else if (fastifyReq.body !== void 0) body = typeof fastifyReq.body === "string" ? fastifyReq.body : JSON.stringify(fastifyReq.body);
+	else {
+		rawBody = createRequestBody(fastifyReq.raw);
+		body = rawBody.stream;
+	}
+	return {
+		request: new Request(url, {
+			method: fastifyReq.method,
+			headers,
+			body,
+			duplex: "half"
+		}),
+		body: rawBody
+	};
 }
 /**
 * Wraps the raw `IncomingMessage` in a `ReadableStream` that stays inert until
-* first read.  The `Request` is built in the `onRequest` hook, before Fedify
-* decides whether it handles the request; an eager `Readable.toWeb()` would
-* start draining the socket and break Fastify's own body parsing of the
-* declined requests.
+* first read, and that keeps the chunks it reads so that they can be put back.
+*
+* The `Request` is built before Fedify decides whether it handles the request.
+* Laziness alone is not enough: `Request.clone()` tees the body, and a tee pulls
+* a chunk right away, so a dispatcher calling `ctx.getSignedKey()` starts
+* reading the body even if Fedify then declines the request.  Reading in paused
+* mode, rather than through `Readable.toWeb()`, lets `restore()` unshift those
+* chunks back.
 */
-function lazyRequestBody(message) {
-	let reader;
-	return new ReadableStream({
-		async pull(controller) {
-			reader ??= Readable.toWeb(message).getReader();
-			const { done, value } = await reader.read();
-			if (done) controller.close();
-			else controller.enqueue(value);
-		},
-		cancel(reason) {
-			return reader?.cancel(reason);
+function createRequestBody(message) {
+	const consumed = [];
+	const restoring = new AbortController();
+	let started = false;
+	let restored = false;
+	return {
+		stream: new ReadableStream({
+			async pull(controller) {
+				started = true;
+				while (!restored) {
+					const size = message.readableLength;
+					const chunk = size > 0 ? message.read(size) : null;
+					if (chunk != null) {
+						const bytes = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
+						consumed.push(bytes);
+						controller.enqueue(bytes);
+						return;
+					}
+					if (isEnded(message)) break;
+					if (message.destroyed) throw new Error("The request was closed before its body ended.");
+					await waitForReadable(message, restoring.signal);
+				}
+				controller.close();
+			},
+			cancel(reason) {
+				if (started && !restored) message.destroy(reason instanceof Error ? reason : void 0);
+			}
+		}, { highWaterMark: 0 }),
+		restore() {
+			restored = true;
+			restoring.abort();
+			for (let i = consumed.length - 1; i >= 0; i--) message.unshift(consumed[i]);
+			consumed.length = 0;
 		}
-	}, { highWaterMark: 0 });
+	};
+}
+/**
+* Tells whether the stream has received all of its data, even if it has not
+* emitted `"end"` yet.  No public API exposes this, so it reads the internal
+* state, which Node.js, Deno, and Bun all provide, and falls back to
+* `readableEnded` elsewhere.
+*/
+function isEnded(message) {
+	return message._readableState?.ended ?? message.readableEnded;
+}
+function waitForReadable(message, signal) {
+	return new Promise((resolve, reject) => {
+		if (signal.aborted) return resolve();
+		const cleanup = () => {
+			message.off("readable", onReady);
+			message.off("end", onReady);
+			message.off("close", onReady);
+			message.off("error", onError);
+			signal.removeEventListener("abort", onReady);
+		};
+		const onReady = () => {
+			cleanup();
+			resolve();
+		};
+		const onError = (error) => {
+			cleanup();
+			reject(error);
+		};
+		message.on("readable", onReady);
+		message.on("end", onReady);
+		message.on("close", onReady);
+		message.on("error", onError);
+		signal.addEventListener("abort", onReady);
+	});
 }
 //#endregion
 export { fedifyPlugin as default, fedifyPlugin };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fedify/fastify",
-  "version": "2.0.29-dev.2053+58b638b4",
+  "version": "2.0.29-dev.2055+5e21857f",
   "description": "Integrate Fedify with Fastify",
   "keywords": [
     "Fedify",
@@ -48,7 +48,7 @@
   },
   "peerDependencies": {
     "fastify": "^5.2.0",
-    "@fedify/fedify": "^2.0.29-dev.2053+58b638b4"
+    "@fedify/fedify": "^2.0.29-dev.2055+5e21857f"
   },
   "devDependencies": {
     "@types/node": "^22.17.0",