fets/esm/plugins/uws.js

TypeScript HTTP Framework focusing on e2e type-safety, easy setup, performance & great developer experience

import { getRequestFromUWSRequest, handleOnRequestHook, sendResponseToUwsOpts, } from '@whatwg-node/server';
import { isLazySerializedResponse } from '../Response.js';
async function handleOnResponse({ request, response, res, serverContext, onResponseHooks, }) {
    for (const onResponseHook of onResponseHooks) {
        await onResponseHook({
            request: request,
            response,
            serverContext,
        });
    }
    await sendResponseToUwsOpts({
        response,
        res,
    });
}
export function useUWS(app) {
    const onRequestHooks = [];
    const onResponseHooks = [];
    const requestMap = new WeakMap();
    const serverContextMap = new WeakMap();
    let router;
    return {
        onRouterInit(_router) {
            router = _router;
            for (const plugin of router.plugins) {
                if (plugin.onRequest) {
                    onRequestHooks.push(plugin.onRequest);
                }
                if (plugin.onResponse) {
                    onResponseHooks.push(plugin.onResponse);
                }
            }
            app.any('/*', async function (res, req) {
                // Create a Request and attach it to the uWS request
                const request = getRequestFromUWSRequest({
                    req,
                    res,
                    fetchAPI: router.fetchAPI,
                });
                requestMap.set(req, request);
                const serverContext = {
                    req,
                    res,
                };
                serverContextMap.set(req, serverContext);
                const { response } = await handleOnRequestHook({
                    fetchAPI: router.fetchAPI,
                    request: request,
                    givenHandleRequest: (() => { }),
                    onRequestHooks,
                    serverContext,
                });
                if (!response) {
                    req.setYield(true);
                }
                else {
                    await handleOnResponse({
                        request,
                        response,
                        res,
                        serverContext,
                        onResponseHooks,
                    });
                }
            });
        },
        onRoute({ method, path, handlers }) {
            let appMethod = method.toLowerCase();
            let normalizedPath = path;
            if (!path.startsWith('/')) {
                normalizedPath = '/' + path;
            }
            for (const handler of handlers) {
                if (!(appMethod in app)) {
                    appMethod = 'any';
                }
                app[appMethod](normalizedPath, async function (res, req) {
                    if (appMethod === 'any') {
                        if (req.getMethod().toLowerCase() !== method.toLowerCase()) {
                            req.setYield(true);
                            return;
                        }
                    }
                    const request = requestMap.get(req);
                    const serverContext = requestMap.get(req);
                    let response = (await handler(request, serverContext));
                    if (isLazySerializedResponse(response)) {
                        for (const onSerializeResponseHook of router.__onSerializeResponseHooks) {
                            onSerializeResponseHook({
                                request,
                                lazyResponse: response,
                                serverContext,
                            });
                        }
                        if (!response.serializerSet) {
                            response = router.fetchAPI.Response.json(response.jsonObj, response.init);
                        }
                        else {
                            response = await response.responsePromise;
                        }
                    }
                    if (!response) {
                        req.setYield(true);
                    }
                    else {
                        if (response) {
                            await handleOnResponse({
                                request,
                                response,
                                res,
                                serverContext,
                                onResponseHooks,
                            });
                        }
                    }
                });
            }
        },
    };
}