grafserv/dist/servers/whatwg-node__server/v0/index.js

A highly optimized server for GraphQL, powered by Grafast

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.WhatwgGrafserv = void 0;
exports.getBodyFromRequest = getBodyFromRequest;
exports.grafserv = grafserv;
const server_1 = require("@whatwg-node/server");
const base_js_1 = require("../../../core/base.js");
const utils_js_1 = require("../../../utils.js");
async function getBodyFromRequest(req /* IncomingMessage */, maxLength) {
    const reader = req.body?.getReader();
    if (!reader) {
        return { type: "buffer", buffer: Buffer.from([]) };
    }
    const chunks = [];
    let len = 0;
    while (true) {
        const { done, value } = await reader.read();
        if (value) {
            chunks.push(Buffer.from(value));
            len += value.length;
            if (len > maxLength) {
                throw (0, utils_js_1.httpError)(413, "Too much data");
            }
        }
        if (done) {
            return { type: "buffer", buffer: Buffer.concat(chunks, len) };
        }
    }
}
/** @experimental */
class WhatwgGrafserv extends base_js_1.GrafservBase {
    whatwgRequestToGrafserv(dynamicOptions, request) {
        const url = new URL(request.url);
        return {
            httpVersionMajor: 1,
            httpVersionMinor: 1,
            isSecure: url.protocol === "https:",
            method: request.method,
            path: url.pathname,
            headers: this.processHeaders(request.headers),
            getQueryParams() {
                return Object.fromEntries(url.searchParams.entries());
            },
            async getBody() {
                return getBodyFromRequest(request, dynamicOptions.maxRequestLength);
            },
            requestContext: {
                whatwgv0: {
                    request,
                },
            },
            preferJSON: true,
        };
    }
    processHeaders(headers) {
        const headerDigest = Object.create(null);
        headers.forEach((v, k) => {
            headerDigest[k] = v;
        });
        return headerDigest;
    }
    grafservResponseToWhatwg(response) {
        if (response === null) {
            return new Response("¯\\_(ツ)_/¯", {
                status: 404,
                headers: new Headers({ "Content-Type": "text/plain" }),
            });
        }
        switch (response.type) {
            case "error": {
                const { statusCode, headers, error } = response;
                const respHeaders = new Headers(headers);
                respHeaders.append("Content-Type", "text/plain");
                return new Response(error.message, {
                    status: statusCode,
                    headers: respHeaders,
                });
            }
            case "buffer": {
                const { statusCode, headers, buffer } = response;
                const respHeaders = new Headers(headers);
                return new Response(buffer, {
                    status: statusCode,
                    headers: respHeaders,
                });
            }
            case "json": {
                const { statusCode, headers, json } = response;
                const respHeaders = new Headers(headers);
                return new Response(JSON.stringify(json), {
                    status: statusCode,
                    headers: respHeaders,
                });
            }
            case "noContent": {
                const { statusCode, headers } = response;
                const respHeaders = new Headers(headers);
                return new Response(null, {
                    status: statusCode,
                    headers: respHeaders,
                });
            }
            default: {
                console.log("Unhandled:");
                console.dir(response);
                return new Response("Server hasn't implemented this yet", {
                    status: 501,
                    headers: new Headers({ "Content-Type": "text/plain" }),
                });
            }
        }
    }
    createHandler() {
        return (0, server_1.createServerAdapter)(async (request) => {
            const dynamicOptions = this.dynamicOptions;
            return this.grafservResponseToWhatwg(await this.processWhatwgRequest(request, this.whatwgRequestToGrafserv(dynamicOptions, request)));
        });
    }
    addTo(server) {
        const handler = this.createHandler();
        server.on("request", handler);
        this.onRelease(() => {
            server.off("request", handler);
        });
    }
    processWhatwgRequest(_request, request) {
        return this.processRequest(request);
    }
}
exports.WhatwgGrafserv = WhatwgGrafserv;
/** @experimental */
function grafserv(config) {
    return new WhatwgGrafserv(config);
}
//# sourceMappingURL=index.js.map