@whatwg-node/server 0.7.4 → 0.7.5-alpha-20230320124321-e6b82e7

package/README.md

@@ -303,4 +303,4 @@ documentation.
 We'd recommend to use `fets` to handle routing and middleware approach. It uses
 `@whatwg-node/server` under the hood.
 
-> Learn more about `fets` [here](../fets)
+> Learn more about `fets` [here](https://github.com/ardatan/fets)

package/cjs/createServerAdapter.js

@@ -0,0 +1,251 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 utils_js_1 = require("./utils.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 === null || serverContext === void 0 ? void 0 : serverContext.request);
+    }
+    catch (_a) {
+        return false;
+    }
+}
+function createServerAdapter(serverAdapterBaseObject, options) {
+    const fetchAPI = {
+        ...DefaultFetchAPI,
+        ...options === null || options === void 0 ? void 0 : options.fetchAPI,
+    };
+    const givenHandleRequest = typeof serverAdapterBaseObject === 'function'
+        ? serverAdapterBaseObject
+        : serverAdapterBaseObject.handle;
+    const onRequestHooks = [];
+    const onResponseHooks = [];
+    if ((options === null || options === void 0 ? void 0 : 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) {
+        let url = new Proxy({}, {
+            get: (_target, prop, _receiver) => {
+                url = new fetchAPI.URL(request.url, 'http://localhost');
+                return Reflect.get(url, prop, url);
+            },
+        });
+        let requestHandler = givenHandleRequest;
+        let response;
+        for (const onRequestHook of onRequestHooks) {
+            await onRequestHook({
+                request,
+                serverContext,
+                fetchAPI,
+                url,
+                requestHandler,
+                setRequestHandler(newRequestHandler) {
+                    requestHandler = newRequestHandler;
+                },
+                endResponse(newResponse) {
+                    response = newResponse;
+                },
+            });
+            if (response) {
+                break;
+            }
+        }
+        if (!response) {
+            response = await requestHandler(request, serverContext);
+        }
+        for (const onResponseHook of onResponseHooks) {
+            await onResponseHook({
+                request,
+                response,
+                serverContext,
+            });
+        }
+        return response;
+    }
+    function handleNodeRequest(nodeRequest, ...ctx) {
+        const serverContext = ctx.length > 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,
+            waitUntil(promise) {
+                if (promise != null) {
+                    waitUntilPromises.push(promise);
+                }
+            },
+        };
+        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();
+            });
+        }
+        if (waitUntilPromises.length > 0) {
+            await handleWaitUntils(waitUntilPromises);
+        }
+    }
+    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 (!('waitUntil' in serverContext)) {
+            const waitUntilPromises = [];
+            const response$ = handleRequest(request, {
+                ...serverContext,
+                waitUntil(promise) {
+                    if (promise != null) {
+                        waitUntilPromises.push(promise);
+                    }
+                },
+            });
+            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)) {
+                return handleRequestWithWaitUntil(new fetchAPI.Request(input, initOrCtx), ...restOfCtx);
+            }
+            return handleRequestWithWaitUntil(new fetchAPI.Request(input), ...maybeCtx);
+        }
+        return handleRequestWithWaitUntil(input, ...maybeCtx);
+    };
+    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, utils_js_1.isServerResponse)(initOrCtxOrRes)) {
+            throw new TypeError('Got Node response without Node request');
+        }
+        // Is input a container object over Request?
+        if (isRequestAccessible(input)) {
+            // Is it FetchEvent?
+            if ((0, utils_js_1.isFetchEvent)(input)) {
+                return handleEvent(input, ...maybeCtx);
+            }
+            // In this input is also the context
+            return handleRequestWithWaitUntil(input.request, input, ...maybeCtx);
+        }
+        // Or is it Request itself?
+        // Then ctx is present and it is the context
+        return fetchFn(input, ...maybeCtx);
+    };
+    const adapterObj = {
+        handleRequest,
+        fetch: fetchFn,
+        handleNodeRequest,
+        requestListener,
+        handleEvent,
+        handle: genericRequestHandler,
+    };
+    const serverAdapter = new Proxy(genericRequestHandler, {
+        // It should have all the attributes of the handler function and the server instance
+        has: (_, prop) => {
+            return (prop in adapterObj ||
+                prop in genericRequestHandler ||
+                (serverAdapterBaseObject && prop in serverAdapterBaseObject));
+        },
+        get: (_, prop) => {
+            const adapterProp = adapterObj[prop];
+            if (adapterProp) {
+                if (adapterProp.bind) {
+                    return adapterProp.bind(adapterObj);
+                }
+                return adapterProp;
+            }
+            const handleProp = genericRequestHandler[prop];
+            if (handleProp) {
+                if (handleProp.bind) {
+                    return handleProp.bind(genericRequestHandler);
+                }
+                return handleProp;
+            }
+            if (serverAdapterBaseObject) {
+                const serverAdapterBaseObjectProp = serverAdapterBaseObject[prop];
+                if (serverAdapterBaseObjectProp) {
+                    if (serverAdapterBaseObjectProp.bind) {
+                        return function (...args) {
+                            const returnedVal = serverAdapterBaseObject[prop](...args);
+                            if (returnedVal === serverAdapterBaseObject) {
+                                return serverAdapter;
+                            }
+                            return returnedVal;
+                        };
+                    }
+                    return serverAdapterBaseObjectProp;
+                }
+            }
+        },
+        apply(_, __, args) {
+            return genericRequestHandler(...args);
+        },
+    });
+    return serverAdapter;
+}
+exports.createServerAdapter = createServerAdapter;
+// from https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign#copying_accessors
+function completeAssign(target, ...sources) {
+    sources.forEach(source => {
+        if (source != null && typeof source === 'object') {
+            // modified Object.keys to Object.getOwnPropertyNames
+            // because Object.keys only returns enumerable properties
+            const descriptors = Object.getOwnPropertyNames(source).reduce((descriptors, key) => {
+                descriptors[key] = Object.getOwnPropertyDescriptor(source, key);
+                return descriptors;
+            }, {});
+            // By default, Object.assign copies enumerable Symbols, too
+            Object.getOwnPropertySymbols(source).forEach(sym => {
+                const descriptor = Object.getOwnPropertyDescriptor(source, sym);
+                if (descriptor.enumerable) {
+                    descriptors[sym] = descriptor;
+                }
+            });
+            Object.defineProperties(target, descriptors);
+        }
+    });
+    return target;
+}

