fix: resolve request hang with large API responses (#437)

* fix: resolve request hang with `pageSize` and `fetchLinks`

Replace `response.clone()` with a memoized response wrapper that caches
promises for `text()`, `json()`, and `blob()` reads. This allows multiple
callers sharing a deduplicated request to safely read from the same response
without stream/body handling issues.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

* fix: prevent body read conflicts in memoized responses

Clone the response before reading text/blob to avoid "body already read"
errors when both methods are called on the same memoized response.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

* fix: buffer response body immediately to avoid backpressure

Buffers the response body as a blob immediately instead of using
response.clone(). This fixes hanging requests in Node.js 22+ where
backpressure blocks the cloned stream when the original is not consumed.

See: node-fetch/node-fetch#139

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

* fix: simplify memoizeResponse to reduce complexity

Replace verbose wrapper with lazy caching variables with a compact
implementation that eagerly buffers the blob and derives text/json
from it on each call.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* test: return fresh Response per mock call to match real fetch

mockResolvedValue reuses one Response object across calls, but real
fetch always returns a fresh Response. Use mockImplementation so each
call creates a new Response, avoiding "Body has already been read".

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* fix: clarify memoizeResponse comment

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>

Author: angeloashmore

src/lib/request.ts

@@ -104,6 +104,26 @@ export interface HeadersLike {
 	get(name: string): string | null
 }
 
+async function memoizeResponse(response: ResponseLike): Promise<ResponseLike> {
+	// Deduplicated responses are shared across multiple callers. Calling
+	// response.clone() on a shared response can cause backpressure hangs
+	// in Node.js, so we buffer the body as a blob upfront instead.
+	const blob = await response.blob()
+
+	const memoized: ResponseLike = {
+		ok: response.ok,
+		status: response.status,
+		headers: response.headers,
+		url: response.url,
+		text: async () => blob.text(),
+		json: async () => JSON.parse(await blob.text()),
+		blob: async () => blob,
+		clone: () => memoized,
+	}
+
+	return memoized
+}
+
 /**
  * Makes an HTTP request with automatic retry for rate limits and request
  * deduplication.
@@ -137,12 +157,14 @@ export async function request(
 		if (existingJob) {
 			job = existingJob
 		} else {
-			job = fetchFn(stringURL, init).finally(() => {
-				DEDUPLICATED_JOBS[stringURL]?.delete(init?.signal)
-				if (DEDUPLICATED_JOBS[stringURL]?.size === 0) {
-					delete DEDUPLICATED_JOBS[stringURL]
-				}
-			})
+			job = fetchFn(stringURL, init)
+				.then(memoizeResponse)
+				.finally(() => {
+					DEDUPLICATED_JOBS[stringURL]?.delete(init?.signal)
+					if (DEDUPLICATED_JOBS[stringURL]?.size === 0) {
+						delete DEDUPLICATED_JOBS[stringURL]
+					}
+				})
 			const map = (DEDUPLICATED_JOBS[stringURL] ||= new Map())
 			map.set(init?.signal, job)
 		}
@@ -162,5 +184,5 @@ export async function request(
 		return request(url, init, fetchFn)
 	}
 
-	return response.clone()
+	return response
 }

test/client-dangerouslyGetAll.test.ts

@@ -172,7 +172,7 @@ it("throttles invalid ref logs", async ({ expect, client, response }) => {
 		.mockResolvedValueOnce(response.repository("invalid"))
 		.mockResolvedValueOnce(response.refNotFound("invalid"))
 		.mockResolvedValueOnce(response.repository("invalid"))
-		.mockResolvedValue(response.refNotFound("invalid"))
+		.mockImplementation(() => Promise.resolve(response.refNotFound("invalid")))
 	await expect(() => client.dangerouslyGetAll()).rejects.toThrow(
 		RefNotFoundError,
 	)

test/client.test.ts

@@ -233,7 +233,7 @@ describe.for(queryCases)("$name", async ({ fn }) => {
 			.mockResolvedValueOnce(response.repository("invalid"))
 			.mockResolvedValueOnce(response.refNotFound("invalid"))
 			.mockResolvedValueOnce(response.repository("invalid"))
-			.mockResolvedValue(response.refNotFound("invalid"))
+			.mockImplementation(() => Promise.resolve(response.refNotFound("invalid")))
 		await expect(() => fn({ client, docs })).rejects.toThrow(RefNotFoundError)
 		expect(console.warn).toHaveBeenCalledTimes(1)
 	})