@whatwg-node/server 0.9.1 → 0.9.2-alpha-20230702143635-7d0af11

package/cjs/utils.js

@@ -1,219 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-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");
+exports.addWaitUntil = exports.completeAssign = exports.isRequestInit = exports.isReadableStream = exports.isAsyncIterable = void 0;
 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);
-}
-function getHeaderPairs(headers) {
-    const headerPairs = new Map();
-    headers.forEach((value, key) => {
-        let headerValues = headerPairs.get(key);
-        if (headerValues === undefined) {
-            headerValues = [];
-            headerPairs.set(key, headerValues);
-        }
-        if (key === 'set-cookie') {
-            const setCookies = headers.getSetCookie?.();
-            if (setCookies) {
-                setCookies.forEach(setCookie => {
-                    headerValues.push(setCookie);
-                });
-                return;
-            }
-        }
-        headerValues.push(value);
-    });
-    return headerPairs;
-}
-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) {
-    const headerPairs = getHeaderPairs(fetchResponse.headers);
-    serverResponse.writeHead(fetchResponse.status, fetchResponse.statusText, Object.fromEntries(headerPairs.entries()));
-    // 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' &&
@@ -254,3 +49,11 @@ 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/esm/createServerAdapter.js

@@ -1,31 +1,9 @@
 /* eslint-disable @typescript-eslint/ban-types */
 import * as DefaultFetchAPI from '@whatwg-node/fetch';
-import { completeAssign, isFetchEvent, isNodeRequest, isRequestInit, isServerResponse, normalizeNodeRequest, sendNodeResponse, } from './utils.js';
-import { getRequestFromUWSRequest, isUWSResponse, sendResponseToUwsOpts, } from './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);
-        }
-    };
-}
+import { useFetchEvent } from './internal-plugins/useFetchEvent.js';
+import { useNodeAdapter } from './internal-plugins/useNodeAdapter.js';
+import { useUWSAdapter } from './internal-plugins/useUWSAdapter.js';
+import { completeAssign, isRequestInit } from './utils.js';
 const EMPTY_OBJECT = {};
 function createServerAdapter(serverAdapterBaseObject, options) {
     const fetchAPI = {
@@ -35,16 +13,20 @@ function createServerAdapter(serverAdapterBaseObject, options) {
     const givenHandleRequest = typeof serverAdapterBaseObject === 'function'
         ? serverAdapterBaseObject
         : serverAdapterBaseObject.handle;
+    const onRequestAdaptHooks = [];
     const onRequestHooks = [];
     const onResponseHooks = [];
-    if (options?.plugins != null) {
-        for (const plugin of options.plugins) {
-            if (plugin.onRequest) {
-                onRequestHooks.push(plugin.onRequest);
-            }
-            if (plugin.onResponse) {
-                onResponseHooks.push(plugin.onResponse);
-            }
+    const plugins = options?.plugins ?? [];
+    plugins.push(useUWSAdapter(), useNodeAdapter(), 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);
         }
     }
     async function handleRequest(request, serverContext) {
@@ -56,6 +38,16 @@ 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,
@@ -77,6 +69,12 @@ 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,
@@ -84,125 +82,58 @@ function createServerAdapter(serverAdapterBaseObject, options) {
                 serverContext,
             });
         }
-        return response;
-    }
-    function handleNodeRequest(nodeRequest, ...ctx) {
-        const serverContext = ctx.length > 1 ? completeAssign(...ctx) : ctx[0] || {};
-        const request = 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 sendNodeResponse(response, serverResponse, nodeRequest);
-        }
-        else {
-            await new Promise(resolve => {
-                serverResponse.statusCode = 404;
-                serverResponse.once('end', resolve);
-                serverResponse.end();
+        if (waitUntilPromises?.size) {
+            const waitUntils = await Promise.allSettled(waitUntilPromises);
+            waitUntils.forEach(waitUntil => {
+                if (waitUntil.status === 'rejected') {
+                    console.error(waitUntil.reason);
+                }
             });
         }
-        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 ? completeAssign(defaultServerContext, ...ctx) : defaultServerContext;
-        const request = getRequestFromUWSRequest({
-            req,
-            res,
-            fetchAPI,
-        });
-        const response = await handleRequest(request, serverContext);
-        if (!response) {
-            res.writeStatus('404 Not Found');
-            res.end();
-            return;
-        }
-        return 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 ? 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);
+        return response;
     }
     const fetchFn = (input, ...maybeCtx) => {
         if (typeof input === 'string' || 'href' in input) {
             const [initOrCtx, ...restOfCtx] = maybeCtx;
             if (isRequestInit(initOrCtx)) {
-                return handleRequestWithWaitUntil(new fetchAPI.Request(input, initOrCtx), ...restOfCtx);
+                const serverContext = restOfCtx.length > 0 ? completeAssign(...restOfCtx) : {};
+                return handleRequest(new fetchAPI.Request(input, initOrCtx), serverContext);
             }
-            return handleRequestWithWaitUntil(new fetchAPI.Request(input), ...maybeCtx);
+            const serverContext = maybeCtx.length > 0 ? completeAssign(...maybeCtx) : {};
+            return handleRequest(new fetchAPI.Request(input), serverContext);
         }
-        return handleRequestWithWaitUntil(input, ...maybeCtx);
+        const serverContext = maybeCtx.length > 0 ? completeAssign(...maybeCtx) : {};
+        return handleRequest(input, serverContext);
     };
-    const genericRequestHandler = (input, ...maybeCtx) => {
-        // If it is a Node request
-        const [initOrCtxOrRes, ...restOfCtx] = maybeCtx;
-        if (isNodeRequest(input)) {
-            if (!isServerResponse(initOrCtxOrRes)) {
-                throw new TypeError(`Expected ServerResponse, got ${initOrCtxOrRes}`);
-            }
-            return requestListener(input, initOrCtxOrRes, ...restOfCtx);
-        }
-        if (isUWSResponse(input)) {
-            return handleUWS(input, initOrCtxOrRes, ...restOfCtx);
-        }
-        if (isServerResponse(initOrCtxOrRes)) {
-            throw new TypeError('Got Node response without Node request');
+    const genericRequestHandler = (...args) => {
+        let request;
+        let serverContext;
+        for (const onRequestAdapt of onRequestAdaptHooks) {
+            onRequestAdapt({
+                args,
+                setRequest(newRequest) {
+                    request = newRequest;
+                },
+                setServerContext(newServerContext) {
+                    serverContext = newServerContext;
+                },
+                fetchAPI,
+            });
         }
-        // Is input a container object over Request?
-        if (isRequestAccessible(input)) {
-            // Is it FetchEvent?
-            if (isFetchEvent(input)) {
-                return handleEvent(input, ...maybeCtx);
+        if (request) {
+            if (!serverContext) {
+                serverContext = {};
             }
-            // In this input is also the context
-            return handleRequestWithWaitUntil(input.request, input, ...maybeCtx);
+            return handleRequest(request, serverContext);
         }
-        // Or is it Request itself?
-        // Then ctx is present and it is the context
-        return fetchFn(input, ...maybeCtx);
+        return fetchFn(...args);
     };
     const adapterObj = {
         handleRequest,
         fetch: fetchFn,
-        handleNodeRequest,
-        requestListener,
-        handleEvent,
-        handleUWS,
+        requestListener: genericRequestHandler,
+        handleNodeRequest: genericRequestHandler,
+        handleEvent: genericRequestHandler,
         handle: genericRequestHandler,
     };
     const serverAdapter = new Proxy(genericRequestHandler, {

package/esm/index.js

@@ -4,5 +4,7 @@ export * from './utils.js';
 export * from './plugins/types.js';
 export * from './plugins/useCors.js';
 export * from './plugins/useErrorHandling.js';
-export * from './uwebsockets.js';
+export * from './internal-plugins/useFetchEvent.js';
+export * from './internal-plugins/useNodeAdapter.js';
+export * from './internal-plugins/useUWSAdapter.js';
 export { Response } from '@whatwg-node/fetch';

package/esm/internal-plugins/useFetchEvent.js

@@ -0,0 +1,31 @@
+import { completeAssign } from '../utils';
+export function isFetchEvent(event) {
+    return event != null && event.request != null && event.respondWith != null;
+}
+// Required for envs like nextjs edge runtime
+function isRequestAccessible(serverContext) {
+    try {
+        return !!serverContext?.request;
+    }
+    catch {
+        return false;
+    }
+}
+export function useFetchEvent() {
+    const eventMap = new WeakMap();
+    return {
+        onRequestAdapt({ args: [event, ...restOfCtx], setRequest, setServerContext }) {
+            if (isRequestAccessible(event)) {
+                setRequest(event.request);
+                const serverContext = restOfCtx.length > 0 ? completeAssign(...restOfCtx) : event;
+                setServerContext(serverContext);
+            }
+        },
+        onResponse({ request, response }) {
+            const event = eventMap.get(request);
+            if (isFetchEvent(event)) {
+                event.respondWith(response);
+            }
+        },
+    };
+}