package/cjs/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Response = void 0;
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./createServerAdapter.js"), exports);
+tslib_1.__exportStar(require("./types.js"), exports);
+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);
+var fetch_1 = require("@whatwg-node/fetch");
+Object.defineProperty(exports, "Response", { enumerable: true, get: function () { return fetch_1.Response; } });

package/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/cjs/plugins/useCors.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useCORS = exports.getCORSHeadersByRequestAndOptions = void 0;
+function getCORSHeadersByRequestAndOptions(request, corsOptions) {
+    var _a, _b;
+    const currentOrigin = request.headers.get('origin');
+    if (corsOptions === false || currentOrigin == null) {
+        return null;
+    }
+    const headers = {};
+    // If defined origins have '*' or undefined by any means, we should allow all origins
+    if (corsOptions.origin == null ||
+        corsOptions.origin.length === 0 ||
+        corsOptions.origin.includes('*')) {
+        headers['Access-Control-Allow-Origin'] = currentOrigin;
+        // Vary by origin because there are multiple origins
+        headers['Vary'] = 'Origin';
+    }
+    else if (typeof corsOptions.origin === 'string') {
+        // If there is one specific origin is specified, use it directly
+        headers['Access-Control-Allow-Origin'] = corsOptions.origin;
+    }
+    else if (Array.isArray(corsOptions.origin)) {
+        // If there is only one origin defined in the array, consider it as a single one
+        if (corsOptions.origin.length === 1) {
+            headers['Access-Control-Allow-Origin'] = corsOptions.origin[0];
+        }
+        else if (corsOptions.origin.includes(currentOrigin)) {
+            // If origin is available in the headers, use it
+            headers['Access-Control-Allow-Origin'] = currentOrigin;
+            // Vary by origin because there are multiple origins
+            headers['Vary'] = 'Origin';
+        }
+        else {
+            // There is no origin found in the headers, so we should return null
+            headers['Access-Control-Allow-Origin'] = 'null';
+        }
+    }
+    if ((_a = corsOptions.methods) === null || _a === void 0 ? void 0 : _a.length) {
+        headers['Access-Control-Allow-Methods'] = corsOptions.methods.join(', ');
+    }
+    else {
+        const requestMethod = request.headers.get('access-control-request-method');
+        if (requestMethod) {
+            headers['Access-Control-Allow-Methods'] = requestMethod;
+        }
+    }
+    if ((_b = corsOptions.allowedHeaders) === null || _b === void 0 ? void 0 : _b.length) {
+        headers['Access-Control-Allow-Headers'] = corsOptions.allowedHeaders.join(', ');
+    }
+    else {
+        const requestHeaders = request.headers.get('access-control-request-headers');
+        if (requestHeaders) {
+            headers['Access-Control-Allow-Headers'] = requestHeaders;
+            if (headers['Vary']) {
+                headers['Vary'] += ', Access-Control-Request-Headers';
+            }
+            headers['Vary'] = 'Access-Control-Request-Headers';
+        }
+    }
+    if (corsOptions.credentials != null) {
+        if (corsOptions.credentials === true) {
+            headers['Access-Control-Allow-Credentials'] = 'true';
+        }
+    }
+    else if (headers['Access-Control-Allow-Origin'] !== '*') {
+        headers['Access-Control-Allow-Credentials'] = 'true';
+    }
+    if (corsOptions.exposedHeaders) {
+        headers['Access-Control-Expose-Headers'] = corsOptions.exposedHeaders.join(', ');
+    }
+    if (corsOptions.maxAge) {
+        headers['Access-Control-Max-Age'] = corsOptions.maxAge.toString();
+    }
+    return headers;
+}
+exports.getCORSHeadersByRequestAndOptions = getCORSHeadersByRequestAndOptions;
+async function getCORSResponseHeaders(request, corsOptionsFactory, serverContext) {
+    const corsOptions = await corsOptionsFactory(request, serverContext);
+    return getCORSHeadersByRequestAndOptions(request, corsOptions);
+}
+function useCORS(options) {
+    let corsOptionsFactory = () => ({});
+    if (options != null) {
+        if (typeof options === 'function') {
+            corsOptionsFactory = options;
+        }
+        else if (typeof options === 'object') {
+            const corsOptions = {
+                ...options,
+            };
+            corsOptionsFactory = () => corsOptions;
+        }
+        else if (options === false) {
+            corsOptionsFactory = () => false;
+        }
+    }
+    return {
+        onRequest({ request, fetchAPI, endResponse }) {
+            if (request.method.toUpperCase() === 'OPTIONS') {
+                const response = new fetchAPI.Response(null, {
+                    status: 204,
+                    // Safari (and potentially other browsers) need content-length 0,
+                    // for 204 or they just hang waiting for a body
+                    // see: https://github.com/expressjs/cors/blob/master/lib/index.js#L176
+                    headers: {
+                        'Content-Length': '0',
+                    },
+                });
+                endResponse(response);
+            }
+        },
+        async onResponse({ request, serverContext, response }) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const headers = await getCORSResponseHeaders(request, corsOptionsFactory, serverContext);
+            if (headers != null) {
+                for (const headerName in headers) {
+                    response.headers.set(headerName, headers[headerName]);
+                }
+            }
+        },
+    };
+}
+exports.useCORS = useCORS;

