@whatwg-node/server 0.10.0-alpha-20241125144944-df106a17746126e3c8089afa16af852a4483c8b3 → 0.10.0-alpha-20250205010145-5ab5edf75d82f8174c999dc970ad9a042ea5547d

package/README.md

@@ -40,7 +40,7 @@ nodeServer.listen(4000)
 ### AWS Lambda
 
 AWS Lambda is a serverless computing platform that makes it easy to build applications that run on
-the AWS cloud. Our adaoter is platform agnostic so they can fit together easily. In order to reduce
+the AWS cloud. Our adapter is platform agnostic so they can fit together easily. In order to reduce
 the boilerplate we prefer to use
 [Serverless Express from Vendia](https://github.com/vendia/serverless-express).
 
@@ -167,10 +167,15 @@ app.route({
   url: '/mypath',
   method: ['GET', 'POST', 'OPTIONS'],
   handler: async (req, reply) => {
-    const response = await myServerAdapter.handleNodeRequestAndResponse(req, reply, {
+    const response: Response = await myServerAdapter.handleNodeRequestAndResponse(req, reply, {
       req,
       reply
     })
+
+    if (!response) {
+      return reply.status(404).send('Not Found')
+    }
+
     response.headers.forEach((value, key) => {
       reply.header(key, value)
     })
@@ -200,7 +205,7 @@ import myServerAdapter from './myServerAdapter'
 const app = new Koa()
 
 app.use(async ctx => {
-  const response = await myServerAdapter.handleNodeRequest(ctx.req)
+  const response = await myServerAdapter.handleNodeRequestAndResponse(ctx.request, ctx.res, ctx)
 
   // Set status code
   ctx.status = response.status
@@ -258,9 +263,7 @@ as a first class citizen. So the configuration is really simple like any other J
 ```ts
 import myServerAdapter from './myServerAdapter'
 
-Bun.serve(myServerAdapter)
-
-const server = Bun.serve(yoga)
+const server = Bun.serve(myServerAdapter)
 
 console.info(`Server is running on ${server.hostname}`)
 ```
@@ -299,3 +302,305 @@ We'd recommend to use `fets` to handle routing and middleware approach. It uses
 `@whatwg-node/server` under the hood.
 
 > Learn more about `fets` [here](https://github.com/ardatan/fets)
+
+## Plugin System
+
+You can create your own plugins to extend the functionality of your server adapter.
+
+### `onRequest`
+
+This hook is invoked for ANY incoming HTTP request. Here you can manipulate the request or create a
+short circuit before the server adapter handles the request.
+
+For example, you can shortcut the manually handle an HTTP request, short-circuiting the HTTP
+handler:
+
+```ts
+import { createServerAdapter, type ServerAdapterPlugin } from '@whatwg-node/server'
+
+const myPlugin: ServerAdapterPlugin = {
+  onRequest({ request, endResponse, fetchAPI }) {
+    if (!request.headers.get('authorization')) {
+      endResponse(
+        new fetchAPI.Response(null, {
+          status: 401,
+          headers: {
+            'Content-Type': 'application/json'
+          }
+        })
+      )
+    }
+  }
+}
+
+const myServerAdapter = createServerAdapter(
+  async request => {
+    return new Response(`Hello World!`, { status: 200 })
+  },
+  {
+    plugins: [myPlugin]
+  }
+)
+```
+
+Possible usage examples of this hook are:
+
+- Manipulate the request
+- Short circuit before the adapter handles the request
+
+| Payload field   | Description                                                                                                                                     |
+| --------------- | ----------------------------------------------------------------------------------------------------------------------------------------------- |
+| `request`       | The incoming HTTP request as WHATWG `Request` object. [Learn more about the request](https://developer.mozilla.org/en-US/docs/Web/API/Request). |
+| `serverContext` | The early context object that is shared between all hooks and the entire execution. [Learn more about the context](/docs/features/context).     |
+| `fetchAPI`      | WHATWG Fetch API implementation. [Learn more about the fetch API](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API).                  |
+| `url`           | WHATWG URL object of the incoming request. [Learn more about the URL object](https://developer.mozilla.org/en-US/docs/Web/API/URL).             |
+| `endResponse`   | A function that allows you to end the request early and send a response to the client.                                                          |
+
+### `onResponse`
+
+This hook is invoked after a HTTP request has been processed and after the response has been
+forwarded to the client. Here you can perform any cleanup or logging operations, or you can
+manipulate the outgoing response object.
+
+```ts
+import { createServerAdapter, type ServerAdapterPlugin } from '@whatwg-node/server'
+
+const requestTimeMap = new WeakMap<Request, number>()
+
+const myPlugin: ServerAdapterPlugin = {
+  onRequest({ request }) {
+    requestTimeMap.set(request, Date.now())
+  },
+  onResponse({ request, serverContext, response }) {
+    console.log(`Request to ${request.url} has been processed with status ${response.status}`)
+    // Add some headers
+    response.headers.set('X-Server-Name', 'My Server')
+    console.log(`Request to ${request.url} took ${Date.now() - requestTimeMap.get(request)}ms`)
+  }
+}
+```
+
+**Example actions in this hook:**
+
+- Specify custom response format
+- Logging/Metrics
+
+| Field Name      | Description                                                                                                                                                   |
+| --------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `request`       | The incoming HTTP request as WHATWG `Request` object. [Learn more about the request](https://developer.mozilla.org/en-US/docs/Web/API/Request).               |
+| `serverContext` | The final context object that is shared between all hooks and the execution. [Learn more about the context](/docs/features/context).                          |
+| `response`      | The outgoing HTTP response as WHATWG `Response` object. [Learn more about the response interface](https://developer.mozilla.org/en-US/docs/Web/API/Response). |
+
+### `onDispose`
+
+In order to clean up resources when the server is shut down, you can use `onDispose`,
+`Symbol.asyncDispose` or `Symbol.syncDispose` to clean up resources.
+
+```ts
+export const useMyPlugin = () => {
+  return {
+    async onDispose() {
+      // Clean up resources
+      await stopConnection()
+    }
+  }
+}
+```
+
+[You can learn more about Explicit Resource Management below](#explicit-resource-management)
+
+## `Request.signal` for awareness of client disconnection
+
+In the real world, a lot of HTTP requests are dropped or canceled. This can happen due to a flakey
+internet connection, navigation to a new view or page within a web or native app or the user simply
+closing the app. In this case, the server can stop processing the request and save resources.
+
+You can utilize `request.signal` to cancel pending asynchronous operations when the client
+disconnects.
+
+```ts
+import { createServerAdapter } from '@whatwg-node/server'
+
+const myServerAdapter = createServerAdapter(async request => {
+  const upstreamRes = await fetch('https://api.example.com/data', {
+    // When the client disconnects, the fetch request will be canceled
+    signal: request.signal
+  })
+  return Response.json({
+    data: await upstreamRes.json()
+  })
+})
+```
+
+The execution cancelation API is built on top of the AbortController and AbortSignal APIs.
+
+[Learn more about AbortController and AbortSignal](https://developer.mozilla.org/en-US/docs/Web/API/AbortController)
+
+## Explicit Resource Management
+
+While implementing your server with `@whatwg-node/server`, you need to control over the lifecycle of
+your resources. This is especially important when you are dealing with resources that need to be
+cleaned up when they are no longer needed, or clean up the operations in a queue when the server is
+shutting down.
+
+### Dispose the Server Adapter
+
+The server adapter supports
+[Explicit Resource Management](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-2.html#using-declarations-and-explicit-resource-management)
+approach that allows you to dispose of resources when they are no longer needed. This can be done in
+two ways shown below;
+
+#### `await using` syntax
+
+We use the `await using` syntax to create a new instance of `adapter` and dispose of it when the
+block is exited. Notice that we are using a block to limit the scope of `adapter` within `{ }`. So
+resources will be disposed of when the block is exited.
+
+```ts
+console.log('Adapter is starting')
+{
+  await using adapter = createServerAdapter(/* ... */)
+}
+console.log('Adapter is disposed')
+```
+
+#### `dispose` method
+
+We create a new instance of `adapter` and dispose of it using the `dispose` method.
+
+```ts
+console.log('Adapter is starting')
+const adapter = createServerAdapter(/* ... */)
+await adapter.dispose()
+console.log('Adapter is disposed')
+```
+
+In the first example, we use the `await using` syntax to create a new instance of `adapter` and
+dispose of it when the block is exited. In the second example,
+
+#### Dispose on Node.js
+
+When running your adapter on Node.js, you can use process event listeners or server's `close` event
+to trigger the adapter's disposal. Or you can configure the adapter to handle this automatically by
+listening `process` exit signals.
+
+##### Explicit disposal
+
+We can dispose of the adapter instance when the server is closed like below.
+
+```ts
+import { createServer } from 'http'
+import { createServerAdapter } from '@whatwg-node/server'
+
+const adapter = createServerAdapter(/* ... */)
+
+const server = createServer(adapter)
+server.listen(4000, () => {
+  console.info('Server is running on http://localhost:4000')
+})
+server.once('close', async () => {
+  await adapter.dispose()
+  console.info('Server is disposed so is adapter')
+})
+```
+
+##### Automatic disposal
+
+`disposeOnProcessTerminate` option will register an event listener for `process` termination in
+Node.js
+
+```ts
+import { createServer } from 'http'
+import { createServerAdapter } from '@whatwg-node/server'
+
+createServer(
+  createServerAdapter(/* ... */, {
+    disposeOnProcessTerminate: true,
+    plugins: [/* ... */]
+  })
+).listen(4000, () => {
+  console.info('Server is running on http://localhost:4000')
+})
+```
+
+### Plugin Disposal
+
+If you have plugins that need some internal resources to be disposed of, you can use the `onDispose`
+hook to dispose of them. This hook will be invoked when the adapter instance is disposed like above.
+
+```ts
+let dbConnection: Connection
+const plugin = {
+  onPluginInit: async () => {
+    dbConnection = await createConnection()
+  },
+  onDispose: async () => {
+    // Dispose of resources
+    await dbConnection.close()
+  }
+}
+```
+
+Or you can flush a queue of operations when the server is shutting down.
+
+```ts
+const backgroundJobs: Promise<void>[] = []
+
+const plugin = {
+  onRequest() {
+    backgroundJobs.push(
+      sendAnalytics({
+        /* ... */
+      })
+    )
+  },
+  onDispose: async () => {
+    // Flush the queue of background jobs
+    await Promise.all(backgroundJobs)
+  }
+}
+```
+
+But for this kind of purposes, `waitUntil` can be a better choice.
+
+### Background jobs
+
+If you have background jobs that need to be completed before the environment is shut down.
+`waitUntil` is better choice than `onDispose`. In this case, those jobs will keep running in the
+background but in case of disposal, they will be awaited. `waitUntil` works so similar to
+[Cloudflare Workers' `waitUntil` function](https://developers.cloudflare.com/workers/runtime-apis/handlers/fetch/#parameters).
+
+But the adapter handles `waitUntil` even if it is not provided by the environment.
+
+```ts
+const adapter = createServerAdapter(async (request, context) => {
+  const args = await request.json()
+  if (!args.name) {
+    return Response.json({ error: 'Name is required' }, { status: 400 })
+  }
+  // This does not block the response
+  context.waitUntil(
+    fetch('http://my-analytics.com/analytics', {
+      method: 'POST',
+      body: JSON.stringify({
+        name: args.name,
+        userAgent: request.headers.get('User-Agent')
+      })
+    })
+  )
+  return Response.json({ greetings: `Hello, ${args.name}` })
+})
+
+const res = await adapter.fetch('http://localhost:4000', {
+  method: 'POST',
+  headers: {
+    'Content-Type': 'application/json'
+  },
+  body: JSON.stringify({ name: 'John' })
+})
+
+console.log(await res.json()) // { greetings: "Hello, John" }
+
+await adapter.dispose()
+// The fetch request for `analytics` will be awaited here
+```

package/cjs/createServerAdapter.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createServerAdapter = createServerAdapter;
 const tslib_1 = require("tslib");
-/* eslint-disable @typescript-eslint/ban-types */
 const disposablestack_1 = require("@whatwg-node/disposablestack");
 const DefaultFetchAPI = tslib_1.__importStar(require("@whatwg-node/fetch"));
 const utils_js_1 = require("./utils.js");
@@ -28,54 +27,56 @@ function createServerAdapter(serverAdapterBaseObject, options) {
     const onRequestHooks = [];
     const onResponseHooks = [];
     const waitUntilPromises = new Set();
-    const disposableStack = new disposablestack_1.AsyncDisposableStack();
-    const signals = new Set();
-    function registerSignal(signal) {
-        signals.add(signal);
-        signal.addEventListener('abort', () => {
-            signals.delete(signal);
-        });
-    }
-    disposableStack.defer(() => {
-        for (const signal of signals) {
-            signal.sendAbort();
-        }
-    });
-    disposableStack.defer(() => {
-        if (waitUntilPromises.size > 0) {
-            return Promise.allSettled(waitUntilPromises).then(() => {
-                waitUntilPromises.clear();
-            }, () => {
-                waitUntilPromises.clear();
+    let _disposableStack;
+    function ensureDisposableStack() {
+        if (!_disposableStack) {
+            _disposableStack = new disposablestack_1.AsyncDisposableStack();
+            if (options?.disposeOnProcessTerminate) {
+                (0, utils_js_1.ensureDisposableStackRegisteredForTerminateEvents)(_disposableStack);
+            }
+            _disposableStack.defer(() => {
+                if (waitUntilPromises.size > 0) {
+                    return Promise.allSettled(waitUntilPromises).then(() => {
+                        waitUntilPromises.clear();
+                    }, () => {
+                        waitUntilPromises.clear();
+                    });
+                }
             });
         }
-    });
+        return _disposableStack;
+    }
     function waitUntil(promiseLike) {
-        // If it is a Node.js environment, we should register the disposable stack to handle process termination events
-        if (globalThis.process) {
-            (0, utils_js_1.ensureDisposableStackRegisteredForTerminateEvents)(disposableStack);
+        // Ensure that the disposable stack is created
+        if ((0, utils_js_1.isPromise)(promiseLike)) {
+            ensureDisposableStack();
+            waitUntilPromises.add(promiseLike);
+            promiseLike.then(() => {
+                waitUntilPromises.delete(promiseLike);
+            }, err => {
+                console.error(`Unexpected error while waiting: ${err.message || err}`);
+                waitUntilPromises.delete(promiseLike);
+            });
         }
-        waitUntilPromises.add(promiseLike);
-        promiseLike.then(() => {
-            waitUntilPromises.delete(promiseLike);
-        }, err => {
-            console.error(`Unexpected error while waiting: ${err.message || err}`);
-            waitUntilPromises.delete(promiseLike);
-        });
     }
     if (options?.plugins != null) {
         for (const plugin of options.plugins) {
-            if (plugin != null) {
-                if (plugin.onRequest) {
-                    onRequestHooks.push(plugin.onRequest);
-                }
-                if (plugin.onResponse) {
-                    onResponseHooks.push(plugin.onResponse);
-                }
-                const disposeFn = plugin[disposablestack_1.DisposableSymbols.asyncDispose] || plugin[disposablestack_1.DisposableSymbols.dispose];
-                if (disposeFn != null) {
-                    disposableStack.defer(disposeFn);
-                }
+            if (plugin.onRequest) {
+                onRequestHooks.push(plugin.onRequest);
+            }
+            if (plugin.onResponse) {
+                onResponseHooks.push(plugin.onResponse);
+            }
+            const disposeFn = plugin[disposablestack_1.DisposableSymbols.dispose];
+            if (disposeFn) {
+                ensureDisposableStack().defer(disposeFn);
+            }
+            const asyncDisposeFn = plugin[disposablestack_1.DisposableSymbols.asyncDispose];
+            if (asyncDisposeFn) {
+                ensureDisposableStack().defer(asyncDisposeFn);
+            }
+            if (plugin.onDispose) {
+                ensureDisposableStack().defer(plugin.onDispose);
             }
         }
     }
@@ -150,7 +151,11 @@ function createServerAdapter(serverAdapterBaseObject, options) {
     // TODO: Remove this on the next major version
     function handleNodeRequest(nodeRequest, ...ctx) {
         const serverContext = ctx.length > 1 ? (0, utils_js_1.completeAssign)(...ctx) : ctx[0] || {};
-        const request = (0, utils_js_1.normalizeNodeRequest)(nodeRequest, fetchAPI, registerSignal);
+        // Ensure `waitUntil` is available in the server context
+        if (!serverContext.waitUntil) {
+            serverContext.waitUntil = waitUntil;
+        }
+        const request = (0, utils_js_1.normalizeNodeRequest)(nodeRequest, fetchAPI);
         return handleRequest(request, serverContext);
     }
     function handleNodeRequestAndResponse(nodeRequest, nodeResponseOrContainer, ...ctx) {
@@ -196,8 +201,7 @@ function createServerAdapter(serverAdapterBaseObject, options) {
         const serverContext = filteredCtxParts.length > 0
             ? (0, utils_js_1.completeAssign)(defaultServerContext, ...ctx)
             : defaultServerContext;
-        const signal = new utils_js_1.ServerAdapterRequestAbortSignal();
-        registerSignal(signal);
+        const controller = new AbortController();
         const originalResEnd = res.end.bind(res);
         let resEnded = false;
         res.end = function (data) {
@@ -206,16 +210,16 @@ function createServerAdapter(serverAdapterBaseObject, options) {
         };
         const originalOnAborted = res.onAborted.bind(res);
         originalOnAborted(function () {
-            signal.sendAbort();
+            controller.abort();
         });
         res.onAborted = function (cb) {
-            signal.addEventListener('abort', cb);
+            controller.signal.addEventListener('abort', cb, { once: true });
         };
         const request = (0, uwebsockets_js_1.getRequestFromUWSRequest)({
             req,
             res,
             fetchAPI,
-            signal,
+            controller,
         });
         let response$;
         try {
@@ -228,8 +232,8 @@ function createServerAdapter(serverAdapterBaseObject, options) {
             return response$
                 .catch((e) => (0, utils_js_1.handleErrorFromRequestHandler)(e, fetchAPI.Response))
                 .then(response => {
-                if (!signal.aborted && !resEnded) {
-                    return (0, uwebsockets_js_1.sendResponseToUwsOpts)(res, response, signal, fetchAPI);
+                if (!controller.signal.aborted && !resEnded) {
+                    return (0, uwebsockets_js_1.sendResponseToUwsOpts)(res, response, controller, fetchAPI);
                 }
             })
                 .catch(err => {
@@ -237,8 +241,8 @@ function createServerAdapter(serverAdapterBaseObject, options) {
             });
         }
         try {
-            if (!signal.aborted && !resEnded) {
-                return (0, uwebsockets_js_1.sendResponseToUwsOpts)(res, response$, signal, fetchAPI);
+            if (!controller.signal.aborted && !resEnded) {
+                return (0, uwebsockets_js_1.sendResponseToUwsOpts)(res, response$, controller, fetchAPI);
             }
         }
         catch (err) {
@@ -271,13 +275,17 @@ function createServerAdapter(serverAdapterBaseObject, options) {
             if ((0, utils_js_1.isRequestInit)(initOrCtx)) {
                 const request = new fetchAPI.Request(input, initOrCtx);
                 const res$ = handleRequestWithWaitUntil(request, ...restOfCtx);
-                return (0, utils_js_1.handleAbortSignalAndPromiseResponse)(res$, initOrCtx?.signal);
+                const signal = initOrCtx.signal;
+                if (signal) {
+                    return (0, utils_js_1.handleAbortSignalAndPromiseResponse)(res$, signal);
+                }
+                return res$;
             }
             const request = new fetchAPI.Request(input);
             return handleRequestWithWaitUntil(request, ...maybeCtx);
         }
         const res$ = handleRequestWithWaitUntil(input, ...maybeCtx);
-        return (0, utils_js_1.handleAbortSignalAndPromiseResponse)(res$, input._signal);
+        return (0, utils_js_1.handleAbortSignalAndPromiseResponse)(res$, input.signal);
     };
     const genericRequestHandler = (input, ...maybeCtx) => {
         // If it is a Node request
@@ -316,16 +324,18 @@ function createServerAdapter(serverAdapterBaseObject, options) {
         handleEvent,
         handleUWS,
         handle: genericRequestHandler,
-        disposableStack,
+        get disposableStack() {
+            return ensureDisposableStack();
+        },
         [disposablestack_1.DisposableSymbols.asyncDispose]() {
-            if (!disposableStack.disposed) {
-                return disposableStack.disposeAsync();
+            if (_disposableStack && !_disposableStack.disposed) {
+                return _disposableStack.disposeAsync();
             }
             return (0, uwebsockets_js_1.fakePromise)(undefined);
         },
         dispose() {
-            if (!disposableStack.disposed) {
-                return disposableStack.disposeAsync();
+            if (_disposableStack && !_disposableStack.disposed) {
+                return _disposableStack.disposeAsync();
             }
             return (0, uwebsockets_js_1.fakePromise)(undefined);
         },

package/cjs/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Response = void 0;
+exports.DisposableSymbols = exports.Response = void 0;
 const tslib_1 = require("tslib");
 tslib_1.__exportStar(require("./createServerAdapter.js"), exports);
 tslib_1.__exportStar(require("./types.js"), exports);
@@ -12,3 +12,5 @@ tslib_1.__exportStar(require("./plugins/useContentEncoding.js"), exports);
 tslib_1.__exportStar(require("./uwebsockets.js"), exports);
 var fetch_1 = require("@whatwg-node/fetch");
 Object.defineProperty(exports, "Response", { enumerable: true, get: function () { return fetch_1.Response; } });
+var disposablestack_1 = require("@whatwg-node/disposablestack");
+Object.defineProperty(exports, "DisposableSymbols", { enumerable: true, get: function () { return disposablestack_1.DisposableSymbols; } });

package/cjs/plugins/useContentEncoding.js

@@ -46,50 +46,19 @@ function useContentEncoding() {
                 encodingMap.set(request, acceptEncoding.split(','));
             }
         },
-        onResponse({ request, response, setResponse, fetchAPI, serverContext }) {
-            // Hack for avoiding to create whatwg-node to create a readable stream until it's needed
-            if (response['bodyInit'] || response.body) {
+        onResponse({ request, response, setResponse, fetchAPI }) {
+            if (response.body) {
                 const encodings = encodingMap.get(request);
                 if (encodings) {
                     const supportedEncoding = encodings.find(encoding => (0, utils_js_1.getSupportedEncodings)(fetchAPI).includes(encoding));
                     if (supportedEncoding) {
                         const compressionStream = new fetchAPI.CompressionStream(supportedEncoding);
-                        // To calculate final content-length
-                        const contentLength = response.headers.get('content-length');
-                        if (contentLength) {
-                            const bufOfRes = response._buffer;
-                            if (bufOfRes) {
-                                const writer = compressionStream.writable.getWriter();
-                                const write$ = writer.write(bufOfRes);
-                                serverContext.waitUntil?.(write$);
-                                const close$ = writer.close();
-                                serverContext.waitUntil?.(close$);
-                                const uint8Arrays$ = (0, utils_js_1.isReadable)(compressionStream.readable['readable'])
-                                    ? collectReadableValues(compressionStream.readable['readable'])
-                                    : (0, utils_js_1.isAsyncIterable)(compressionStream.readable)
-                                        ? collectAsyncIterableValues(compressionStream.readable)
-                                        : collectReadableStreamValues(compressionStream.readable);
-                                return uint8Arrays$.then(uint8Arrays => {
-                                    const chunks = uint8Arrays.flatMap(uint8Array => [...uint8Array]);
-                                    const uint8Array = new Uint8Array(chunks);
-                                    const newHeaders = new fetchAPI.Headers(response.headers);
-                                    newHeaders.set('content-encoding', supportedEncoding);
-                                    newHeaders.set('content-length', uint8Array.byteLength.toString());
-                                    const compressedResponse = new fetchAPI.Response(uint8Array, {
-                                        ...response,
-                                        headers: newHeaders,
-                                    });
-                                    utils_js_1.decompressedResponseMap.set(compressedResponse, response);
-                                    setResponse(compressedResponse);
-                                    const close$ = compressionStream.writable.close();
-                                    serverContext.waitUntil?.(close$);
-                                });
-                            }
-                        }
                         const newHeaders = new fetchAPI.Headers(response.headers);
                         newHeaders.set('content-encoding', supportedEncoding);
                         newHeaders.delete('content-length');
-                        const compressedBody = response.body.pipeThrough(compressionStream);
+                        const compressedBody = response.body.pipeThrough(compressionStream, {
+                            signal: request.signal,
+                        });
                         const compressedResponse = new fetchAPI.Response(compressedBody, {
                             status: response.status,
                             statusText: response.statusText,
@@ -103,33 +72,3 @@ function useContentEncoding() {
         },
     };
 }
-function collectReadableValues(readable) {
-    const values = [];
-    readable.on('data', value => values.push(value));
-    return new Promise((resolve, reject) => {
-        readable.once('end', () => resolve(values));
-        readable.once('error', reject);
-    });
-}
-async function collectAsyncIterableValues(asyncIterable) {
-    const values = [];
-    for await (const value of asyncIterable) {
-        values.push(value);
-    }
-    return values;
-}
-async function collectReadableStreamValues(readableStream) {
-    const reader = readableStream.getReader();
-    const values = [];
-    while (true) {
-        const { done, value } = await reader.read();
-        if (done) {
-            reader.releaseLock();
-            break;
-        }
-        else if (value) {
-            values.push(value);
-        }
-    }
-    return values;
-}