@whatwg-node/server 0.10.0-alpha-20240726141316-c6ce93b3598457ebe73b3b725986723af8f5e609 → 0.10.0-alpha-20241123133536-975c9068dde45574fcfa26567e4bab96f45d1f85

package/cjs/uwebsockets.js

@@ -2,50 +2,75 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isUWSResponse = isUWSResponse;
 exports.getRequestFromUWSRequest = getRequestFromUWSRequest;
+exports.createWritableFromUWS = createWritableFromUWS;
 exports.sendResponseToUwsOpts = sendResponseToUwsOpts;
+exports.fakePromise = fakePromise;
+const utils_js_1 = require("./utils.js");
 function isUWSResponse(res) {
     return !!res.onData;
 }
 function getRequestFromUWSRequest({ req, res, fetchAPI, signal }) {
-    let body;
     const method = req.getMethod();
-    if (method !== 'get' && method !== 'head') {
-        let controller;
-        body = new fetchAPI.ReadableStream({
-            start(c) {
-                controller = c;
-            },
-        });
-        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);
-                }
-            });
+    let duplex;
+    const chunks = [];
+    const pushFns = [
+        (chunk) => {
+            chunks.push(chunk);
+        },
+    ];
+    const push = (chunk) => {
+        for (const pushFn of pushFns) {
+            pushFn(chunk);
         }
-        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();
-                }
-            });
+    };
+    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') {
+        duplex = 'half';
+        signal.addEventListener('abort', () => {
+            stop();
+        });
+        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) => {
@@ -56,30 +81,97 @@ 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: 'half',
+        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;
 }
-function sendResponseToUwsOpts(uwsResponse, fetchResponse, signal) {
+function createWritableFromUWS(uwsResponse, fetchAPI) {
+    return new fetchAPI.WritableStream({
+        write(chunk) {
+            uwsResponse.cork(() => {
+                uwsResponse.write(chunk);
+            });
+        },
+        close() {
+            uwsResponse.cork(() => {
+                uwsResponse.end();
+            });
+        },
+    });
+}
+function sendResponseToUwsOpts(uwsResponse, fetchResponse, signal, fetchAPI) {
     if (!fetchResponse) {
         uwsResponse.writeStatus('404 Not Found');
         uwsResponse.end();
@@ -109,13 +201,59 @@ 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;
+    });
+}
+function fakePromise(value) {
+    if ((0, utils_js_1.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 ((0, utils_js_1.isPromise)(callbackResult)) {
+                    return callbackResult;
+                }
+                return fakePromise(callbackResult);
+            }
+            return this;
+        },
+        catch() {
+            return this;
+        },
+        finally(cb) {
+            if (cb) {
+                const callbackResult = cb();
+                if ((0, utils_js_1.isPromise)(callbackResult)) {
+                    return callbackResult.then(() => value);
+                }
+                return fakePromise(value);
+            }
+            return this;
+        },
+        [Symbol.toStringTag]: 'Promise',
+    };
 }

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) {
@@ -103,20 +131,21 @@ function createServerAdapter(serverAdapterBaseObject, options) {
         }
         : givenHandleRequest;
     // TODO: Remove this on the next major version
-    function handleNodeRequestAndResponse(nodeRequest, nodeResponseOrContainer, ...ctx) {
-        const nodeResponse = nodeResponseOrContainer.raw || nodeResponseOrContainer;
+    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 {
@@ -141,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) {
@@ -185,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 => {
@@ -194,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) {
@@ -214,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) {
@@ -271,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/plugins/useContentEncoding.js

@@ -1,4 +1,4 @@
-import { decompressedResponseMap, getSupportedEncodings } from '../utils.js';
+import { decompressedResponseMap, getSupportedEncodings, isAsyncIterable, isReadable, } from '../utils.js';
 export function useContentEncoding() {
     const encodingMap = new WeakMap();
     return {
@@ -18,7 +18,7 @@ export function useContentEncoding() {
                     for (const contentEncoding of contentEncodings) {
                         newBody = newBody.pipeThrough(new fetchAPI.DecompressionStream(contentEncoding));
                     }
-                    const newRequest = new fetchAPI.Request(request.url, {
+                    request = new fetchAPI.Request(request.url, {
                         body: newBody,
                         cache: request.cache,
                         credentials: request.credentials,
@@ -35,7 +35,7 @@ export function useContentEncoding() {
                         // @ts-ignore - not in the TS types yet
                         duplex: 'half',
                     });
-                    setRequest(newRequest);
+                    setRequest(request);
                 }
             }
             const acceptEncoding = request.headers.get('accept-encoding');
@@ -43,7 +43,8 @@ export function useContentEncoding() {
                 encodingMap.set(request, acceptEncoding.split(','));
             }
         },
-        onResponse({ request, response, setResponse, fetchAPI }) {
+        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);
@@ -57,21 +58,15 @@ export function useContentEncoding() {
                             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);
-                                        }
-                                    }
+                                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);
@@ -82,6 +77,7 @@ export function useContentEncoding() {
                                     });
                                     decompressedResponseMap.set(compressedResponse, response);
                                     setResponse(compressedResponse);
+                                    waitUntil(compressionStream.writable.close());
                                 });
                             }
                         }
@@ -102,3 +98,33 @@ export 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;
+}

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);
     }
 }