package/cjs/plugins/useErrorHandling.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useErrorHandling = exports.HTTPError = exports.createDefaultErrorHandler = void 0;
+const fetch_1 = require("@whatwg-node/fetch");
+function createDefaultErrorHandler(ResponseCtor = fetch_1.Response) {
+    return function defaultErrorHandler(e) {
+        return new ResponseCtor(typeof e.details === 'object'
+            ? JSON.stringify(e.details)
+            : e.stack || e.message || e.toString(), {
+            status: e.statusCode || e.status || 500,
+            headers: e.headers || {},
+        });
+    };
+}
+exports.createDefaultErrorHandler = createDefaultErrorHandler;
+class HTTPError extends Error {
+    constructor(status, message, headers = {}, details) {
+        super(message);
+        this.status = status;
+        this.message = message;
+        this.headers = headers;
+        this.details = details;
+        Error.captureStackTrace(this, HTTPError);
+    }
+}
+exports.HTTPError = HTTPError;
+function useErrorHandling(onError) {
+    return {
+        onRequest({ requestHandler, setRequestHandler, fetchAPI }) {
+            const errorHandler = onError || createDefaultErrorHandler(fetchAPI.Response);
+            setRequestHandler(async function handlerWithErrorHandling(request, serverContext) {
+                try {
+                    const response = await requestHandler(request, serverContext);
+                    return response;
+                }
+                catch (e) {
+                    const response = await errorHandler(e, request, serverContext);
+                    return response;
+                }
+            });
+        },
+    };
+}
+exports.useErrorHandling = useErrorHandling;