@whatwg-node/server 0.9.2-alpha-20230702150553-e1b62ad → 0.9.2

package/cjs/createServerAdapter.js

@@ -4,10 +4,32 @@ exports.createServerAdapter = void 0;
 const tslib_1 = require("tslib");
 /* eslint-disable @typescript-eslint/ban-types */
 const DefaultFetchAPI = tslib_1.__importStar(require("@whatwg-node/fetch"));
-const useFetchEvent_js_1 = require("./internal-plugins/useFetchEvent.js");
-const useNodeAdapter_js_1 = require("./internal-plugins/useNodeAdapter.js");
-const useUWSAdapter_js_1 = require("./internal-plugins/useUWSAdapter.js");
 const utils_js_1 = require("./utils.js");
+const uwebsockets_js_1 = require("./uwebsockets.js");
+async function handleWaitUntils(waitUntilPromises) {
+    const waitUntils = await Promise.allSettled(waitUntilPromises);
+    waitUntils.forEach(waitUntil => {
+        if (waitUntil.status === 'rejected') {
+            console.error(waitUntil.reason);
+        }
+    });
+}
+// Required for envs like nextjs edge runtime
+function isRequestAccessible(serverContext) {
+    try {
+        return !!serverContext?.request;
+    }
+    catch {
+        return false;
+    }
+}
+function addWaitUntil(serverContext, waitUntilPromises) {
+    serverContext['waitUntil'] = function (promise) {
+        if (promise != null) {
+            waitUntilPromises.push(promise);
+        }
+    };
+}
 const EMPTY_OBJECT = {};
 function createServerAdapter(serverAdapterBaseObject, options) {
     const fetchAPI = {
@@ -17,20 +39,16 @@ function createServerAdapter(serverAdapterBaseObject, options) {
     const givenHandleRequest = typeof serverAdapterBaseObject === 'function'
         ? serverAdapterBaseObject
         : serverAdapterBaseObject.handle;
-    const onRequestAdaptHooks = [];
     const onRequestHooks = [];
     const onResponseHooks = [];
-    const plugins = options?.plugins ?? [];
-    plugins.push((0, useUWSAdapter_js_1.useUWSAdapter)(), (0, useNodeAdapter_js_1.useNodeAdapter)(), (0, useFetchEvent_js_1.useFetchEvent)());
-    for (const plugin of plugins) {
-        if (plugin.onRequestAdapt) {
-            onRequestAdaptHooks.push(plugin.onRequestAdapt);
-        }
-        if (plugin.onRequest) {
-            onRequestHooks.push(plugin.onRequest);
-        }
-        if (plugin.onResponse) {
-            onResponseHooks.push(plugin.onResponse);
+    if (options?.plugins != null) {
+        for (const plugin of options.plugins) {
+            if (plugin.onRequest) {
+                onRequestHooks.push(plugin.onRequest);
+            }
+            if (plugin.onResponse) {
+                onResponseHooks.push(plugin.onResponse);
+            }
         }
     }
     async function handleRequest(request, serverContext) {
@@ -42,16 +60,6 @@ function createServerAdapter(serverAdapterBaseObject, options) {
         });
         let requestHandler = givenHandleRequest;
         let response;
-        let waitUntilPromises;
-        if (serverContext['waitUntil'] == null) {
-            waitUntilPromises = new Set();
-            serverContext['waitUntil'] = (promise) => {
-                waitUntilPromises.add(promise);
-                promise.then(() => {
-                    waitUntilPromises.delete(promise);
-                });
-            };
-        }
         for (const onRequestHook of onRequestHooks) {
             await onRequestHook({
                 request,
@@ -73,12 +81,6 @@ function createServerAdapter(serverAdapterBaseObject, options) {
         if (!response) {
             response = await requestHandler(request, serverContext);
         }
-        if (!response) {
-            response = new fetchAPI.Response(undefined, {
-                status: 404,
-                statusText: 'Not Found',
-            });
-        }
         for (const onResponseHook of onResponseHooks) {
             await onResponseHook({
                 request,
@@ -86,58 +88,125 @@ function createServerAdapter(serverAdapterBaseObject, options) {
                 serverContext,
             });
         }
-        if (waitUntilPromises?.size) {
-            const waitUntils = await Promise.allSettled(waitUntilPromises);
-            waitUntils.forEach(waitUntil => {
-                if (waitUntil.status === 'rejected') {
-                    console.error(waitUntil.reason);
-                }
+        return response;
+    }
+    function handleNodeRequest(nodeRequest, ...ctx) {
+        const serverContext = ctx.length > 1 ? (0, utils_js_1.completeAssign)(...ctx) : ctx[0] || {};
+        const request = (0, utils_js_1.normalizeNodeRequest)(nodeRequest, fetchAPI.Request);
+        return handleRequest(request, serverContext);
+    }
+    async function requestListener(nodeRequest, serverResponse, ...ctx) {
+        const waitUntilPromises = [];
+        const defaultServerContext = {
+            req: nodeRequest,
+            res: serverResponse,
+        };
+        addWaitUntil(defaultServerContext, waitUntilPromises);
+        const response = await handleNodeRequest(nodeRequest, defaultServerContext, ...ctx);
+        if (response) {
+            await (0, utils_js_1.sendNodeResponse)(response, serverResponse, nodeRequest);
+        }
+        else {
+            await new Promise(resolve => {
+                serverResponse.statusCode = 404;
+                serverResponse.once('end', resolve);
+                serverResponse.end();
             });
         }
-        return response;
+        if (waitUntilPromises.length > 0) {
+            await handleWaitUntils(waitUntilPromises);
+        }
+    }
+    async function handleUWS(res, req, ...ctx) {
+        const waitUntilPromises = [];
+        const defaultServerContext = {
+            res,
+            req,
+        };
+        addWaitUntil(defaultServerContext, waitUntilPromises);
+        const serverContext = ctx.length > 0 ? (0, utils_js_1.completeAssign)(defaultServerContext, ...ctx) : defaultServerContext;
+        const request = (0, uwebsockets_js_1.getRequestFromUWSRequest)({
+            req,
+            res,
+            fetchAPI,
+        });
+        const response = await handleRequest(request, serverContext);
+        if (!response) {
+            res.writeStatus('404 Not Found');
+            res.end();
+            return;
+        }
+        return (0, uwebsockets_js_1.sendResponseToUwsOpts)({
+            response,
+            res,
+        });
+    }
+    function handleEvent(event, ...ctx) {
+        if (!event.respondWith || !event.request) {
+            throw new TypeError(`Expected FetchEvent, got ${event}`);
+        }
+        const serverContext = ctx.length > 0 ? Object.assign({}, event, ...ctx) : event;
+        const response$ = handleRequest(event.request, serverContext);
+        event.respondWith(response$);
+    }
+    function handleRequestWithWaitUntil(request, ...ctx) {
+        const serverContext = (ctx.length > 1 ? (0, utils_js_1.completeAssign)(...ctx) : ctx[0]) || {};
+        if (serverContext.waitUntil == null) {
+            const waitUntilPromises = [];
+            addWaitUntil(serverContext, waitUntilPromises);
+            const response$ = handleRequest(request, serverContext);
+            if (waitUntilPromises.length > 0) {
+                return handleWaitUntils(waitUntilPromises).then(() => response$);
+            }
+            return response$;
+        }
+        return handleRequest(request, serverContext);
     }
     const fetchFn = (input, ...maybeCtx) => {
         if (typeof input === 'string' || 'href' in input) {
             const [initOrCtx, ...restOfCtx] = maybeCtx;
             if ((0, utils_js_1.isRequestInit)(initOrCtx)) {
-                const serverContext = restOfCtx.length > 0 ? (0, utils_js_1.completeAssign)(...restOfCtx) : {};
-                return handleRequest(new fetchAPI.Request(input, initOrCtx), serverContext);
+                return handleRequestWithWaitUntil(new fetchAPI.Request(input, initOrCtx), ...restOfCtx);
             }
-            const serverContext = maybeCtx.length > 0 ? (0, utils_js_1.completeAssign)(...maybeCtx) : {};
-            return handleRequest(new fetchAPI.Request(input), serverContext);
+            return handleRequestWithWaitUntil(new fetchAPI.Request(input), ...maybeCtx);
         }
-        const serverContext = maybeCtx.length > 0 ? (0, utils_js_1.completeAssign)(...maybeCtx) : {};
-        return handleRequest(input, serverContext);
+        return handleRequestWithWaitUntil(input, ...maybeCtx);
     };
-    const genericRequestHandler = (...args) => {
-        let request;
-        let serverContext;
-        for (const onRequestAdapt of onRequestAdaptHooks) {
-            onRequestAdapt({
-                args,
-                setRequest(newRequest) {
-                    request = newRequest;
-                },
-                setServerContext(newServerContext) {
-                    serverContext = newServerContext;
-                },
-                fetchAPI,
-            });
+    const genericRequestHandler = (input, ...maybeCtx) => {
+        // If it is a Node request
+        const [initOrCtxOrRes, ...restOfCtx] = maybeCtx;
+        if ((0, utils_js_1.isNodeRequest)(input)) {
+            if (!(0, utils_js_1.isServerResponse)(initOrCtxOrRes)) {
+                throw new TypeError(`Expected ServerResponse, got ${initOrCtxOrRes}`);
+            }
+            return requestListener(input, initOrCtxOrRes, ...restOfCtx);
+        }
+        if ((0, uwebsockets_js_1.isUWSResponse)(input)) {
+            return handleUWS(input, initOrCtxOrRes, ...restOfCtx);
+        }
+        if ((0, utils_js_1.isServerResponse)(initOrCtxOrRes)) {
+            throw new TypeError('Got Node response without Node request');
         }
-        if (request) {
-            if (!serverContext) {
-                serverContext = {};
+        // Is input a container object over Request?
+        if (isRequestAccessible(input)) {
+            // Is it FetchEvent?
+            if ((0, utils_js_1.isFetchEvent)(input)) {
+                return handleEvent(input, ...maybeCtx);
             }
-            return handleRequest(request, serverContext);
+            // In this input is also the context
+            return handleRequestWithWaitUntil(input.request, input, ...maybeCtx);
         }
-        return fetchFn(...args);
+        // Or is it Request itself?
+        // Then ctx is present and it is the context
+        return fetchFn(input, ...maybeCtx);
     };
     const adapterObj = {
         handleRequest,
         fetch: fetchFn,
-        requestListener: genericRequestHandler,
-        handleNodeRequest: genericRequestHandler,
-        handleEvent: genericRequestHandler,
+        handleNodeRequest,
+        requestListener,
+        handleEvent,
+        handleUWS,
         handle: genericRequestHandler,
     };
     const serverAdapter = new Proxy(genericRequestHandler, {

package/cjs/index.js

@@ -8,8 +8,6 @@ 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("./internal-plugins/useFetchEvent.js"), exports);
-tslib_1.__exportStar(require("./internal-plugins/useNodeAdapter.js"), exports);
-tslib_1.__exportStar(require("./internal-plugins/useUWSAdapter.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/utils.js

@@ -1,14 +1,208 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.addWaitUntil = exports.completeAssign = exports.isRequestInit = exports.isReadableStream = exports.isAsyncIterable = void 0;
+exports.completeAssign = exports.isRequestInit = exports.sendNodeResponse = exports.isFetchEvent = exports.isReadableStream = exports.isServerResponse = exports.isNodeRequest = exports.isReadable = exports.normalizeNodeRequest = exports.isAsyncIterable = void 0;
+const fetch_1 = require("@whatwg-node/fetch");
 function isAsyncIterable(body) {
     return (body != null && typeof body === 'object' && typeof body[Symbol.asyncIterator] === 'function');
 }
 exports.isAsyncIterable = isAsyncIterable;
+function getPort(nodeRequest) {
+    if (nodeRequest.socket?.localPort) {
+        return nodeRequest.socket?.localPort;
+    }
+    const hostInHeader = nodeRequest.headers?.[':authority'] || nodeRequest.headers?.host;
+    const portInHeader = hostInHeader?.split(':')?.[1];
+    if (portInHeader) {
+        return portInHeader;
+    }
+    return 80;
+}
+function getHostnameWithPort(nodeRequest) {
+    if (nodeRequest.headers?.[':authority']) {
+        return nodeRequest.headers?.[':authority'];
+    }
+    if (nodeRequest.headers?.host) {
+        return nodeRequest.headers?.host;
+    }
+    const port = getPort(nodeRequest);
+    if (nodeRequest.hostname) {
+        return nodeRequest.hostname + ':' + port;
+    }
+    const localIp = nodeRequest.socket?.localAddress;
+    if (localIp && !localIp?.includes('::') && !localIp?.includes('ffff')) {
+        return `${localIp}:${port}`;
+    }
+    return 'localhost';
+}
+function buildFullUrl(nodeRequest) {
+    const hostnameWithPort = getHostnameWithPort(nodeRequest);
+    const protocol = nodeRequest.protocol || 'http';
+    const endpoint = nodeRequest.originalUrl || nodeRequest.url || '/graphql';
+    return `${protocol}://${hostnameWithPort}${endpoint}`;
+}
+function isRequestBody(body) {
+    const stringTag = body[Symbol.toStringTag];
+    if (typeof body === 'string' ||
+        stringTag === 'Uint8Array' ||
+        stringTag === 'Blob' ||
+        stringTag === 'FormData' ||
+        stringTag === 'URLSearchParams' ||
+        isAsyncIterable(body)) {
+        return true;
+    }
+    return false;
+}
+function normalizeNodeRequest(nodeRequest, RequestCtor) {
+    const rawRequest = nodeRequest.raw || nodeRequest.req || nodeRequest;
+    let fullUrl = buildFullUrl(rawRequest);
+    if (nodeRequest.query) {
+        const url = new fetch_1.URL(fullUrl);
+        for (const key in nodeRequest.query) {
+            url.searchParams.set(key, nodeRequest.query[key]);
+        }
+        fullUrl = url.toString();
+    }
+    if (nodeRequest.method === 'GET' || nodeRequest.method === 'HEAD') {
+        return new RequestCtor(fullUrl, {
+            method: nodeRequest.method,
+            headers: nodeRequest.headers,
+        });
+    }
+    /**
+     * Some Node server frameworks like Serverless Express sends a dummy object with body but as a Buffer not string
+     * so we do those checks to see is there something we can use directly as BodyInit
+     * because the presence of body means the request stream is already consumed and,
+     * rawRequest cannot be used as BodyInit/ReadableStream by Fetch API in this case.
+     */
+    const maybeParsedBody = nodeRequest.body;
+    if (maybeParsedBody != null && Object.keys(maybeParsedBody).length > 0) {
+        if (isRequestBody(maybeParsedBody)) {
+            return new RequestCtor(fullUrl, {
+                method: nodeRequest.method,
+                headers: nodeRequest.headers,
+                body: maybeParsedBody,
+            });
+        }
+        const request = new RequestCtor(fullUrl, {
+            method: nodeRequest.method,
+            headers: nodeRequest.headers,
+        });
+        if (!request.headers.get('content-type')?.includes('json')) {
+            request.headers.set('content-type', 'application/json; charset=utf-8');
+        }
+        return new Proxy(request, {
+            get: (target, prop, receiver) => {
+                switch (prop) {
+                    case 'json':
+                        return async () => maybeParsedBody;
+                    case 'text':
+                        return async () => JSON.stringify(maybeParsedBody);
+                    default:
+                        return Reflect.get(target, prop, receiver);
+                }
+            },
+        });
+    }
+    // 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,
+        body: rawRequest,
+    });
+}
+exports.normalizeNodeRequest = normalizeNodeRequest;
+function isReadable(stream) {
+    return stream.read != null;
+}
+exports.isReadable = isReadable;
+function isNodeRequest(request) {
+    return isReadable(request);
+}
+exports.isNodeRequest = isNodeRequest;
+function isServerResponse(stream) {
+    // Check all used functions are defined
+    return (stream != null &&
+        stream.setHeader != null &&
+        stream.end != null &&
+        stream.once != null &&
+        stream.write != null);
+}
+exports.isServerResponse = isServerResponse;
 function isReadableStream(stream) {
     return stream != null && stream.getReader != null;
 }
 exports.isReadableStream = isReadableStream;
+function isFetchEvent(event) {
+    return event != null && event.request != null && event.respondWith != null;
+}
+exports.isFetchEvent = isFetchEvent;
+function configureSocket(rawRequest) {
+    rawRequest?.socket?.setTimeout?.(0);
+    rawRequest?.socket?.setNoDelay?.(true);
+    rawRequest?.socket?.setKeepAlive?.(true);
+}
+function endResponse(serverResponse) {
+    // @ts-expect-error Avoid arguments adaptor trampoline https://v8.dev/blog/adaptor-frame
+    serverResponse.end(null, null, null);
+}
+async function sendAsyncIterable(serverResponse, asyncIterable) {
+    for await (const chunk of asyncIterable) {
+        if (!serverResponse
+            // @ts-expect-error http and http2 writes are actually compatible
+            .write(chunk)) {
+            break;
+        }
+    }
+    endResponse(serverResponse);
+}
+function sendNodeResponse(fetchResponse, serverResponse, nodeRequest) {
+    serverResponse.statusCode = fetchResponse.status;
+    serverResponse.statusMessage = fetchResponse.statusText;
+    fetchResponse.headers.forEach((value, key) => {
+        if (key === 'set-cookie') {
+            const setCookies = fetchResponse.headers.getSetCookie?.();
+            if (setCookies) {
+                serverResponse.setHeader('set-cookie', setCookies);
+                return;
+            }
+        }
+        serverResponse.setHeader(key, value);
+    });
+    // Optimizations for node-fetch
+    if (fetchResponse.bodyType === 'Buffer' ||
+        fetchResponse.bodyType === 'String' ||
+        fetchResponse.bodyType === 'Uint8Array') {
+        // @ts-expect-error http and http2 writes are actually compatible
+        serverResponse.write(fetchResponse.bodyInit);
+        endResponse(serverResponse);
+        return;
+    }
+    // Other fetch implementations
+    const fetchBody = fetchResponse.body;
+    if (fetchBody == null) {
+        endResponse(serverResponse);
+        return;
+    }
+    if (fetchBody[Symbol.toStringTag] === 'Uint8Array') {
+        serverResponse
+            // @ts-expect-error http and http2 writes are actually compatible
+            .write(fetchBody);
+        endResponse(serverResponse);
+        return;
+    }
+    configureSocket(nodeRequest);
+    if (isReadable(fetchBody)) {
+        serverResponse.once('close', () => {
+            fetchBody.destroy();
+        });
+        fetchBody.pipe(serverResponse);
+        return;
+    }
+    if (isAsyncIterable(fetchBody)) {
+        return sendAsyncIterable(serverResponse, fetchBody);
+    }
+}
+exports.sendNodeResponse = sendNodeResponse;
 function isRequestInit(val) {
     return (val != null &&
         typeof val === 'object' &&
@@ -49,11 +243,3 @@ function completeAssign(...args) {
     return target;
 }
 exports.completeAssign = completeAssign;
-function addWaitUntil(serverContext, waitUntilPromises) {
-    serverContext['waitUntil'] = function (promise) {
-        if (promise != null) {
-            waitUntilPromises.push(promise);
-        }
-    };
-}
-exports.addWaitUntil = addWaitUntil;

package/cjs/{internal-plugins/useUWSAdapter.js → uwebsockets.js}

@@ -1,39 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sendResponseToUwsOpts = exports.getRequestFromUWSRequest = exports.isUWSResponse = exports.useUWSAdapter = void 0;
-const utils_js_1 = require("../utils.js");
-function useUWSAdapter() {
-    const uwsResponseMap = new WeakMap();
-    return {
-        onRequestAdapt({ args: [res, req, ...restOfCtx], setRequest, setServerContext, fetchAPI }) {
-            if (isUWSResponse(res)) {
-                const request = getRequestFromUWSRequest({
-                    req: req,
-                    res,
-                    fetchAPI,
-                });
-                uwsResponseMap.set(request, res);
-                setRequest(request);
-                const defaultServerContext = {
-                    req,
-                    res,
-                };
-                const serverContext = restOfCtx.length > 0 ? (0, utils_js_1.completeAssign)(...restOfCtx) : defaultServerContext;
-                setServerContext(serverContext);
-            }
-        },
-        onResponse({ request, response }) {
-            const res = uwsResponseMap.get(request);
-            if (res) {
-                return sendResponseToUwsOpts({
-                    res,
-                    response,
-                });
-            }
-        },
-    };
-}
-exports.useUWSAdapter = useUWSAdapter;
+exports.sendResponseToUwsOpts = exports.getRequestFromUWSRequest = exports.isUWSResponse = void 0;
 function isUWSResponse(res) {
     return !!res.onData;
 }