@whatwg-node/server 0.10.0-alpha-20240717144936-662ea5088eb83ec5b55025307193fac81a8ea190 → 0.10.0-alpha-20240726141316-c6ce93b3598457ebe73b3b725986723af8f5e609

package/cjs/createServerAdapter.js

@@ -54,6 +54,9 @@ function createServerAdapter(serverAdapterBaseObject, options) {
             });
             const onRequestHooksIteration$ = (0, utils_js_1.iterateAsyncVoid)(onRequestHooks, (onRequestHook, stopEarly) => onRequestHook({
                 request,
+                setRequest(newRequest) {
+                    request = newRequest;
+                },
                 serverContext,
                 fetchAPI,
                 url,
@@ -69,13 +72,17 @@ function createServerAdapter(serverAdapterBaseObject, options) {
                 },
             }));
             function handleResponse(response) {
-                if (onRequestHooks.length === 0) {
+                if (onResponseHooks.length === 0) {
                     return response;
                 }
                 const onResponseHookPayload = {
                     request,
                     response,
                     serverContext,
+                    setResponse(newResponse) {
+                        response = newResponse;
+                    },
+                    fetchAPI,
                 };
                 const onResponseHooksIteration$ = (0, utils_js_1.iterateAsyncVoid)(onResponseHooks, onResponseHook => onResponseHook(onResponseHookPayload));
                 if ((0, utils_js_1.isPromise)(onResponseHooksIteration$)) {
@@ -99,6 +106,7 @@ function createServerAdapter(serverAdapterBaseObject, options) {
             return handleEarlyResponse();
         }
         : givenHandleRequest;
+    // TODO: Remove this on the next major version
     function handleNodeRequestAndResponse(nodeRequest, nodeResponseOrContainer, ...ctx) {
         const nodeResponse = nodeResponseOrContainer.raw || nodeResponseOrContainer;
         const serverContext = ctx.length > 1 ? (0, utils_js_1.completeAssign)(...ctx) : ctx[0] || {};

package/cjs/index.js

@@ -8,6 +8,7 @@ tslib_1.__exportStar(require("./utils.js"), exports);
 tslib_1.__exportStar(require("./plugins/types.js"), exports);
 tslib_1.__exportStar(require("./plugins/useCors.js"), exports);
 tslib_1.__exportStar(require("./plugins/useErrorHandling.js"), exports);
+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; } });

package/cjs/plugins/useContentEncoding.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useContentEncoding = useContentEncoding;
+const utils_js_1 = require("../utils.js");
+function useContentEncoding() {
+    const encodingMap = new WeakMap();
+    return {
+        onRequest({ request, setRequest, fetchAPI, endResponse }) {
+            if (request.body) {
+                const contentEncodingHeader = request.headers.get('content-encoding');
+                if (contentEncodingHeader && contentEncodingHeader !== 'none') {
+                    const contentEncodings = contentEncodingHeader?.split(',');
+                    if (!contentEncodings.every(encoding => (0, utils_js_1.getSupportedEncodings)(fetchAPI).includes(encoding))) {
+                        endResponse(new fetchAPI.Response(`Unsupported 'Content-Encoding': ${contentEncodingHeader}`, {
+                            status: 415,
+                            statusText: 'Unsupported Media Type',
+                        }));
+                        return;
+                    }
+                    let newBody = request.body;
+                    for (const contentEncoding of contentEncodings) {
+                        newBody = newBody.pipeThrough(new fetchAPI.DecompressionStream(contentEncoding));
+                    }
+                    const newRequest = new fetchAPI.Request(request.url, {
+                        body: newBody,
+                        cache: request.cache,
+                        credentials: request.credentials,
+                        headers: request.headers,
+                        integrity: request.integrity,
+                        keepalive: request.keepalive,
+                        method: request.method,
+                        mode: request.mode,
+                        redirect: request.redirect,
+                        referrer: request.referrer,
+                        referrerPolicy: request.referrerPolicy,
+                        signal: request.signal,
+                        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                        // @ts-ignore - not in the TS types yet
+                        duplex: 'half',
+                    });
+                    setRequest(newRequest);
+                }
+            }
+            const acceptEncoding = request.headers.get('accept-encoding');
+            if (acceptEncoding) {
+                encodingMap.set(request, acceptEncoding.split(','));
+            }
+        },
+        onResponse({ request, response, setResponse, fetchAPI }) {
+            // Hack for avoiding to create whatwg-node to create a readable stream until it's needed
+            if (response['bodyInit'] || 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();
+                                writer.write(bufOfRes);
+                                writer.close();
+                                const reader = compressionStream.readable.getReader();
+                                return Promise.resolve().then(async () => {
+                                    const chunks = [];
+                                    while (true) {
+                                        const { done, value } = await reader.read();
+                                        if (done) {
+                                            reader.releaseLock();
+                                            break;
+                                        }
+                                        else if (value) {
+                                            chunks.push(...value);
+                                        }
+                                    }
+                                    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 newHeaders = new fetchAPI.Headers(response.headers);
+                        newHeaders.set('content-encoding', supportedEncoding);
+                        newHeaders.delete('content-length');
+                        const compressedBody = response.body.pipeThrough(compressionStream);
+                        const compressedResponse = new fetchAPI.Response(compressedBody, {
+                            status: response.status,
+                            statusText: response.statusText,
+                            headers: newHeaders,
+                        });
+                        utils_js_1.decompressedResponseMap.set(compressedResponse, response);
+                        setResponse(compressedResponse);
+                    }
+                }
+            }
+        },
+    };
+}

package/cjs/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ServerAdapterRequestAbortSignal = void 0;
+exports.decompressedResponseMap = exports.ServerAdapterRequestAbortSignal = void 0;
 exports.isAsyncIterable = isAsyncIterable;
 exports.normalizeNodeRequest = normalizeNodeRequest;
 exports.isReadable = isReadable;
@@ -17,6 +17,8 @@ exports.handleErrorFromRequestHandler = handleErrorFromRequestHandler;
 exports.isolateObject = isolateObject;
 exports.createDeferredPromise = createDeferredPromise;
 exports.handleAbortSignalAndPromiseResponse = handleAbortSignalAndPromiseResponse;
+exports.getSupportedEncodings = getSupportedEncodings;
+exports.handleResponseDecompression = handleResponseDecompression;
 const fetch_1 = require("@whatwg-node/fetch");
 function isAsyncIterable(body) {
     return (body != null && typeof body === 'object' && typeof body[Symbol.asyncIterator] === 'function');
@@ -112,7 +114,16 @@ function normalizeNodeRequest(nodeRequest, nodeResponse, RequestCtor) {
         fullUrl = url.toString();
     }
     let signal;
-    if (nodeResponse.once) {
+    let normalizedHeaders = nodeRequest.headers;
+    if (nodeRequest.headers?.[':method']) {
+        normalizedHeaders = {};
+        for (const key in nodeRequest.headers) {
+            if (!key.startsWith(':')) {
+                normalizedHeaders[key] = nodeRequest.headers[key];
+            }
+        }
+    }
+    if (nodeResponse?.once) {
         let sendAbortSignal;
         // If ponyfilled
         if (RequestCtor !== globalThis.Request) {
@@ -139,7 +150,7 @@ function normalizeNodeRequest(nodeRequest, nodeResponse, RequestCtor) {
     if (nodeRequest.method === 'GET' || nodeRequest.method === 'HEAD') {
         return new RequestCtor(fullUrl, {
             method: nodeRequest.method,
-            headers: nodeRequest.headers,
+            headers: normalizedHeaders,
             signal,
         });
     }
@@ -154,14 +165,14 @@ function normalizeNodeRequest(nodeRequest, nodeResponse, RequestCtor) {
         if (isRequestBody(maybeParsedBody)) {
             return new RequestCtor(fullUrl, {
                 method: nodeRequest.method,
-                headers: nodeRequest.headers,
+                headers: normalizedHeaders,
                 body: maybeParsedBody,
                 signal,
             });
         }
         const request = new RequestCtor(fullUrl, {
             method: nodeRequest.method,
-            headers: nodeRequest.headers,
+            headers: normalizedHeaders,
             signal,
         });
         if (!request.headers.get('content-type')?.includes('json')) {
@@ -189,7 +200,7 @@ It will affect your performance. Please check our Bun integration recipe, and av
         }
         return new RequestCtor(fullUrl, {
             method: nodeRequest.method,
-            headers: nodeRequest.headers,
+            headers: normalizedHeaders,
             duplex: 'half',
             body: new ReadableStream({
                 start(controller) {
@@ -213,7 +224,7 @@ It will affect your performance. Please check our Bun integration recipe, and av
     // perf: instead of spreading the object, we can just pass it as is and it performs better
     return new RequestCtor(fullUrl, {
         method: nodeRequest.method,
-        headers: nodeRequest.headers,
+        headers: normalizedHeaders,
         body: rawRequest,
         duplex: 'half',
         signal,
@@ -341,13 +352,16 @@ function completeAssign(...args) {
         // modified Object.keys to Object.getOwnPropertyNames
         // because Object.keys only returns enumerable properties
         const descriptors = Object.getOwnPropertyNames(source).reduce((descriptors, key) => {
-            descriptors[key] = Object.getOwnPropertyDescriptor(source, key);
+            const descriptor = Object.getOwnPropertyDescriptor(source, key);
+            if (descriptor) {
+                descriptors[key] = Object.getOwnPropertyDescriptor(source, key);
+            }
             return descriptors;
         }, {});
         // By default, Object.assign copies enumerable Symbols, too
         Object.getOwnPropertySymbols(source).forEach(sym => {
             const descriptor = Object.getOwnPropertyDescriptor(source, sym);
-            if (descriptor.enumerable) {
+            if (descriptor?.enumerable) {
                 descriptors[sym] = descriptor;
             }
         });
@@ -496,3 +510,55 @@ function handleAbortSignalAndPromiseResponse(response$, abortSignal) {
     }
     return response$;
 }
+exports.decompressedResponseMap = new WeakMap();
+const supportedEncodingsByFetchAPI = new WeakMap();
+function getSupportedEncodings(fetchAPI) {
+    let supportedEncodings = supportedEncodingsByFetchAPI.get(fetchAPI);
+    if (!supportedEncodings) {
+        const possibleEncodings = ['deflate', 'gzip', 'deflate-raw', 'br'];
+        supportedEncodings = possibleEncodings.filter(encoding => {
+            // deflate-raw is not supported in Node.js >v20
+            if (globalThis.process?.version?.startsWith('v2') &&
+                fetchAPI.DecompressionStream === globalThis.DecompressionStream &&
+                encoding === 'deflate-raw') {
+                return false;
+            }
+            try {
+                // eslint-disable-next-line no-new
+                new fetchAPI.DecompressionStream(encoding);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        });
+        supportedEncodingsByFetchAPI.set(fetchAPI, supportedEncodings);
+    }
+    return supportedEncodings;
+}
+function handleResponseDecompression(response, fetchAPI) {
+    const contentEncodingHeader = response?.headers.get('content-encoding');
+    if (!contentEncodingHeader || contentEncodingHeader === 'none') {
+        return response;
+    }
+    if (!response?.body) {
+        return response;
+    }
+    let decompressedResponse = exports.decompressedResponseMap.get(response);
+    if (!decompressedResponse || decompressedResponse.bodyUsed) {
+        let decompressedBody = response.body;
+        const contentEncodings = contentEncodingHeader.split(',');
+        if (!contentEncodings.every(encoding => getSupportedEncodings(fetchAPI).includes(encoding))) {
+            return new fetchAPI.Response(`Unsupported 'Content-Encoding': ${contentEncodingHeader}`, {
+                status: 415,
+                statusText: 'Unsupported Media Type',
+            });
+        }
+        for (const contentEncoding of contentEncodings) {
+            decompressedBody = decompressedBody.pipeThrough(new fetchAPI.DecompressionStream(contentEncoding));
+        }
+        decompressedResponse = new fetchAPI.Response(decompressedBody, response);
+        exports.decompressedResponseMap.set(response, decompressedResponse);
+    }
+    return decompressedResponse;
+}

package/cjs/uwebsockets.js

@@ -10,18 +10,42 @@ function getRequestFromUWSRequest({ req, res, fetchAPI, signal }) {
     let body;
     const method = req.getMethod();
     if (method !== 'get' && method !== 'head') {
-        body = new fetchAPI.ReadableStream({});
-        const readable = body.readable;
-        signal.addEventListener('abort', () => {
-            readable.push(null);
+        let controller;
+        body = new fetchAPI.ReadableStream({
+            start(c) {
+                controller = c;
+            },
         });
-        res.onData(function (ab, isLast) {
-            const chunk = Buffer.from(ab, 0, ab.byteLength);
-            readable.push(Buffer.from(chunk));
-            if (isLast) {
+        const readable = body.readable;
+        if (readable) {
+            signal.addEventListener('abort', () => {
                 readable.push(null);
-            }
-        });
+            });
+            res.onData(function (ab, isLast) {
+                const chunk = Buffer.from(ab, 0, ab.byteLength);
+                readable.push(Buffer.from(chunk));
+                if (isLast) {
+                    readable.push(null);
+                }
+            });
+        }
+        else {
+            let closed = false;
+            signal.addEventListener('abort', () => {
+                if (!closed) {
+                    closed = true;
+                    controller.close();
+                }
+            });
+            res.onData(function (ab, isLast) {
+                const chunk = Buffer.from(ab, 0, ab.byteLength);
+                controller.enqueue(Buffer.from(chunk));
+                if (isLast) {
+                    closed = true;
+                    controller.close();
+                }
+            });
+        }
     }
     const headers = new fetchAPI.Headers();
     req.forEach((key, value) => {
@@ -37,6 +61,9 @@ function getRequestFromUWSRequest({ req, res, fetchAPI, signal }) {
         headers,
         body: body,
         signal,
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore - not in the TS types yet
+        duplex: 'half',
     });
 }
 async function forwardResponseBodyToUWSResponse(uwsResponse, fetchResponse, signal) {

package/esm/createServerAdapter.js

@@ -50,6 +50,9 @@ function createServerAdapter(serverAdapterBaseObject, options) {
             });
             const onRequestHooksIteration$ = iterateAsyncVoid(onRequestHooks, (onRequestHook, stopEarly) => onRequestHook({
                 request,
+                setRequest(newRequest) {
+                    request = newRequest;
+                },
                 serverContext,
                 fetchAPI,
                 url,
@@ -65,13 +68,17 @@ function createServerAdapter(serverAdapterBaseObject, options) {
                 },
             }));
             function handleResponse(response) {
-                if (onRequestHooks.length === 0) {
+                if (onResponseHooks.length === 0) {
                     return response;
                 }
                 const onResponseHookPayload = {
                     request,
                     response,
                     serverContext,
+                    setResponse(newResponse) {
+                        response = newResponse;
+                    },
+                    fetchAPI,
                 };
                 const onResponseHooksIteration$ = iterateAsyncVoid(onResponseHooks, onResponseHook => onResponseHook(onResponseHookPayload));
                 if (isPromise(onResponseHooksIteration$)) {
@@ -95,6 +102,7 @@ function createServerAdapter(serverAdapterBaseObject, options) {
             return handleEarlyResponse();
         }
         : givenHandleRequest;
+    // TODO: Remove this on the next major version
     function handleNodeRequestAndResponse(nodeRequest, nodeResponseOrContainer, ...ctx) {
         const nodeResponse = nodeResponseOrContainer.raw || nodeResponseOrContainer;
         const serverContext = ctx.length > 1 ? completeAssign(...ctx) : ctx[0] || {};

package/esm/index.js

@@ -4,5 +4,6 @@ export * from './utils.js';
 export * from './plugins/types.js';
 export * from './plugins/useCors.js';
 export * from './plugins/useErrorHandling.js';
+export * from './plugins/useContentEncoding.js';
 export * from './uwebsockets.js';
 export { Response } from '@whatwg-node/fetch';

package/esm/plugins/useContentEncoding.js

@@ -0,0 +1,104 @@
+import { decompressedResponseMap, getSupportedEncodings } from '../utils.js';
+export function useContentEncoding() {
+    const encodingMap = new WeakMap();
+    return {
+        onRequest({ request, setRequest, fetchAPI, endResponse }) {
+            if (request.body) {
+                const contentEncodingHeader = request.headers.get('content-encoding');
+                if (contentEncodingHeader && contentEncodingHeader !== 'none') {
+                    const contentEncodings = contentEncodingHeader?.split(',');
+                    if (!contentEncodings.every(encoding => getSupportedEncodings(fetchAPI).includes(encoding))) {
+                        endResponse(new fetchAPI.Response(`Unsupported 'Content-Encoding': ${contentEncodingHeader}`, {
+                            status: 415,
+                            statusText: 'Unsupported Media Type',
+                        }));
+                        return;
+                    }
+                    let newBody = request.body;
+                    for (const contentEncoding of contentEncodings) {
+                        newBody = newBody.pipeThrough(new fetchAPI.DecompressionStream(contentEncoding));
+                    }
+                    const newRequest = new fetchAPI.Request(request.url, {
+                        body: newBody,
+                        cache: request.cache,
+                        credentials: request.credentials,
+                        headers: request.headers,
+                        integrity: request.integrity,
+                        keepalive: request.keepalive,
+                        method: request.method,
+                        mode: request.mode,
+                        redirect: request.redirect,
+                        referrer: request.referrer,
+                        referrerPolicy: request.referrerPolicy,
+                        signal: request.signal,
+                        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                        // @ts-ignore - not in the TS types yet
+                        duplex: 'half',
+                    });
+                    setRequest(newRequest);
+                }
+            }
+            const acceptEncoding = request.headers.get('accept-encoding');
+            if (acceptEncoding) {
+                encodingMap.set(request, acceptEncoding.split(','));
+            }
+        },
+        onResponse({ request, response, setResponse, fetchAPI }) {
+            // Hack for avoiding to create whatwg-node to create a readable stream until it's needed
+            if (response['bodyInit'] || response.body) {
+                const encodings = encodingMap.get(request);
+                if (encodings) {
+                    const supportedEncoding = encodings.find(encoding => 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();
+                                writer.write(bufOfRes);
+                                writer.close();
+                                const reader = compressionStream.readable.getReader();
+                                return Promise.resolve().then(async () => {
+                                    const chunks = [];
+                                    while (true) {
+                                        const { done, value } = await reader.read();
+                                        if (done) {
+                                            reader.releaseLock();
+                                            break;
+                                        }
+                                        else if (value) {
+                                            chunks.push(...value);
+                                        }
+                                    }
+                                    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,
+                                    });
+                                    decompressedResponseMap.set(compressedResponse, response);
+                                    setResponse(compressedResponse);
+                                });
+                            }
+                        }
+                        const newHeaders = new fetchAPI.Headers(response.headers);
+                        newHeaders.set('content-encoding', supportedEncoding);
+                        newHeaders.delete('content-length');
+                        const compressedBody = response.body.pipeThrough(compressionStream);
+                        const compressedResponse = new fetchAPI.Response(compressedBody, {
+                            status: response.status,
+                            statusText: response.statusText,
+                            headers: newHeaders,
+                        });
+                        decompressedResponseMap.set(compressedResponse, response);
+                        setResponse(compressedResponse);
+                    }
+                }
+            }
+        },
+    };
+}

package/esm/utils.js

@@ -92,7 +92,16 @@ export function normalizeNodeRequest(nodeRequest, nodeResponse, RequestCtor) {
         fullUrl = url.toString();
     }
     let signal;
-    if (nodeResponse.once) {
+    let normalizedHeaders = nodeRequest.headers;
+    if (nodeRequest.headers?.[':method']) {
+        normalizedHeaders = {};
+        for (const key in nodeRequest.headers) {
+            if (!key.startsWith(':')) {
+                normalizedHeaders[key] = nodeRequest.headers[key];
+            }
+        }
+    }
+    if (nodeResponse?.once) {
         let sendAbortSignal;
         // If ponyfilled
         if (RequestCtor !== globalThis.Request) {
@@ -119,7 +128,7 @@ export function normalizeNodeRequest(nodeRequest, nodeResponse, RequestCtor) {
     if (nodeRequest.method === 'GET' || nodeRequest.method === 'HEAD') {
         return new RequestCtor(fullUrl, {
             method: nodeRequest.method,
-            headers: nodeRequest.headers,
+            headers: normalizedHeaders,
             signal,
         });
     }
@@ -134,14 +143,14 @@ export function normalizeNodeRequest(nodeRequest, nodeResponse, RequestCtor) {
         if (isRequestBody(maybeParsedBody)) {
             return new RequestCtor(fullUrl, {
                 method: nodeRequest.method,
-                headers: nodeRequest.headers,
+                headers: normalizedHeaders,
                 body: maybeParsedBody,
                 signal,
             });
         }
         const request = new RequestCtor(fullUrl, {
             method: nodeRequest.method,
-            headers: nodeRequest.headers,
+            headers: normalizedHeaders,
             signal,
         });
         if (!request.headers.get('content-type')?.includes('json')) {
@@ -169,7 +178,7 @@ It will affect your performance. Please check our Bun integration recipe, and av
         }
         return new RequestCtor(fullUrl, {
             method: nodeRequest.method,
-            headers: nodeRequest.headers,
+            headers: normalizedHeaders,
             duplex: 'half',
             body: new ReadableStream({
                 start(controller) {
@@ -193,7 +202,7 @@ It will affect your performance. Please check our Bun integration recipe, and av
     // perf: instead of spreading the object, we can just pass it as is and it performs better
     return new RequestCtor(fullUrl, {
         method: nodeRequest.method,
-        headers: nodeRequest.headers,
+        headers: normalizedHeaders,
         body: rawRequest,
         duplex: 'half',
         signal,
@@ -321,13 +330,16 @@ export function completeAssign(...args) {
         // modified Object.keys to Object.getOwnPropertyNames
         // because Object.keys only returns enumerable properties
         const descriptors = Object.getOwnPropertyNames(source).reduce((descriptors, key) => {
-            descriptors[key] = Object.getOwnPropertyDescriptor(source, key);
+            const descriptor = Object.getOwnPropertyDescriptor(source, key);
+            if (descriptor) {
+                descriptors[key] = Object.getOwnPropertyDescriptor(source, key);
+            }
             return descriptors;
         }, {});
         // By default, Object.assign copies enumerable Symbols, too
         Object.getOwnPropertySymbols(source).forEach(sym => {
             const descriptor = Object.getOwnPropertyDescriptor(source, sym);
-            if (descriptor.enumerable) {
+            if (descriptor?.enumerable) {
                 descriptors[sym] = descriptor;
             }
         });
@@ -476,3 +488,55 @@ export function handleAbortSignalAndPromiseResponse(response$, abortSignal) {
     }
     return response$;
 }
+export const decompressedResponseMap = new WeakMap();
+const supportedEncodingsByFetchAPI = new WeakMap();
+export function getSupportedEncodings(fetchAPI) {
+    let supportedEncodings = supportedEncodingsByFetchAPI.get(fetchAPI);
+    if (!supportedEncodings) {
+        const possibleEncodings = ['deflate', 'gzip', 'deflate-raw', 'br'];
+        supportedEncodings = possibleEncodings.filter(encoding => {
+            // deflate-raw is not supported in Node.js >v20
+            if (globalThis.process?.version?.startsWith('v2') &&
+                fetchAPI.DecompressionStream === globalThis.DecompressionStream &&
+                encoding === 'deflate-raw') {
+                return false;
+            }
+            try {
+                // eslint-disable-next-line no-new
+                new fetchAPI.DecompressionStream(encoding);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        });
+        supportedEncodingsByFetchAPI.set(fetchAPI, supportedEncodings);
+    }
+    return supportedEncodings;
+}
+export function handleResponseDecompression(response, fetchAPI) {
+    const contentEncodingHeader = response?.headers.get('content-encoding');
+    if (!contentEncodingHeader || contentEncodingHeader === 'none') {
+        return response;
+    }
+    if (!response?.body) {
+        return response;
+    }
+    let decompressedResponse = decompressedResponseMap.get(response);
+    if (!decompressedResponse || decompressedResponse.bodyUsed) {
+        let decompressedBody = response.body;
+        const contentEncodings = contentEncodingHeader.split(',');
+        if (!contentEncodings.every(encoding => getSupportedEncodings(fetchAPI).includes(encoding))) {
+            return new fetchAPI.Response(`Unsupported 'Content-Encoding': ${contentEncodingHeader}`, {
+                status: 415,
+                statusText: 'Unsupported Media Type',
+            });
+        }
+        for (const contentEncoding of contentEncodings) {
+            decompressedBody = decompressedBody.pipeThrough(new fetchAPI.DecompressionStream(contentEncoding));
+        }
+        decompressedResponse = new fetchAPI.Response(decompressedBody, response);
+        decompressedResponseMap.set(response, decompressedResponse);
+    }
+    return decompressedResponse;
+}

package/esm/uwebsockets.js

@@ -5,18 +5,42 @@ export function getRequestFromUWSRequest({ req, res, fetchAPI, signal }) {
     let body;
     const method = req.getMethod();
     if (method !== 'get' && method !== 'head') {
-        body = new fetchAPI.ReadableStream({});
-        const readable = body.readable;
-        signal.addEventListener('abort', () => {
-            readable.push(null);
+        let controller;
+        body = new fetchAPI.ReadableStream({
+            start(c) {
+                controller = c;
+            },
         });
-        res.onData(function (ab, isLast) {
-            const chunk = Buffer.from(ab, 0, ab.byteLength);
-            readable.push(Buffer.from(chunk));
-            if (isLast) {
+        const readable = body.readable;
+        if (readable) {
+            signal.addEventListener('abort', () => {
                 readable.push(null);
-            }
-        });
+            });
+            res.onData(function (ab, isLast) {
+                const chunk = Buffer.from(ab, 0, ab.byteLength);
+                readable.push(Buffer.from(chunk));
+                if (isLast) {
+                    readable.push(null);
+                }
+            });
+        }
+        else {
+            let closed = false;
+            signal.addEventListener('abort', () => {
+                if (!closed) {
+                    closed = true;
+                    controller.close();
+                }
+            });
+            res.onData(function (ab, isLast) {
+                const chunk = Buffer.from(ab, 0, ab.byteLength);
+                controller.enqueue(Buffer.from(chunk));
+                if (isLast) {
+                    closed = true;
+                    controller.close();
+                }
+            });
+        }
     }
     const headers = new fetchAPI.Headers();
     req.forEach((key, value) => {
@@ -32,6 +56,9 @@ export function getRequestFromUWSRequest({ req, res, fetchAPI, signal }) {
         headers,
         body: body,
         signal,
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore - not in the TS types yet
+        duplex: 'half',
     });
 }
 async function forwardResponseBodyToUWSResponse(uwsResponse, fetchResponse, signal) {

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@whatwg-node/server",
-  "version": "0.10.0-alpha-20240717144936-662ea5088eb83ec5b55025307193fac81a8ea190",
+  "version": "0.10.0-alpha-20240726141316-c6ce93b3598457ebe73b3b725986723af8f5e609",
   "description": "Fetch API compliant HTTP Server adapter",
   "sideEffects": false,
   "dependencies": {
-    "@whatwg-node/fetch": "^0.9.17",
+    "@whatwg-node/fetch": "^0.9.19",
     "tslib": "^2.6.3"
   },
   "repository": {

package/typings/index.d.cts

@@ -4,5 +4,6 @@ export * from './utils.cjs';
 export * from './plugins/types.cjs';
 export * from './plugins/useCors.cjs';
 export * from './plugins/useErrorHandling.cjs';
+export * from './plugins/useContentEncoding.cjs';
 export * from './uwebsockets.cjs';
 export { Response } from '@whatwg-node/fetch';

package/typings/index.d.ts

@@ -4,5 +4,6 @@ export * from './utils.js';
 export * from './plugins/types.js';
 export * from './plugins/useCors.js';
 export * from './plugins/useErrorHandling.js';
+export * from './plugins/useContentEncoding.js';
 export * from './uwebsockets.js';
 export { Response } from '@whatwg-node/fetch';

package/typings/plugins/types.d.cts

@@ -6,7 +6,8 @@ export interface ServerAdapterPlugin<TServerContext = {}> {
 export type OnRequestHook<TServerContext> = (payload: OnRequestEventPayload<TServerContext>) => Promise<void> | void;
 export interface OnRequestEventPayload<TServerContext> {
     request: Request;
-    serverContext: TServerContext | undefined;
+    setRequest(newRequest: Request): void;
+    serverContext: TServerContext;
     fetchAPI: FetchAPI;
     requestHandler: ServerAdapterRequestHandler<TServerContext>;
     setRequestHandler(newRequestHandler: ServerAdapterRequestHandler<TServerContext>): void;
@@ -16,6 +17,8 @@ export interface OnRequestEventPayload<TServerContext> {
 export type OnResponseHook<TServerContext> = (payload: OnResponseEventPayload<TServerContext>) => Promise<void> | void;
 export interface OnResponseEventPayload<TServerContext> {
     request: Request;
-    serverContext: TServerContext | undefined;
+    serverContext: TServerContext;
     response: Response;
+    setResponse(newResponse: Response): void;
+    fetchAPI: FetchAPI;
 }

package/typings/plugins/types.d.ts

@@ -6,7 +6,8 @@ export interface ServerAdapterPlugin<TServerContext = {}> {
 export type OnRequestHook<TServerContext> = (payload: OnRequestEventPayload<TServerContext>) => Promise<void> | void;
 export interface OnRequestEventPayload<TServerContext> {
     request: Request;
-    serverContext: TServerContext | undefined;
+    setRequest(newRequest: Request): void;
+    serverContext: TServerContext;
     fetchAPI: FetchAPI;
     requestHandler: ServerAdapterRequestHandler<TServerContext>;
     setRequestHandler(newRequestHandler: ServerAdapterRequestHandler<TServerContext>): void;
@@ -16,6 +17,8 @@ export interface OnRequestEventPayload<TServerContext> {
 export type OnResponseHook<TServerContext> = (payload: OnResponseEventPayload<TServerContext>) => Promise<void> | void;
 export interface OnResponseEventPayload<TServerContext> {
     request: Request;
-    serverContext: TServerContext | undefined;
+    serverContext: TServerContext;
     response: Response;
+    setResponse(newResponse: Response): void;
+    fetchAPI: FetchAPI;
 }

package/typings/plugins/useContentEncoding.d.cts

@@ -0,0 +1,2 @@
+import type { ServerAdapterPlugin } from './types.cjs';
+export declare function useContentEncoding<TServerContext>(): ServerAdapterPlugin<TServerContext>;

package/typings/plugins/useContentEncoding.d.ts

@@ -0,0 +1,2 @@
+import type { ServerAdapterPlugin } from './types.js';
+export declare function useContentEncoding<TServerContext>(): ServerAdapterPlugin<TServerContext>;

package/typings/plugins/useErrorHandling.d.cts

@@ -4,9 +4,9 @@ export declare class HTTPError extends Error {
     status: number;
     message: string;
     headers: HeadersInit;
-    details?: any | undefined;
+    details?: any;
     name: string;
-    constructor(status: number, message: string, headers?: HeadersInit, details?: any | undefined);
+    constructor(status: number, message: string, headers?: HeadersInit, details?: any);
 }
 export type ErrorHandler<TServerContext> = (e: any, request: Request, ctx: TServerContext) => Response | Promise<Response>;
 export declare function useErrorHandling<TServerContext>(onError?: ErrorHandler<TServerContext>): ServerAdapterPlugin<TServerContext>;

package/typings/plugins/useErrorHandling.d.ts

@@ -4,9 +4,9 @@ export declare class HTTPError extends Error {
     status: number;
     message: string;
     headers: HeadersInit;
-    details?: any | undefined;
+    details?: any;
     name: string;
-    constructor(status: number, message: string, headers?: HeadersInit, details?: any | undefined);
+    constructor(status: number, message: string, headers?: HeadersInit, details?: any);
 }
 export type ErrorHandler<TServerContext> = (e: any, request: Request, ctx: TServerContext) => Response | Promise<Response>;
 export declare function useErrorHandling<TServerContext>(onError?: ErrorHandler<TServerContext>): ServerAdapterPlugin<TServerContext>;

package/typings/utils.d.cts

@@ -2,7 +2,7 @@ import type { IncomingMessage, ServerResponse } from 'http';
 import type { Http2ServerRequest, Http2ServerResponse } from 'http2';
 import type { Socket } from 'net';
 import type { Readable } from 'stream';
-import type { FetchEvent } from './types.cjs';
+import type { FetchAPI, FetchEvent } from './types.cjs';
 export declare function isAsyncIterable(body: any): body is AsyncIterable<any>;
 export interface NodeRequest {
     protocol?: string;
@@ -50,3 +50,6 @@ export interface DeferredPromise<T = void> {
 }
 export declare function createDeferredPromise<T = void>(): DeferredPromise<T>;
 export declare function handleAbortSignalAndPromiseResponse(response$: Promise<Response> | Response, abortSignal?: AbortSignal | null): Response | Promise<Response>;
+export declare const decompressedResponseMap: WeakMap<Response, Response>;
+export declare function getSupportedEncodings(fetchAPI: FetchAPI): CompressionFormat[];
+export declare function handleResponseDecompression(response: Response, fetchAPI: FetchAPI): Response;

package/typings/utils.d.ts

@@ -2,7 +2,7 @@ import type { IncomingMessage, ServerResponse } from 'http';
 import type { Http2ServerRequest, Http2ServerResponse } from 'http2';
 import type { Socket } from 'net';
 import type { Readable } from 'stream';
-import type { FetchEvent } from './types.js';
+import type { FetchAPI, FetchEvent } from './types.js';
 export declare function isAsyncIterable(body: any): body is AsyncIterable<any>;
 export interface NodeRequest {
     protocol?: string;
@@ -50,3 +50,6 @@ export interface DeferredPromise<T = void> {
 }
 export declare function createDeferredPromise<T = void>(): DeferredPromise<T>;
 export declare function handleAbortSignalAndPromiseResponse(response$: Promise<Response> | Response, abortSignal?: AbortSignal | null): Response | Promise<Response>;
+export declare const decompressedResponseMap: WeakMap<Response, Response>;
+export declare function getSupportedEncodings(fetchAPI: FetchAPI): CompressionFormat[];
+export declare function handleResponseDecompression(response: Response, fetchAPI: FetchAPI): Response;