@whatwg-node/server 0.10.0-alpha-20240726141316-c6ce93b3598457ebe73b3b725986723af8f5e609 → 0.10.0-alpha-20241125124208-52a1220ca8b2a3b86a8338c8f96b80dde432e1bb

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,17 +78,20 @@ 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;
+    const nodeResponse = nodeRequestResponseMap.get(nodeRequest);
+    nodeRequestResponseMap.delete(nodeRequest);
     let normalizedHeaders = nodeRequest.headers;
     if (nodeRequest.headers?.[':method']) {
         normalizedHeaders = {};
@@ -104,8 +104,10 @@ export function normalizeNodeRequest(nodeRequest, nodeResponse, RequestCtor) {
     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 {
@@ -126,7 +128,7 @@ 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: normalizedHeaders,
             signal,
@@ -141,14 +143,14 @@ 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: normalizedHeaders,
                 body: maybeParsedBody,
                 signal,
             });
         }
-        const request = new RequestCtor(fullUrl, {
+        const request = new fetchAPI.Request(fullUrl, {
             method: nodeRequest.method,
             headers: normalizedHeaders,
             signal,
@@ -176,7 +178,7 @@ 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: normalizedHeaders,
             duplex: 'half',
@@ -200,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, {
+    return new fetchAPI.Request(fullUrl, {
         method: nodeRequest.method,
         headers: normalizedHeaders,
         body: rawRequest,
@@ -238,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);
@@ -253,7 +270,7 @@ export function sendNodeResponse(fetchResponse, serverResponse, nodeRequest) {
     }
     if (!fetchResponse) {
         serverResponse.statusCode = 404;
-        serverResponse.end();
+        endResponse(serverResponse);
         return;
     }
     serverResponse.statusCode = fetchResponse.status;
@@ -302,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' &&
@@ -382,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;
@@ -494,22 +473,27 @@ 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;
-            }
-        });
+        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;
@@ -540,3 +524,31 @@ export function handleResponseDecompression(response, fetchAPI) {
     }
     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.disposed &&
+                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,46 +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();
-    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) => {
@@ -51,30 +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: '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;
 }
-export function sendResponseToUwsOpts(uwsResponse, fetchResponse, signal) {
+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, fetchAPI) {
     if (!fetchResponse) {
         uwsResponse.writeStatus('404 Not Found');
         uwsResponse.end();
@@ -104,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-20240726141316-c6ce93b3598457ebe73b3b725986723af8f5e609",
+  "version": "0.10.0-alpha-20241125124208-52a1220ca8b2a3b86a8338c8f96b80dde432e1bb",
   "description": "Fetch API compliant HTTP Server adapter",
   "sideEffects": false,
   "dependencies": {
-    "@whatwg-node/fetch": "^0.9.19",
+    "@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/plugins/useCors.d.cts

@@ -1,4 +1,4 @@
-import { ServerAdapterPlugin } from './types.cjs';
+import type { ServerAdapterPlugin } from './types.cjs';
 export type CORSOptions = {
     origin?: string[] | string;
     methods?: string[];

package/typings/plugins/useCors.d.ts

@@ -1,4 +1,4 @@
-import { ServerAdapterPlugin } from './types.js';
+import type { ServerAdapterPlugin } from './types.js';
 export type CORSOptions = {
     origin?: string[] | string;
     methods?: string[];

package/typings/plugins/useErrorHandling.d.cts

@@ -1,4 +1,4 @@
-import { ServerAdapterPlugin } from './types.cjs';
+import type { ServerAdapterPlugin } from './types.cjs';
 export declare function createDefaultErrorHandler<TServerContext = {}>(ResponseCtor?: typeof Response): ErrorHandler<TServerContext>;
 export declare class HTTPError extends Error {
     status: number;
@@ -6,7 +6,7 @@ export declare class HTTPError extends Error {
     headers: HeadersInit;
     details?: any;
     name: string;
-    constructor(status: number, message: string, headers?: HeadersInit, details?: any);
+    constructor(status: number | undefined, 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

@@ -1,4 +1,4 @@
-import { ServerAdapterPlugin } from './types.js';
+import type { ServerAdapterPlugin } from './types.js';
 export declare function createDefaultErrorHandler<TServerContext = {}>(ResponseCtor?: typeof Response): ErrorHandler<TServerContext>;
 export declare class HTTPError extends Error {
     status: number;
@@ -6,7 +6,7 @@ export declare class HTTPError extends Error {
     headers: HeadersInit;
     details?: any;
     name: string;
-    constructor(status: number, message: string, headers?: HeadersInit, details?: any);
+    constructor(status: number | undefined, 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>;