@whatwg-node/server 0.10.0-alpha-20240717150008-1474b9d9b679a0e8f6225f44f11b95a6f4bf24ea → 0.10.0-alpha-20241123133536-975c9068dde45574fcfa26567e4bab96f45d1f85

package/esm/utils.js

@@ -1,4 +1,3 @@
-import { URL } from '@whatwg-node/fetch';
 export function isAsyncIterable(body) {
     return (body != null && typeof body === 'object' && typeof body[Symbol.asyncIterator] === 'function');
 }
@@ -49,11 +48,9 @@ function isRequestBody(body) {
     return false;
 }
 export class ServerAdapterRequestAbortSignal extends EventTarget {
-    constructor() {
-        super(...arguments);
-        this.aborted = false;
-        this._onabort = null;
-    }
+    aborted = false;
+    _onabort = null;
+    reason;
     throwIfAborted() {
         if (this.aborted) {
             throw this.reason;
@@ -81,22 +78,36 @@ export class ServerAdapterRequestAbortSignal extends EventTarget {
     }
 }
 let bunNodeCompatModeWarned = false;
-export function normalizeNodeRequest(nodeRequest, nodeResponse, RequestCtor) {
+export const nodeRequestResponseMap = new WeakMap();
+export function normalizeNodeRequest(nodeRequest, fetchAPI, registerSignal) {
     const rawRequest = nodeRequest.raw || nodeRequest.req || nodeRequest;
     let fullUrl = buildFullUrl(rawRequest);
     if (nodeRequest.query) {
-        const url = new URL(fullUrl);
+        const url = new fetchAPI.URL(fullUrl);
         for (const key in nodeRequest.query) {
             url.searchParams.set(key, nodeRequest.query[key]);
         }
         fullUrl = url.toString();
     }
     let signal;
-    if (nodeResponse.once) {
+    const nodeResponse = nodeRequestResponseMap.get(nodeRequest);
+    nodeRequestResponseMap.delete(nodeRequest);
+    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) {
-            signal = new ServerAdapterRequestAbortSignal();
+        if (fetchAPI.Request !== globalThis.Request) {
+            const newSignal = new ServerAdapterRequestAbortSignal();
+            registerSignal?.(newSignal);
+            signal = newSignal;
             sendAbortSignal = () => signal.sendAbort();
         }
         else {
@@ -117,9 +128,9 @@ export function normalizeNodeRequest(nodeRequest, nodeResponse, RequestCtor) {
         });
     }
     if (nodeRequest.method === 'GET' || nodeRequest.method === 'HEAD') {
-        return new RequestCtor(fullUrl, {
+        return new fetchAPI.Request(fullUrl, {
             method: nodeRequest.method,
-            headers: nodeRequest.headers,
+            headers: normalizedHeaders,
             signal,
         });
     }
@@ -132,16 +143,16 @@ export function normalizeNodeRequest(nodeRequest, nodeResponse, RequestCtor) {
     const maybeParsedBody = nodeRequest.body;
     if (maybeParsedBody != null && Object.keys(maybeParsedBody).length > 0) {
         if (isRequestBody(maybeParsedBody)) {
-            return new RequestCtor(fullUrl, {
+            return new fetchAPI.Request(fullUrl, {
                 method: nodeRequest.method,
-                headers: nodeRequest.headers,
+                headers: normalizedHeaders,
                 body: maybeParsedBody,
                 signal,
             });
         }
-        const request = new RequestCtor(fullUrl, {
+        const request = new fetchAPI.Request(fullUrl, {
             method: nodeRequest.method,
-            headers: nodeRequest.headers,
+            headers: normalizedHeaders,
             signal,
         });
         if (!request.headers.get('content-type')?.includes('json')) {
@@ -167,9 +178,9 @@ export function normalizeNodeRequest(nodeRequest, nodeResponse, RequestCtor) {
             console.warn(`You use Bun Node compatibility mode, which is not recommended!
 It will affect your performance. Please check our Bun integration recipe, and avoid using 'http' for your server implementation.`);
         }
-        return new RequestCtor(fullUrl, {
+        return new fetchAPI.Request(fullUrl, {
             method: nodeRequest.method,
-            headers: nodeRequest.headers,
+            headers: normalizedHeaders,
             duplex: 'half',
             body: new ReadableStream({
                 start(controller) {
@@ -191,9 +202,9 @@ 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, {
+    return new fetchAPI.Request(fullUrl, {
         method: nodeRequest.method,
-        headers: nodeRequest.headers,
+        headers: normalizedHeaders,
         body: rawRequest,
         duplex: 'half',
         signal,
@@ -229,11 +240,26 @@ function endResponse(serverResponse) {
     serverResponse.end(null, null, null);
 }
 async function sendAsyncIterable(serverResponse, asyncIterable) {
+    let closed = false;
+    const closeEventListener = () => {
+        closed = true;
+    };
+    serverResponse.once('error', closeEventListener);
+    serverResponse.once('close', closeEventListener);
+    serverResponse.once('finish', () => {
+        serverResponse.removeListener('close', closeEventListener);
+    });
     for await (const chunk of asyncIterable) {
+        if (closed) {
+            break;
+        }
         if (!serverResponse
             // @ts-expect-error http and http2 writes are actually compatible
             .write(chunk)) {
-            break;
+            if (closed) {
+                break;
+            }
+            await new Promise(resolve => serverResponse.once('drain', resolve));
         }
     }
     endResponse(serverResponse);
@@ -244,7 +270,7 @@ export function sendNodeResponse(fetchResponse, serverResponse, nodeRequest) {
     }
     if (!fetchResponse) {
         serverResponse.statusCode = 404;
-        serverResponse.end();
+        endResponse(serverResponse);
         return;
     }
     serverResponse.statusCode = fetchResponse.status;
@@ -293,10 +319,31 @@ export function sendNodeResponse(fetchResponse, serverResponse, nodeRequest) {
         fetchBody.pipe(serverResponse);
         return;
     }
+    if (isReadableStream(fetchBody)) {
+        return sendReadableStream(serverResponse, fetchBody);
+    }
     if (isAsyncIterable(fetchBody)) {
         return sendAsyncIterable(serverResponse, fetchBody);
     }
 }
+async function sendReadableStream(serverResponse, readableStream) {
+    const reader = readableStream.getReader();
+    serverResponse.req.once('error', err => {
+        reader.cancel(err);
+    });
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+            break;
+        }
+        if (!serverResponse
+            // @ts-expect-error http and http2 writes are actually compatible
+            .write(value)) {
+            await new Promise(resolve => serverResponse.once('drain', resolve));
+        }
+    }
+    endResponse(serverResponse);
+}
 export function isRequestInit(val) {
     return (val != null &&
         typeof val === 'object' &&
@@ -321,13 +368,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;
             }
         });
@@ -370,77 +420,18 @@ export function handleErrorFromRequestHandler(error, ResponseCtor) {
         status: error.status || 500,
     });
 }
-export function isolateObject(originalCtx, waitUntilPromises) {
+export function isolateObject(originalCtx, waitUntilFn) {
     if (originalCtx == null) {
-        return {};
-    }
-    const extraProps = {};
-    const deletedProps = new Set();
-    return new Proxy(originalCtx, {
-        get(originalCtx, prop) {
-            if (waitUntilPromises != null && prop === 'waitUntil') {
-                return function waitUntil(promise) {
-                    waitUntilPromises.push(promise.catch(err => console.error(err)));
-                };
-            }
-            const extraPropVal = extraProps[prop];
-            if (extraPropVal != null) {
-                if (typeof extraPropVal === 'function') {
-                    return extraPropVal.bind(extraProps);
-                }
-                return extraPropVal;
-            }
-            if (deletedProps.has(prop)) {
-                return undefined;
-            }
-            return originalCtx[prop];
-        },
-        set(_originalCtx, prop, value) {
-            extraProps[prop] = value;
-            return true;
-        },
-        has(originalCtx, prop) {
-            if (waitUntilPromises != null && prop === 'waitUntil') {
-                return true;
-            }
-            if (deletedProps.has(prop)) {
-                return false;
-            }
-            if (prop in extraProps) {
-                return true;
-            }
-            return prop in originalCtx;
-        },
-        defineProperty(_originalCtx, prop, descriptor) {
-            return Reflect.defineProperty(extraProps, prop, descriptor);
-        },
-        deleteProperty(_originalCtx, prop) {
-            if (prop in extraProps) {
-                return Reflect.deleteProperty(extraProps, prop);
-            }
-            deletedProps.add(prop);
-            return true;
-        },
-        ownKeys(originalCtx) {
-            const extraKeys = Reflect.ownKeys(extraProps);
-            const originalKeys = Reflect.ownKeys(originalCtx);
-            const deletedKeys = Array.from(deletedProps);
-            const allKeys = new Set(extraKeys.concat(originalKeys.filter(keys => !deletedKeys.includes(keys))));
-            if (waitUntilPromises != null) {
-                allKeys.add('waitUntil');
-            }
-            return Array.from(allKeys);
-        },
-        getOwnPropertyDescriptor(originalCtx, prop) {
-            if (prop in extraProps) {
-                return Reflect.getOwnPropertyDescriptor(extraProps, prop);
-            }
-            if (deletedProps.has(prop)) {
-                return undefined;
-            }
-            return Reflect.getOwnPropertyDescriptor(originalCtx, prop);
-        },
-    });
+        if (waitUntilFn == null) {
+            return {};
+        }
+        return {
+            waitUntil: waitUntilFn,
+        };
+    }
+    return completeAssign(Object.create(originalCtx), {
+        waitUntil: waitUntilFn,
+    }, originalCtx);
 }
 export function createDeferredPromise() {
     let resolveFn;
@@ -476,3 +467,87 @@ 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'];
+        if (fetchAPI.DecompressionStream?.['supportedFormats']) {
+            supportedEncodings = fetchAPI.DecompressionStream['supportedFormats'];
+        }
+        else {
+            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;
+}
+const terminateEvents = ['SIGINT', 'SIGTERM', 'exit'];
+const disposableStacks = new Set();
+let eventListenerRegistered = false;
+function ensureEventListenerForDisposableStacks() {
+    if (eventListenerRegistered) {
+        return;
+    }
+    eventListenerRegistered = true;
+    for (const event of terminateEvents) {
+        globalThis.process.once(event, function terminateHandler() {
+            return Promise.allSettled([...disposableStacks].map(stack => stack.disposeAsync().catch(e => {
+                console.error('Error while disposing:', e);
+            })));
+        });
+    }
+}
+export function ensureDisposableStackRegisteredForTerminateEvents(disposableStack) {
+    if (globalThis.process) {
+        ensureEventListenerForDisposableStacks();
+        if (!disposableStacks.has(disposableStack)) {
+            disposableStacks.add(disposableStack);
+            disposableStack.defer(() => {
+                disposableStacks.delete(disposableStack);
+            });
+        }
+    }
+}

package/esm/uwebsockets.js

@@ -1,22 +1,69 @@
+import { isPromise } from './utils.js';
 export function isUWSResponse(res) {
     return !!res.onData;
 }
 export function getRequestFromUWSRequest({ req, res, fetchAPI, signal }) {
-    let body;
     const method = req.getMethod();
+    let duplex;
+    const chunks = [];
+    const pushFns = [
+        (chunk) => {
+            chunks.push(chunk);
+        },
+    ];
+    const push = (chunk) => {
+        for (const pushFn of pushFns) {
+            pushFn(chunk);
+        }
+    };
+    let stopped = false;
+    const stopFns = [
+        () => {
+            stopped = true;
+        },
+    ];
+    const stop = () => {
+        for (const stopFn of stopFns) {
+            stopFn();
+        }
+    };
+    res.onData(function (ab, isLast) {
+        push(Buffer.from(Buffer.from(ab, 0, ab.byteLength)));
+        if (isLast) {
+            stop();
+        }
+    });
+    let getReadableStream;
     if (method !== 'get' && method !== 'head') {
-        body = new fetchAPI.ReadableStream({});
-        const readable = body.readable;
+        duplex = 'half';
         signal.addEventListener('abort', () => {
-            readable.push(null);
+            stop();
         });
-        res.onData(function (ab, isLast) {
-            const chunk = Buffer.from(ab, 0, ab.byteLength);
-            readable.push(Buffer.from(chunk));
-            if (isLast) {
-                readable.push(null);
+        let readableStream;
+        getReadableStream = () => {
+            if (!readableStream) {
+                readableStream = new fetchAPI.ReadableStream({
+                    start(controller) {
+                        for (const chunk of chunks) {
+                            controller.enqueue(chunk);
+                        }
+                        if (stopped) {
+                            controller.close();
+                            return;
+                        }
+                        pushFns.push((chunk) => {
+                            controller.enqueue(chunk);
+                        });
+                        stopFns.push(() => {
+                            if (controller.desiredSize) {
+                                controller.close();
+                            }
+                        });
+                    },
+                });
             }
-        });
+            return readableStream;
+        };
     }
     const headers = new fetchAPI.Headers();
     req.forEach((key, value) => {
@@ -27,27 +74,97 @@ export function getRequestFromUWSRequest({ req, res, fetchAPI, signal }) {
     if (query) {
         url += `?${query}`;
     }
-    return new fetchAPI.Request(url, {
+    let buffer;
+    function getBody() {
+        if (!getReadableStream) {
+            return null;
+        }
+        if (stopped) {
+            return getBufferFromChunks();
+        }
+        return getReadableStream();
+    }
+    const request = new fetchAPI.Request(url, {
         method,
         headers,
-        body: body,
+        get body() {
+            return getBody();
+        },
         signal,
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore - not in the TS types yet
+        duplex,
     });
-}
-async function forwardResponseBodyToUWSResponse(uwsResponse, fetchResponse, signal) {
-    for await (const chunk of fetchResponse.body) {
-        if (signal.aborted) {
-            return;
+    function getBufferFromChunks() {
+        if (!buffer) {
+            buffer = chunks.length === 1 ? chunks[0] : Buffer.concat(chunks);
         }
-        uwsResponse.cork(() => {
-            uwsResponse.write(chunk);
+        return buffer;
+    }
+    function collectBuffer() {
+        if (stopped) {
+            return fakePromise(getBufferFromChunks());
+        }
+        return new Promise((resolve, reject) => {
+            try {
+                stopFns.push(() => {
+                    resolve(getBufferFromChunks());
+                });
+            }
+            catch (e) {
+                reject(e);
+            }
         });
     }
-    uwsResponse.cork(() => {
-        uwsResponse.end();
+    Object.defineProperties(request, {
+        body: {
+            get() {
+                return getBody();
+            },
+            configurable: true,
+            enumerable: true,
+        },
+        json: {
+            value() {
+                return collectBuffer()
+                    .then(b => b.toString('utf8'))
+                    .then(t => JSON.parse(t));
+            },
+            configurable: true,
+            enumerable: true,
+        },
+        text: {
+            value() {
+                return collectBuffer().then(b => b.toString('utf8'));
+            },
+            configurable: true,
+            enumerable: true,
+        },
+        arrayBuffer: {
+            value() {
+                return collectBuffer();
+            },
+            configurable: true,
+            enumerable: true,
+        },
+    });
+    return request;
+}
+export function createWritableFromUWS(uwsResponse, fetchAPI) {
+    return new fetchAPI.WritableStream({
+        write(chunk) {
+            uwsResponse.cork(() => {
+                uwsResponse.write(chunk);
+            });
+        },
+        close() {
+            uwsResponse.cork(() => {
+                uwsResponse.end();
+            });
+        },
     });
 }
-export function sendResponseToUwsOpts(uwsResponse, fetchResponse, signal) {
+export function sendResponseToUwsOpts(uwsResponse, fetchResponse, signal, fetchAPI) {
     if (!fetchResponse) {
         uwsResponse.writeStatus('404 Not Found');
         uwsResponse.end();
@@ -77,13 +194,59 @@ export function sendResponseToUwsOpts(uwsResponse, fetchResponse, signal) {
         if (bufferOfRes) {
             uwsResponse.end(bufferOfRes);
         }
+        else if (!fetchResponse.body) {
+            uwsResponse.end();
+        }
     });
-    if (bufferOfRes) {
+    if (bufferOfRes || !fetchResponse.body) {
         return;
     }
-    if (!fetchResponse.body) {
-        uwsResponse.end();
-        return;
+    signal.addEventListener('abort', () => {
+        if (!fetchResponse.body?.locked) {
+            fetchResponse.body?.cancel(signal.reason);
+        }
+    });
+    return fetchResponse.body
+        .pipeTo(createWritableFromUWS(uwsResponse, fetchAPI), {
+        signal,
+    })
+        .catch(err => {
+        if (signal.aborted) {
+            return;
+        }
+        throw err;
+    });
+}
+export function fakePromise(value) {
+    if (isPromise(value)) {
+        return value;
     }
-    return forwardResponseBodyToUWSResponse(uwsResponse, fetchResponse, signal);
+    // Write a fake promise to avoid the promise constructor
+    // being called with `new Promise` in the browser.
+    return {
+        then(resolve) {
+            if (resolve) {
+                const callbackResult = resolve(value);
+                if (isPromise(callbackResult)) {
+                    return callbackResult;
+                }
+                return fakePromise(callbackResult);
+            }
+            return this;
+        },
+        catch() {
+            return this;
+        },
+        finally(cb) {
+            if (cb) {
+                const callbackResult = cb();
+                if (isPromise(callbackResult)) {
+                    return callbackResult.then(() => value);
+                }
+                return fakePromise(value);
+            }
+            return this;
+        },
+        [Symbol.toStringTag]: 'Promise',
+    };
 }

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@whatwg-node/server",
-  "version": "0.10.0-alpha-20240717150008-1474b9d9b679a0e8f6225f44f11b95a6f4bf24ea",
+  "version": "0.10.0-alpha-20241123133536-975c9068dde45574fcfa26567e4bab96f45d1f85",
   "description": "Fetch API compliant HTTP Server adapter",
   "sideEffects": false,
   "dependencies": {
-    "@whatwg-node/fetch": "^0.9.17",
+    "@whatwg-node/disposablestack": "^0.0.5",
+    "@whatwg-node/fetch": "^0.10.0",
     "tslib": "^2.6.3"
   },
   "repository": {
@@ -15,7 +16,7 @@
   "author": "Arda TANRIKULU <ardatanrikulu@gmail.com>",
   "license": "MIT",
   "engines": {
-    "node": ">=16.0.0"
+    "node": ">=18.0.0"
   },
   "main": "cjs/index.js",
   "module": "esm/index.js",

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,6 +6,7 @@ export interface ServerAdapterPlugin<TServerContext = {}> {
 export type OnRequestHook<TServerContext> = (payload: OnRequestEventPayload<TServerContext>) => Promise<void> | void;
 export interface OnRequestEventPayload<TServerContext> {
     request: Request;
+    setRequest(newRequest: Request): void;
     serverContext: TServerContext;
     fetchAPI: FetchAPI;
     requestHandler: ServerAdapterRequestHandler<TServerContext>;
@@ -18,4 +19,6 @@ export interface OnResponseEventPayload<TServerContext> {
     request: Request;
     serverContext: TServerContext;
     response: Response;
+    setResponse(newResponse: Response): void;
+    fetchAPI: FetchAPI;
 }