@3sixty/api-server-native 0.20.0-next.0 → 0.20.0-next.1

package/dist/es/nativeWebServer.js

@@ -0,0 +1,863 @@
+// Copyright 2026 3Sixty Trade Ltd.
+// SPDX-License-Identifier: Apache-2.0.
+import { lookup } from "node:dns/promises";
+import { once } from "node:events";
+import { createServer as createHttpServer } from "node:http";
+import { createServer as createHttpsServer } from "node:https";
+import { createServer as createNetServer } from "node:net";
+import { parse as parseQuery } from "node:querystring";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { promisify } from "node:util";
+import zlib from "node:zlib";
+import { BaseServer } from "@3sixty/api-core-server";
+import { HttpBodyLimit, HttpErrorHelper } from "@3sixty/api-models";
+import { BaseError, Converter, GeneralError, Is, StringHelper } from "@3sixty/core";
+import { HeaderTypes, HttpMethod, HttpStatusCode, MimeTypes } from "@3sixty/web";
+import Router from "find-my-way";
+import { Server } from "socket.io";
+/**
+ * Implementation of the web server using the Node.js HTTP server and the find-my-way router.
+ */
+export class NativeWebServer extends BaseServer {
+    /**
+     * Runtime name for the class.
+     */
+    static CLASS_NAME = "NativeWebServer";
+    /**
+     * Matches the content types which are worth compressing.
+     * @internal
+     */
+    static _COMPRESSIBLE_TYPES = /^\s*(?:text\/(?!event-stream)|application\/(?:json|javascript|xml|x-www-form-urlencoded)|[^;\s]+\+(?:json|xml|text|yaml))/i;
+    /**
+     * The minimum size in bytes of a response body before it is compressed.
+     * @internal
+     */
+    static _COMPRESS_THRESHOLD = 1024;
+    /**
+     * The supported response encodings in order of preference, matching the Fastify defaults.
+     * @internal
+     */
+    static _ENCODINGS = ["zstd", "br", "gzip", "deflate"];
+    /**
+     * The Brotli options, matching the Fastify defaults as the zlib defaults are very slow.
+     * @internal
+     */
+    static _BROTLI_OPTIONS = {
+        params: {
+            [zlib.constants.BROTLI_PARAM_MODE]: zlib.constants.BROTLI_MODE_TEXT,
+            [zlib.constants.BROTLI_PARAM_QUALITY]: 4
+        }
+    };
+    /**
+     * The compressors for each encoding.
+     * @internal
+     */
+    static _COMPRESSORS = {
+        zstd: promisify(zlib.zstdCompress),
+        br: async (body) => promisify(zlib.brotliCompress)(body, NativeWebServer._BROTLI_OPTIONS),
+        gzip: promisify(zlib.gzip),
+        deflate: promisify(zlib.deflate)
+    };
+    /**
+     * The stream compressors for each encoding.
+     * @internal
+     */
+    static _STREAM_COMPRESSORS = {
+        zstd: () => zlib.createZstdCompress(),
+        br: () => zlib.createBrotliCompress(NativeWebServer._BROTLI_OPTIONS),
+        gzip: () => zlib.createGzip(),
+        deflate: () => zlib.createDeflate()
+    };
+    /**
+     * The HTTP status codes for the errors raised by the transport.
+     * @internal
+     */
+    static _ERROR_STATUS_CODES = new WeakMap();
+    /**
+     * The router.
+     * @internal
+     */
+    _router;
+    /**
+     * The maximum length of a path param.
+     * @internal
+     */
+    _maxParamLength;
+    /**
+     * The options for the node web server.
+     * @internal
+     */
+    _webConfig;
+    /**
+     * The options for the socket server.
+     * @internal
+     */
+    _socketConfig;
+    /**
+     * The mime type processors keyed by the media type they handle.
+     * @internal
+     */
+    _mimeTypeProcessorMap;
+    /**
+     * The body limit for requests which do not match a route.
+     * @internal
+     */
+    _defaultBodyLimit;
+    /**
+     * The resolved CORS settings, available once built.
+     * @internal
+     */
+    _cors;
+    /**
+     * The node server, available once listening.
+     * @internal
+     */
+    _server;
+    /**
+     * Listeners for additional bound addresses, which forward connections to the main server.
+     * @internal
+     */
+    _additionalServers;
+    /**
+     * The socket server, available once built with socket routes.
+     * @internal
+     */
+    _socketServer;
+    /**
+     * Create a new instance of NativeWebServer.
+     * @param options The options for the server.
+     */
+    constructor(options) {
+        super({
+            loggingComponentType: options?.loggingComponentType,
+            mimeTypeProcessors: options?.mimeTypeProcessors,
+            includeErrorStack: options?.config?.includeErrorStack
+        });
+        this._webConfig = options?.config?.web;
+        this._maxParamLength = this._webConfig?.maxParamLength ?? 2000;
+        // The router does not match a route with a param over its limit, so the limit is checked
+        // once matched, to respond like Fastify rather than as not found
+        this._router = Router({ maxParamLength: Number.MAX_SAFE_INTEGER });
+        this._socketConfig = {
+            path: "/socket",
+            ...options?.config?.socket
+        };
+        this._mimeTypeProcessorMap = {};
+        this._defaultBodyLimit = 0;
+        this._additionalServers = [];
+    }
+    /**
+     * Returns the class name of the component.
+     * @returns The class name of the component.
+     */
+    className() {
+        return NativeWebServer.CLASS_NAME;
+    }
+    /**
+     * Get the web server instance.
+     * @returns The web server instance.
+     */
+    getInstance() {
+        return this._router;
+    }
+    /**
+     * Build the server.
+     * @param restRouteProcessors The processors for incoming requests over REST.
+     * @param restRoutes The REST routes.
+     * @param socketRouteProcessors The processors for incoming requests over Sockets.
+     * @param socketRoutes The socket routes.
+     * @param options Options for building the server.
+     * @returns A promise that resolves when the server is fully built and ready to start.
+     */
+    async build(restRouteProcessors, restRoutes, socketRouteProcessors, socketRoutes, options) {
+        await this.prepareBuild(restRouteProcessors, restRoutes, socketRouteProcessors, socketRoutes, options);
+        if (Is.arrayValue(socketRoutes)) {
+            this._socketServer = new Server(this._socketConfig);
+        }
+        // Processors supplied first take precedence for a media type
+        for (const mimeTypeProcessor of [...this._mimeTypeProcessors].reverse()) {
+            for (const mediaType of mimeTypeProcessor.getTypes()) {
+                this._mimeTypeProcessorMap[mediaType.toLowerCase()] = mimeTypeProcessor;
+            }
+        }
+        const corsOptions = this.resolveCorsOptions(options);
+        this._cors = {
+            hasWildcardOrigin: corsOptions.hasWildcardOrigin,
+            origins: corsOptions.origins,
+            allowMethods: corsOptions.methods.join(", "),
+            allowHeaders: corsOptions.allowedHeaders.join(", "),
+            exposeHeaders: corsOptions.exposedHeaders.join(", ")
+        };
+        const bodyLimits = this.resolveBodyLimits();
+        this._defaultBodyLimit = bodyLimits[HttpBodyLimit.Default];
+        await this.addRoutesRest(bodyLimits, restRouteProcessors, restRoutes);
+        await this.addRoutesSocket(socketRouteProcessors, socketRoutes);
+    }
+    /**
+     * Start listening for connections on the transport.
+     * @param host The host to bind to.
+     * @param port The port to bind to.
+     * @returns A promise that resolves when the transport is listening.
+     */
+    async serverListen(host, port) {
+        const listener = async (req, res) => this.handleRequest(req, res);
+        const server = Is.object(this._webConfig?.https)
+            ? createHttpsServer({ ...this._webConfig.serverOptions, ...this._webConfig.https }, listener)
+            : createHttpServer(this._webConfig?.serverOptions ?? {}, listener);
+        this._socketServer?.attach(server);
+        // Generate the optimised lookups now that all the routes are registered
+        this._router.compile();
+        // Like Fastify, bind every address localhost resolves to, so both IPv4 and IPv6 clients connect
+        const hosts = host === "localhost"
+            ? [...new Set((await lookup(host, { all: true })).map(a => a.address))]
+            : [host];
+        await this.listenOn(server, hosts[0], port);
+        this._server = server;
+        for (const additionalHost of hosts.slice(1)) {
+            const additionalServer = createNetServer(socket => server.emit("connection", socket));
+            try {
+                await this.listenOn(additionalServer, additionalHost, port);
+                this._additionalServers.push(additionalServer);
+            }
+            catch (err) {
+                // An additional address failing to bind does not stop the server
+                await this._logging?.log({
+                    level: "warn",
+                    ts: Date.now(),
+                    source: NativeWebServer.CLASS_NAME,
+                    message: "additionalBindingFailed",
+                    data: { host: additionalHost, port },
+                    error: BaseError.fromError(err)
+                });
+            }
+        }
+    }
+    /**
+     * Close the transport and all of its connections.
+     * @returns A promise that resolves when the transport has closed.
+     */
+    async serverClose() {
+        const server = this._server;
+        const additionalServers = this._additionalServers;
+        this._server = undefined;
+        this._additionalServers = [];
+        // The forwarded connections are only released when the main server closes its idle
+        // connections, so all the servers must be closed together
+        const closing = additionalServers.map(async (s) => this.closeServer(s));
+        if (!Is.empty(this._socketServer)) {
+            closing.push(this.closeSocketServer(this._socketServer, server));
+        }
+        else if (!Is.empty(server)) {
+            closing.push(this.closeServer(server));
+        }
+        await Promise.all(closing);
+    }
+    /**
+     * Get the addresses the transport is bound to.
+     * @returns The bound addresses.
+     */
+    serverAddresses() {
+        const addresses = [];
+        for (const server of [this._server, ...this._additionalServers]) {
+            const address = server?.address();
+            if (Is.object(address)) {
+                addresses.push({ address: address.address, family: address.family, port: address.port });
+            }
+        }
+        return addresses;
+    }
+    /**
+     * Whether the transport is serving over TLS.
+     * @returns True if the transport is secure.
+     */
+    serverIsSecure() {
+        return Is.object(this._webConfig?.https);
+    }
+    /**
+     * Whether the transport is currently listening for connections.
+     * @returns True if the transport is listening.
+     */
+    serverIsListening() {
+        return this._server?.listening ?? false;
+    }
+    /**
+     * Whether a GET route is registered for the root path.
+     * @returns True if the root route is registered.
+     */
+    serverHasRootRoute() {
+        return this._router.hasRoute(HttpMethod.GET, "/");
+    }
+    /**
+     * Add the REST routes to the server.
+     * @param bodyLimits The named body limits in bytes.
+     * @param restRouteProcessors The processors for the incoming requests.
+     * @param restRoutes The REST routes to add.
+     * @internal
+     */
+    async addRoutesRest(bodyLimits, restRouteProcessors, restRoutes) {
+        if (Is.arrayValue(restRouteProcessors) && Is.arrayValue(restRoutes)) {
+            for (const restRoute of restRoutes) {
+                let path = StringHelper.trimTrailingSlashes(restRoute.path);
+                if (!path.startsWith("/")) {
+                    path = `/${path}`;
+                }
+                await this._logging?.log({
+                    level: "info",
+                    ts: Date.now(),
+                    source: NativeWebServer.CLASS_NAME,
+                    message: "restRouteAdded",
+                    data: { route: path, method: restRoute.method }
+                });
+                const bodyLimitKey = Is.stringValue(restRoute.bodyLimit)
+                    ? restRoute.bodyLimit
+                    : HttpBodyLimit.Default;
+                const bodyLimit = bodyLimits[bodyLimitKey];
+                if (Is.empty(bodyLimit)) {
+                    throw new GeneralError(NativeWebServer.CLASS_NAME, "unknownBodyLimit", {
+                        route: path,
+                        bodyLimit: bodyLimitKey
+                    });
+                }
+                this._router.on(restRoute.method, path, async (req, res, params, store, searchParams) => this.handleRequestRest(req, res, bodyLimit, params, searchParams, restRoute));
+            }
+        }
+    }
+    /**
+     * Add the socket routes to the server.
+     * @param socketRouteProcessors The processors for the incoming requests.
+     * @param socketRoutes The socket routes to add.
+     * @internal
+     */
+    async addRoutesSocket(socketRouteProcessors, socketRoutes) {
+        const io = this._socketServer;
+        if (Is.arrayValue(socketRouteProcessors) && Is.arrayValue(socketRoutes) && !Is.empty(io)) {
+            for (const socketRoute of socketRoutes) {
+                const path = StringHelper.trimLeadingSlashes(StringHelper.trimTrailingSlashes(socketRoute.path));
+                const pathParts = path.split("/");
+                const namespace = `/${pathParts[0]}`;
+                const topic = pathParts.slice(1).join("/");
+                await this._logging?.log({
+                    level: "info",
+                    ts: Date.now(),
+                    source: NativeWebServer.CLASS_NAME,
+                    message: "socketRouteAdded",
+                    data: {
+                        handshakePath: this._socketConfig.path,
+                        namespace,
+                        eventName: topic
+                    }
+                });
+                const socketNamespace = io.of(namespace);
+                socketNamespace.on("connection", async (socket) => {
+                    const socketServerRequest = {
+                        method: HttpMethod.GET,
+                        url: socket.handshake.url,
+                        query: socket.handshake.query,
+                        headers: socket.handshake.headers,
+                        socketId: socket.id
+                    };
+                    // Pass the connected information on to any processors
+                    try {
+                        for (const connected of this._socketChains.connected) {
+                            await connected(socketServerRequest, socketRoute, this._loggingComponentType);
+                        }
+                    }
+                    catch (err) {
+                        const { error, httpStatusCode } = HttpErrorHelper.processError(err, this._includeErrorStack);
+                        const response = {};
+                        HttpErrorHelper.buildResponse(response, error, httpStatusCode, this._includeErrorStack);
+                        socket.emit(topic, response);
+                    }
+                    socket.on("disconnect", async () => {
+                        try {
+                            // The socket disconnected so notify any processors
+                            for (const disconnected of this._socketChains.disconnected) {
+                                await disconnected(socketServerRequest, socketRoute, this._loggingComponentType);
+                            }
+                        }
+                        catch {
+                            // If something fails on a disconnect there is not much we can do with it
+                        }
+                    });
+                    // Handle any incoming messages
+                    socket.on(topic, async (data) => {
+                        // The listener is async, so anything escaping it would surface as an unhandled
+                        // rejection and terminate the process, emit it on the topic instead
+                        try {
+                            await this.handleRequestSocket(socketRoute, socket, `/${pathParts.join("/")}`, topic, data);
+                        }
+                        catch (err) {
+                            const { error, httpStatusCode } = HttpErrorHelper.processError(err, this._includeErrorStack);
+                            const response = {};
+                            HttpErrorHelper.buildResponse(response, error, httpStatusCode, this._includeErrorStack);
+                            socket.emit(topic, response);
+                        }
+                    });
+                });
+            }
+        }
+    }
+    /**
+     * Handle an incoming HTTP request, routing it to its handler.
+     * @param req The incoming request.
+     * @param res The outgoing response.
+     * @internal
+     */
+    async handleRequest(req, res) {
+        try {
+            if (this.applyCors(req, res)) {
+                return;
+            }
+            const method = (req.method ?? HttpMethod.GET);
+            const url = req.url ?? "/";
+            const queryStart = url.indexOf("?");
+            // Like Fastify, a path which is not valid percent encoding is rejected
+            const path = queryStart === -1 ? url : url.slice(0, queryStart);
+            if (path.includes("%")) {
+                try {
+                    decodeURIComponent(path);
+                }
+                catch (err) {
+                    throw this.createTransportError(HttpStatusCode.badRequest, new GeneralError(NativeWebServer.CLASS_NAME, "invalidUrl", { path }, err));
+                }
+            }
+            let found = this._router.find(method, url);
+            // Like Fastify, HEAD requests are served by the GET route when there is no HEAD route
+            if (Is.empty(found) && method === HttpMethod.HEAD) {
+                found = this._router.find(HttpMethod.GET, url);
+            }
+            if (Is.empty(found)) {
+                const query = queryStart === -1 ? {} : parseQuery(url.slice(queryStart + 1));
+                await this.handleRequestRest(req, res, this._defaultBodyLimit, {}, query);
+            }
+            else {
+                for (const param of Object.keys(found.params)) {
+                    if ((found.params[param]?.length ?? 0) > this._maxParamLength) {
+                        throw this.createTransportError(HttpStatusCode.uriTooLong, new GeneralError(NativeWebServer.CLASS_NAME, "paramTooLong", {
+                            param,
+                            maxParamLength: this._maxParamLength
+                        }));
+                    }
+                }
+                await found.handler(req, res, found.params, found.store, found.searchParams);
+            }
+        }
+        catch (err) {
+            await this.sendError(res, err);
+        }
+    }
+    /**
+     * Handle the incoming REST request.
+     * @param req The incoming request.
+     * @param res The outgoing response.
+     * @param bodyLimit The maximum size of the request body in bytes.
+     * @param pathParams The request path params.
+     * @param query The request query params.
+     * @param restRoute The REST route to handle.
+     * @internal
+     */
+    async handleRequestRest(req, res, bodyLimit, pathParams, query, restRoute) {
+        const isSecure = req.socket.encrypted === true;
+        let host = req.headers.host ?? "localhost";
+        // Like Fastify, the default port for the protocol is omitted from the origin
+        if ((isSecure && host.endsWith(":443")) || (!isSecure && host.endsWith(":80"))) {
+            host = host.slice(0, host.lastIndexOf(":"));
+        }
+        const requestOrigin = `${isSecure ? "https" : "http"}://${host}`;
+        const headers = req.headers;
+        const httpServerRequest = this.buildServerRequest((req.method ?? HttpMethod.GET).toUpperCase(), `${requestOrigin}${req.url ?? "/"}`, await this.parseBody(req, headers, bodyLimit), query, pathParams, headers);
+        const httpResponse = {};
+        const contextIds = this.buildContextIds(requestOrigin, httpServerRequest.headers);
+        const processorState = {};
+        await this.runProcessorsRest(restRoute, httpServerRequest, httpResponse, contextIds, processorState);
+        await this.sendResponse(req, res, httpResponse);
+    }
+    /**
+     * Handle the incoming socket request.
+     * @param socketRoute The socket route to handle.
+     * @param socket The socket to handle.
+     * @param fullPath The full path of the socket route.
+     * @param emitTopic The topic to emit the response on.
+     * @param request The incoming request.
+     * @internal
+     */
+    async handleRequestSocket(socketRoute, socket, fullPath, emitTopic, request) {
+        const socketServerRequest = {
+            method: HttpMethod.GET,
+            url: fullPath,
+            query: socket.handshake.query,
+            headers: socket.handshake.headers,
+            // The payload arrives straight off the wire, so it can be missing or any shape
+            body: Is.object(request) ? request.body : undefined,
+            socketId: socket.id
+        };
+        const httpResponse = {};
+        const contextIds = {};
+        const processorState = {};
+        delete socketServerRequest.query?.EIO;
+        delete socketServerRequest.query?.transport;
+        await this.runProcessorsSocket(socketRoute, socketServerRequest, httpResponse, contextIds, processorState, emitTopic, async (topic, response) => {
+            socket.emit(topic, response);
+        });
+    }
+    /**
+     * Apply the CORS headers to the response, mirroring the Fastify CORS plugin.
+     * @param req The incoming request.
+     * @param res The outgoing response.
+     * @returns True if the request was a preflight request which has been responded to.
+     * @internal
+     */
+    applyCors(req, res) {
+        const cors = this._cors;
+        if (Is.empty(cors)) {
+            return false;
+        }
+        res.setHeader("vary", "Origin");
+        const origin = req.headers.origin;
+        const allowed = cors.hasWildcardOrigin || (Is.stringValue(origin) && cors.origins.includes(origin));
+        if (!allowed) {
+            return false;
+        }
+        if (Is.stringValue(origin)) {
+            res.setHeader("access-control-allow-origin", origin);
+        }
+        res.setHeader("access-control-allow-credentials", "true");
+        res.setHeader("access-control-expose-headers", cors.exposeHeaders);
+        if (req.method === HttpMethod.OPTIONS) {
+            if (!Is.stringValue(origin) ||
+                !Is.stringValue(req.headers["access-control-request-method"])) {
+                res.writeHead(HttpStatusCode.badRequest, {
+                    [HeaderTypes.ContentType]: `${MimeTypes.PlainText}; charset=utf-8`
+                });
+                res.end("Invalid Preflight Request");
+                return true;
+            }
+            res.writeHead(HttpStatusCode.noContent, {
+                "access-control-allow-methods": cors.allowMethods,
+                "access-control-allow-headers": cors.allowHeaders,
+                [HeaderTypes.ContentLength]: "0"
+            });
+            res.end();
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Read and parse the request body based on its content type.
+     * @param req The incoming request.
+     * @param headers The request headers.
+     * @param bodyLimit The maximum size of the request body in bytes.
+     * @returns The parsed body, or undefined if there is no body.
+     * @throws GeneralError If the body is too large, malformed or an unsupported media type.
+     * @internal
+     */
+    async parseBody(req, headers, bodyLimit) {
+        if (req.method === HttpMethod.GET || req.method === HttpMethod.HEAD) {
+            return undefined;
+        }
+        const contentType = headers[HeaderTypes.ContentType];
+        const mediaType = (Is.string(contentType) ? contentType : "")
+            .split(";")[0]
+            .trim()
+            .toLowerCase();
+        const raw = await this.readBody(req, headers, bodyLimit);
+        if (Is.empty(raw)) {
+            // Like Fastify, declaring a JSON body without sending one is an error
+            if (mediaType === MimeTypes.Json) {
+                throw this.createTransportError(HttpStatusCode.badRequest, new GeneralError(NativeWebServer.CLASS_NAME, "emptyJsonBody"));
+            }
+            return undefined;
+        }
+        const mimeTypeProcessor = this._mimeTypeProcessorMap[mediaType];
+        if (!Is.empty(mimeTypeProcessor)) {
+            return mimeTypeProcessor.handle(raw);
+        }
+        if (mediaType === MimeTypes.Json) {
+            const text = Converter.bytesToUtf8(raw);
+            try {
+                return JSON.parse(text);
+            }
+            catch (err) {
+                throw this.createTransportError(HttpStatusCode.badRequest, new GeneralError(NativeWebServer.CLASS_NAME, "invalidJsonBody", undefined, err));
+            }
+        }
+        if (mediaType === MimeTypes.PlainText) {
+            return Converter.bytesToUtf8(raw);
+        }
+        throw this.createTransportError(HttpStatusCode.unsupportedMediaType, new GeneralError(NativeWebServer.CLASS_NAME, "unsupportedMediaType", {
+            contentType: mediaType
+        }));
+    }
+    /**
+     * Read the raw request body, enforcing the body limit while streaming.
+     * @param req The incoming request.
+     * @param headers The request headers.
+     * @param bodyLimit The maximum size of the request body in bytes.
+     * @returns The raw body, or undefined if it is empty.
+     * @throws GeneralError If the body is larger than the limit.
+     * @internal
+     */
+    async readBody(req, headers, bodyLimit) {
+        const contentLength = headers[HeaderTypes.ContentLength];
+        if (Is.string(contentLength) && Number.parseInt(contentLength, 10) > bodyLimit) {
+            throw this.createBodyTooLargeError(bodyLimit);
+        }
+        const chunks = [];
+        let total = 0;
+        for await (const chunk of req) {
+            const buffer = chunk;
+            total += buffer.byteLength;
+            if (total > bodyLimit) {
+                throw this.createBodyTooLargeError(bodyLimit);
+            }
+            chunks.push(buffer);
+        }
+        return total === 0 ? undefined : Buffer.concat(chunks, total);
+    }
+    /**
+     * Create the error for a body which exceeds the limit.
+     * @param bodyLimit The maximum size of the request body in bytes.
+     * @returns The error.
+     * @internal
+     */
+    createBodyTooLargeError(bodyLimit) {
+        return this.createTransportError(HttpStatusCode.payloadTooLarge, new GeneralError(NativeWebServer.CLASS_NAME, "bodyTooLarge", { bodyLimit }));
+    }
+    /**
+     * Mark an error as raised by the transport, so it is responded to with a specific status code.
+     * @param statusCode The status code for the response.
+     * @param error The error.
+     * @returns The error.
+     * @internal
+     */
+    createTransportError(statusCode, error) {
+        NativeWebServer._ERROR_STATUS_CODES.set(error, statusCode);
+        return error;
+    }
+    /**
+     * Send the processed response.
+     * @param req The incoming request.
+     * @param res The outgoing response.
+     * @param httpResponse The processed response.
+     * @internal
+     */
+    async sendResponse(req, res, httpResponse) {
+        this.validateResponse(httpResponse);
+        const headers = {};
+        if (!Is.empty(httpResponse.headers)) {
+            for (const header of Object.keys(httpResponse.headers)) {
+                const value = httpResponse.headers[header];
+                if (!Is.empty(value)) {
+                    headers[header.toLowerCase()] = value;
+                }
+            }
+        }
+        const status = httpResponse.statusCode ?? HttpStatusCode.ok;
+        const payload = httpResponse.body;
+        if (Is.empty(payload) ||
+            status === HttpStatusCode.noContent ||
+            status === HttpStatusCode.notModified) {
+            res.writeHead(status, headers);
+            res.end();
+            return;
+        }
+        const stream = this.toNodeStream(payload);
+        if (!Is.empty(stream)) {
+            headers[HeaderTypes.ContentType] ??= MimeTypes.OctetStream;
+            const encoding = this.selectEncoding(req, headers);
+            if (Is.stringValue(encoding)) {
+                delete headers[HeaderTypes.ContentLength];
+                headers["content-encoding"] = encoding;
+                this.appendVary(res, headers, "Accept-Encoding");
+                res.writeHead(status, headers);
+                await pipeline(stream, NativeWebServer._STREAM_COMPRESSORS[encoding](), res);
+            }
+            else {
+                res.writeHead(status, headers);
+                await pipeline(stream, res);
+            }
+            return;
+        }
+        let body;
+        if (Is.uint8Array(payload)) {
+            body = payload;
+            headers[HeaderTypes.ContentType] ??= MimeTypes.OctetStream;
+        }
+        else if (Is.string(payload)) {
+            body = Converter.utf8ToBytes(payload);
+            headers[HeaderTypes.ContentType] ??= `${MimeTypes.PlainText}; charset=utf-8`;
+        }
+        else {
+            body = Converter.utf8ToBytes(JSON.stringify(payload));
+            headers[HeaderTypes.ContentType] ??= `${MimeTypes.Json}; charset=utf-8`;
+        }
+        if (body.byteLength >= NativeWebServer._COMPRESS_THRESHOLD) {
+            const encoding = this.selectEncoding(req, headers);
+            if (Is.stringValue(encoding)) {
+                body = await NativeWebServer._COMPRESSORS[encoding](body);
+                headers["content-encoding"] = encoding;
+                this.appendVary(res, headers, "Accept-Encoding");
+            }
+        }
+        headers[HeaderTypes.ContentLength] = body.byteLength;
+        res.writeHead(status, headers);
+        res.end(body);
+    }
+    /**
+     * Convert a streaming response payload to a Node stream.
+     * @param payload The response payload.
+     * @returns The stream, or undefined if the payload is not a stream.
+     * @internal
+     */
+    toNodeStream(payload) {
+        if (Is.function(payload.pipe)) {
+            return payload;
+        }
+        if (Is.function(payload.getReader)) {
+            return Readable.fromWeb(payload);
+        }
+        return undefined;
+    }
+    /**
+     * Select the encoding for the response, if it should be compressed.
+     * @param req The incoming request.
+     * @param headers The response headers.
+     * @returns The encoding, or undefined if the response should not be compressed.
+     * @internal
+     */
+    selectEncoding(req, headers) {
+        const acceptEncoding = req.headers["accept-encoding"];
+        const contentType = headers[HeaderTypes.ContentType];
+        if (!Is.stringValue(acceptEncoding) ||
+            !Is.empty(headers["content-encoding"]) ||
+            !Is.string(contentType) ||
+            !NativeWebServer._COMPRESSIBLE_TYPES.test(contentType)) {
+            return undefined;
+        }
+        let selected;
+        let selectedQuality = 0;
+        for (const part of acceptEncoding.toLowerCase().split(",")) {
+            const [name, ...params] = part.trim().split(";");
+            const qualityParam = params.find(p => p.trim().startsWith("q="));
+            const quality = Is.stringValue(qualityParam)
+                ? Number.parseFloat(qualityParam.trim().slice(2))
+                : 1;
+            const encoding = name === "x-gzip" ? "gzip" : name;
+            const candidates = encoding === "*"
+                ? NativeWebServer._ENCODINGS
+                : NativeWebServer._ENCODINGS.filter(e => e === encoding);
+            for (const candidate of candidates) {
+                const isBetter = quality > selectedQuality ||
+                    (quality === selectedQuality &&
+                        Is.stringValue(selected) &&
+                        NativeWebServer._ENCODINGS.indexOf(candidate) <
+                            NativeWebServer._ENCODINGS.indexOf(selected));
+                if (quality > 0 && isBetter) {
+                    selected = candidate;
+                    selectedQuality = quality;
+                }
+            }
+        }
+        return selected;
+    }
+    /**
+     * Append a value to the vary header, keeping any value already set on the response.
+     * @param res The outgoing response.
+     * @param headers The response headers.
+     * @param value The value to append.
+     * @internal
+     */
+    appendVary(res, headers, value) {
+        const existing = headers.vary ?? res.getHeader("vary");
+        if (Is.empty(existing)) {
+            headers.vary = value;
+        }
+        else {
+            headers.vary = `${Is.array(existing) ? existing.join(", ") : String(existing)}, ${value}`;
+        }
+    }
+    /**
+     * Send an error response.
+     * @param res The outgoing response.
+     * @param error The error to send.
+     * @internal
+     */
+    async sendError(res, error) {
+        let httpStatusCode = NativeWebServer._ERROR_STATUS_CODES.get(error);
+        let err;
+        if (Is.empty(httpStatusCode)) {
+            const errorAndCode = HttpErrorHelper.processError(error);
+            err = errorAndCode.error;
+            httpStatusCode = errorAndCode.httpStatusCode;
+        }
+        else {
+            err = BaseError.fromError(error).toJsonObject();
+        }
+        await this._logging?.log({
+            level: "error",
+            ts: Date.now(),
+            source: NativeWebServer.CLASS_NAME,
+            message: "badRequest",
+            error: err
+        });
+        if (res.headersSent) {
+            // The response is already partly sent, so the only option left is to drop it
+            res.destroy();
+            return;
+        }
+        const body = Converter.utf8ToBytes(JSON.stringify({ error: err }));
+        const headers = {
+            [HeaderTypes.ContentType]: `${MimeTypes.Json}; charset=utf-8`,
+            [HeaderTypes.ContentLength]: body.byteLength
+        };
+        if (httpStatusCode === HttpStatusCode.payloadTooLarge) {
+            // The unread body would otherwise hold the connection open, so close it like Fastify
+            headers.connection = "close";
+        }
+        res.writeHead(httpStatusCode, headers);
+        res.end(body);
+    }
+    /**
+     * Listen on a host and port.
+     * @param server The server to listen with.
+     * @param host The host to bind to.
+     * @param port The port to bind to.
+     * @returns A promise that resolves when the server is listening.
+     * @internal
+     */
+    async listenOn(server, host, port) {
+        await new Promise((resolve, reject) => {
+            server.once("error", reject);
+            server.listen(port, host, () => {
+                server.off("error", reject);
+                resolve();
+            });
+        });
+    }
+    /**
+     * Close the socket server, which also closes the server it is attached to.
+     * @param socketServer The socket server to close.
+     * @param server The server the socket server is attached to.
+     * @returns A promise that resolves when both servers have closed.
+     * @internal
+     */
+    async closeSocketServer(socketServer, server) {
+        const serverClosed = Is.empty(server) ? undefined : once(server, "close");
+        socketServer.disconnectSockets();
+        await socketServer.close();
+        await serverClosed;
+    }
+    /**
+     * Close a server.
+     * @param server The server to close.
+     * @returns A promise that resolves when the server has closed.
+     * @internal
+     */
+    async closeServer(server) {
+        await new Promise((resolve, reject) => {
+            server.close(err => (Is.empty(err) ? resolve() : reject(err)));
+        });
+    }
+}
+//# sourceMappingURL=nativeWebServer.js.map