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

package/esm/createServerAdapter.js

@@ -1,10 +1,8 @@
 /* eslint-disable @typescript-eslint/ban-types */
+import { AsyncDisposableStack, DisposableSymbols } from '@whatwg-node/disposablestack';
 import * as DefaultFetchAPI from '@whatwg-node/fetch';
-import { completeAssign, handleAbortSignalAndPromiseResponse, handleErrorFromRequestHandler, isFetchEvent, isNodeRequest, isolateObject, isPromise, isRequestInit, isServerResponse, iterateAsyncVoid, normalizeNodeRequest, sendNodeResponse, ServerAdapterRequestAbortSignal, } from './utils.js';
+import { completeAssign, ensureDisposableStackRegisteredForTerminateEvents, handleAbortSignalAndPromiseResponse, handleErrorFromRequestHandler, isFetchEvent, isNodeRequest, isolateObject, isPromise, isRequestInit, isServerResponse, iterateAsyncVoid, nodeRequestResponseMap, normalizeNodeRequest, sendNodeResponse, ServerAdapterRequestAbortSignal, } from './utils.js';
 import { getRequestFromUWSRequest, isUWSResponse, sendResponseToUwsOpts, } from './uwebsockets.js';
-async function handleWaitUntils(waitUntilPromises) {
-    await Promise.allSettled(waitUntilPromises);
-}
 // Required for envs like nextjs edge runtime
 function isRequestAccessible(serverContext) {
     try {
@@ -25,6 +23,36 @@ function createServerAdapter(serverAdapterBaseObject, options) {
         : serverAdapterBaseObject.handle;
     const onRequestHooks = [];
     const onResponseHooks = [];
+    const waitUntilPromises = new Set();
+    const disposableStack = new 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();
+        }
+    });
+    function handleWaitUntils() {
+        return Promise.allSettled(waitUntilPromises).then(() => { }, () => { });
+    }
+    disposableStack.defer(handleWaitUntils);
+    function waitUntil(promiseLike) {
+        // If it is a Node.js environment, we should register the disposable stack to handle process termination events
+        if (globalThis.process) {
+            ensureDisposableStackRegisteredForTerminateEvents(disposableStack);
+        }
+        waitUntilPromises.add(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.onRequest) {
@@ -50,6 +78,9 @@ function createServerAdapter(serverAdapterBaseObject, options) {
             });
             const onRequestHooksIteration$ = iterateAsyncVoid(onRequestHooks, (onRequestHook, stopEarly) => onRequestHook({
                 request,
+                setRequest(newRequest) {
+                    request = newRequest;
+                },
                 serverContext,
                 fetchAPI,
                 url,
@@ -65,13 +96,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,20 +130,22 @@ function createServerAdapter(serverAdapterBaseObject, options) {
             return handleEarlyResponse();
         }
         : givenHandleRequest;
-    function handleNodeRequestAndResponse(nodeRequest, nodeResponseOrContainer, ...ctx) {
-        const nodeResponse = nodeResponseOrContainer.raw || nodeResponseOrContainer;
+    // TODO: Remove this on the next major version
+    function handleNodeRequest(nodeRequest, ...ctx) {
         const serverContext = ctx.length > 1 ? completeAssign(...ctx) : ctx[0] || {};
-        const request = normalizeNodeRequest(nodeRequest, nodeResponse, fetchAPI.Request);
+        const request = normalizeNodeRequest(nodeRequest, fetchAPI, registerSignal);
         return handleRequest(request, serverContext);
     }
+    function handleNodeRequestAndResponse(nodeRequest, nodeResponseOrContainer, ...ctx) {
+        const nodeResponse = nodeResponseOrContainer.raw || nodeResponseOrContainer;
+        nodeRequestResponseMap.set(nodeRequest, nodeResponse);
+        return handleNodeRequest(nodeRequest, ...ctx);
+    }
     function requestListener(nodeRequest, nodeResponse, ...ctx) {
-        const waitUntilPromises = [];
         const defaultServerContext = {
             req: nodeRequest,
             res: nodeResponse,
-            waitUntil(cb) {
-                waitUntilPromises.push(cb.catch(err => console.error(err)));
-            },
+            waitUntil,
         };
         let response$;
         try {
@@ -133,19 +170,17 @@ function createServerAdapter(serverAdapterBaseObject, options) {
         }
     }
     function handleUWS(res, req, ...ctx) {
-        const waitUntilPromises = [];
         const defaultServerContext = {
             res,
             req,
-            waitUntil(cb) {
-                waitUntilPromises.push(cb.catch(err => console.error(err)));
-            },
+            waitUntil,
         };
         const filteredCtxParts = ctx.filter(partCtx => partCtx != null);
         const serverContext = filteredCtxParts.length > 0
             ? completeAssign(defaultServerContext, ...ctx)
             : defaultServerContext;
         const signal = new ServerAdapterRequestAbortSignal();
+        registerSignal(signal);
         const originalResEnd = res.end.bind(res);
         let resEnded = false;
         res.end = function (data) {
@@ -177,7 +212,7 @@ function createServerAdapter(serverAdapterBaseObject, options) {
                 .catch((e) => handleErrorFromRequestHandler(e, fetchAPI.Response))
                 .then(response => {
                 if (!signal.aborted && !resEnded) {
-                    return sendResponseToUwsOpts(res, response, signal);
+                    return sendResponseToUwsOpts(res, response, signal, fetchAPI);
                 }
             })
                 .catch(err => {
@@ -186,7 +221,7 @@ function createServerAdapter(serverAdapterBaseObject, options) {
         }
         try {
             if (!signal.aborted && !resEnded) {
-                return sendResponseToUwsOpts(res, response$, signal);
+                return sendResponseToUwsOpts(res, response$, signal, fetchAPI);
             }
         }
         catch (err) {
@@ -206,17 +241,12 @@ function createServerAdapter(serverAdapterBaseObject, options) {
     }
     function handleRequestWithWaitUntil(request, ...ctx) {
         const filteredCtxParts = ctx.filter(partCtx => partCtx != null);
-        let waitUntilPromises;
         const serverContext = filteredCtxParts.length > 1
             ? completeAssign({}, ...filteredCtxParts)
             : isolateObject(filteredCtxParts[0], filteredCtxParts[0] == null || filteredCtxParts[0].waitUntil == null
-                ? (waitUntilPromises = [])
+                ? waitUntil
                 : undefined);
-        const response$ = handleRequest(request, serverContext);
-        if (waitUntilPromises?.length) {
-            return handleWaitUntils(waitUntilPromises).then(() => response$);
-        }
-        return response$;
+        return handleRequest(request, serverContext);
     }
     const fetchFn = (input, ...maybeCtx) => {
         if (typeof input === 'string' || 'href' in input) {
@@ -263,11 +293,19 @@ function createServerAdapter(serverAdapterBaseObject, options) {
     const adapterObj = {
         handleRequest: handleRequestWithWaitUntil,
         fetch: fetchFn,
+        handleNodeRequest,
         handleNodeRequestAndResponse,
         requestListener,
         handleEvent,
         handleUWS,
         handle: genericRequestHandler,
+        disposableStack,
+        [DisposableSymbols.asyncDispose]() {
+            return disposableStack.disposeAsync();
+        },
+        dispose() {
+            return disposableStack.disposeAsync();
+        },
     };
     const serverAdapter = new Proxy(genericRequestHandler, {
         // It should have all the attributes of the handler function and the server instance

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,130 @@
+import { decompressedResponseMap, getSupportedEncodings, isAsyncIterable, isReadable, } 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));
+                    }
+                    request = 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(request);
+                }
+            }
+            const acceptEncoding = request.headers.get('accept-encoding');
+            if (acceptEncoding) {
+                encodingMap.set(request, acceptEncoding.split(','));
+            }
+        },
+        onResponse({ request, response, setResponse, fetchAPI, serverContext }) {
+            const waitUntil = serverContext.waitUntil?.bind(serverContext) || (() => { });
+            // 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();
+                                waitUntil(writer.write(bufOfRes));
+                                waitUntil(writer.close());
+                                const uint8Arrays$ = isReadable(compressionStream.readable['readable'])
+                                    ? collectReadableValues(compressionStream.readable['readable'])
+                                    : 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,
+                                    });
+                                    decompressedResponseMap.set(compressedResponse, response);
+                                    setResponse(compressedResponse);
+                                    waitUntil(compressionStream.writable.close());
+                                });
+                            }
+                        }
+                        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);
+                    }
+                }
+            }
+        },
+    };
+}
+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;
+}

package/esm/plugins/useErrorHandling.js

@@ -19,13 +19,17 @@ function createDefaultErrorResponse(ResponseCtor) {
     return new ResponseCtor(null, { status: 500 });
 }
 export class HTTPError extends Error {
+    status;
+    message;
+    headers;
+    details;
+    name = 'HTTPError';
     constructor(status = 500, message, headers = {}, details) {
         super(message);
         this.status = status;
         this.message = message;
         this.headers = headers;
         this.details = details;
-        this.name = 'HTTPError';
         Error.captureStackTrace(this, HTTPError);
     }
 }