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

package/dist/es/honoWebServer.js

@@ -0,0 +1,759 @@
+// Copyright 2026 3Sixty Trade Ltd.
+// SPDX-License-Identifier: Apache-2.0.
+import { lookup } from "node:dns/promises";
+import { once } from "node:events";
+import { createSecureServer as createSecureHttp2Server } from "node:http2";
+import { createServer as createHttpsServer } from "node:https";
+import { createServer as createNetServer } from "node:net";
+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 { createAdaptorServer } from "@hono/node-server";
+import { Hono } from "hono";
+import { compress } from "hono/compress";
+import { HTTPException } from "hono/http-exception";
+import { Server } from "socket.io";
+/**
+ * Implementation of the web server using Hono.
+ */
+export class HonoWebServer extends BaseServer {
+    /**
+     * Runtime name for the class.
+     */
+    static CLASS_NAME = "HonoWebServer";
+    /**
+     * The maximum length of a path param, matching the Fastify server.
+     * @internal
+     */
+    static _MAX_PARAM_LENGTH = 2000;
+    /**
+     * The Hono application.
+     * @internal
+     */
+    _app;
+    /**
+     * 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 node server the application is served on, 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 HonoWebServer.
+     * @param options The options for the server.
+     */
+    constructor(options) {
+        super({
+            loggingComponentType: options?.loggingComponentType,
+            mimeTypeProcessors: options?.mimeTypeProcessors,
+            includeErrorStack: options?.config?.includeErrorStack
+        });
+        this._app = new Hono();
+        this._webConfig = options?.config?.web;
+        this._socketConfig = {
+            path: "/socket",
+            ...options?.config?.socket
+        };
+        this._mimeTypeProcessorMap = {};
+        this._additionalServers = [];
+    }
+    /**
+     * Compare two route paths, ordering a static segment before a param in the same position.
+     * @param a The first route path.
+     * @param b The second route path.
+     * @returns Negative if a should be registered first, positive if b should, otherwise zero.
+     * @internal
+     */
+    static compareRouteSpecificity(a, b) {
+        const aSegments = StringHelper.trimLeadingSlashes(a).split("/");
+        const bSegments = StringHelper.trimLeadingSlashes(b).split("/");
+        const length = Math.min(aSegments.length, bSegments.length);
+        for (let i = 0; i < length; i++) {
+            const aIsParam = aSegments[i].startsWith(":");
+            const bIsParam = bSegments[i].startsWith(":");
+            if (aIsParam !== bIsParam) {
+                return aIsParam ? 1 : -1;
+            }
+        }
+        return 0;
+    }
+    /**
+     * Returns the class name of the component.
+     * @returns The class name of the component.
+     */
+    className() {
+        return HonoWebServer.CLASS_NAME;
+    }
+    /**
+     * Get the web server instance.
+     * @returns The web server instance.
+     */
+    getInstance() {
+        return this._app;
+    }
+    /**
+     * 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);
+        // Only run the compression middleware when the client accepts an encoding, as it
+        // reads the request and response headers through the slower fetch API
+        const compressMiddleware = compress();
+        this._app.use(async (c, next) => {
+            if (Is.stringValue(this.getRequestHeaders(c)["accept-encoding"])) {
+                await compressMiddleware(c, next);
+            }
+            else {
+                await next();
+            }
+        });
+        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;
+            }
+        }
+        this.initCors(options);
+        const bodyLimits = this.resolveBodyLimits();
+        this._app.notFound(async (c) => this.handleRequestRest(c, bodyLimits[HttpBodyLimit.Default]));
+        this._app.onError(async (error, c) => {
+            // HTTP exceptions are raised by the transport, everything else is from our framework
+            let httpStatusCode;
+            let err;
+            const httpException = error;
+            if (Is.integer(httpException.status) && Is.function(httpException.getResponse)) {
+                err = BaseError.fromError(httpException.cause).toJsonObject();
+                httpStatusCode = httpException.status;
+            }
+            else {
+                const errorAndCode = HttpErrorHelper.processError(error);
+                err = errorAndCode.error;
+                httpStatusCode = errorAndCode.httpStatusCode;
+            }
+            await this._logging?.log({
+                level: "error",
+                ts: Date.now(),
+                source: HonoWebServer.CLASS_NAME,
+                message: "badRequest",
+                error: err
+            });
+            if (httpStatusCode === HttpStatusCode.payloadTooLarge) {
+                // The unread body would otherwise hold the connection open, so close it like Fastify
+                c.header("connection", "close");
+            }
+            return c.json({ error: err }, httpStatusCode);
+        });
+        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) {
+        // The config omits the options the server controls, which flattens the server type union
+        const server = createAdaptorServer({
+            ...this._webConfig,
+            fetch: this._app.fetch
+        });
+        this._socketServer?.attach(server);
+        // 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) {
+                // Like Fastify, an additional address failing to bind does not stop the server
+                await this._logging?.log({
+                    level: "warn",
+                    ts: Date.now(),
+                    source: HonoWebServer.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() {
+        if (!Is.empty(this._server)) {
+            return Is.function(this._server.setSecureContext);
+        }
+        // Before listening the server factory determines whether it will be secure
+        const createServer = this._webConfig?.createServer;
+        return createServer === createHttpsServer || createServer === createSecureHttp2Server;
+    }
+    /**
+     * 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._app.routes.some(route => route.method === HttpMethod.GET && route.path === "/");
+    }
+    /**
+     * 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)) {
+            // Hono matches overlapping routes in registration order, so register the routes with a
+            // static segment before those with a param in the same position, as find-my-way does
+            const sortedRoutes = [...restRoutes].sort((a, b) => HonoWebServer.compareRouteSpecificity(a.path, b.path));
+            for (const restRoute of sortedRoutes) {
+                let path = StringHelper.trimTrailingSlashes(restRoute.path);
+                if (!path.startsWith("/")) {
+                    path = `/${path}`;
+                }
+                await this._logging?.log({
+                    level: "info",
+                    ts: Date.now(),
+                    source: HonoWebServer.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(HonoWebServer.CLASS_NAME, "unknownBodyLimit", {
+                        route: path,
+                        bodyLimit: bodyLimitKey
+                    });
+                }
+                // Like find-my-way, a param can match an empty segment
+                const honoPath = path.replace(/:(\w+)/g, ":$1{[^/]*}");
+                this._app.on(restRoute.method, honoPath, async (c) => this.handleRequestRest(c, bodyLimit, 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: HonoWebServer.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 the incoming REST request.
+     * @param c The Hono context for the request.
+     * @param bodyLimit The maximum size of the request body in bytes.
+     * @param restRoute The REST route to handle.
+     * @returns The response.
+     * @internal
+     */
+    async handleRequestRest(c, bodyLimit, restRoute) {
+        const url = c.req.url;
+        const pathStart = url.indexOf("/", url.indexOf("//") + 2);
+        const requestOrigin = pathStart === -1 ? url : url.slice(0, pathStart);
+        const headers = this.getRequestHeaders(c);
+        // Like Fastify, a path which is not valid percent encoding is rejected, the raw path is
+        // checked as Hono may already have partially decoded its own copy
+        const queryStart = url.indexOf("?", pathStart);
+        const path = pathStart === -1 ? "/" : url.slice(pathStart, queryStart === -1 ? undefined : queryStart);
+        if (path.includes("%")) {
+            try {
+                decodeURIComponent(path);
+            }
+            catch (err) {
+                throw new HTTPException(HttpStatusCode.badRequest, {
+                    cause: new GeneralError(HonoWebServer.CLASS_NAME, "invalidUrl", { path }, err)
+                });
+            }
+        }
+        const pathParams = c.req.param();
+        for (const param of Object.keys(pathParams)) {
+            if (pathParams[param].length > HonoWebServer._MAX_PARAM_LENGTH) {
+                throw new HTTPException(HttpStatusCode.uriTooLong, {
+                    cause: new GeneralError(HonoWebServer.CLASS_NAME, "paramTooLong", {
+                        param,
+                        maxParamLength: HonoWebServer._MAX_PARAM_LENGTH
+                    })
+                });
+            }
+        }
+        const httpServerRequest = this.buildServerRequest(c.req.method.toUpperCase(), url, await this.parseBody(c, headers, bodyLimit), this.getRequestQuery(c), pathParams, headers);
+        const httpResponse = {};
+        const contextIds = this.buildContextIds(requestOrigin, httpServerRequest.headers);
+        const processorState = {};
+        await this.runProcessorsRest(restRoute, httpServerRequest, httpResponse, contextIds, processorState);
+        this.validateResponse(httpResponse);
+        return this.buildResponse(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);
+        });
+    }
+    /**
+     * Get the request query, like Fastify a repeated key gives an array of its values.
+     * @param c The Hono context for the request.
+     * @returns The request query.
+     * @internal
+     */
+    getRequestQuery(c) {
+        const query = {};
+        const queries = c.req.queries();
+        for (const key of Object.keys(queries)) {
+            const values = queries[key];
+            query[key] = values.length === 1 ? values[0] : values;
+        }
+        return query;
+    }
+    /**
+     * Get the request headers, using the headers already parsed by Node when available,
+     * as building them from the fetch request is comparatively expensive.
+     * @param c The Hono context for the request.
+     * @returns The request headers with lower case names.
+     * @internal
+     */
+    getRequestHeaders(c) {
+        const incoming = c.env?.incoming;
+        return (incoming?.headers ?? c.req.header());
+    }
+    /**
+     * Read and parse the request body based on its content type.
+     * @param c The Hono context for the 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 HTTPException If the body is too large, malformed or an unsupported media type.
+     * @internal
+     */
+    async parseBody(c, headers, bodyLimit) {
+        const method = c.req.method;
+        if (method === HttpMethod.GET || 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(c, headers, bodyLimit);
+        if (Is.empty(raw)) {
+            // Like Fastify, declaring a JSON body without sending one is an error
+            if (mediaType === MimeTypes.Json) {
+                throw new HTTPException(HttpStatusCode.badRequest, {
+                    cause: new GeneralError(HonoWebServer.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 new HTTPException(HttpStatusCode.badRequest, {
+                    cause: new GeneralError(HonoWebServer.CLASS_NAME, "invalidJsonBody", undefined, err)
+                });
+            }
+        }
+        if (mediaType === MimeTypes.PlainText) {
+            return Converter.bytesToUtf8(raw);
+        }
+        throw new HTTPException(HttpStatusCode.unsupportedMediaType, {
+            cause: new GeneralError(HonoWebServer.CLASS_NAME, "unsupportedMediaType", {
+                contentType: mediaType
+            })
+        });
+    }
+    /**
+     * Read the raw request body, enforcing the body limit while streaming.
+     * @param c The Hono context for the 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 HTTPException If the body is larger than the limit.
+     * @internal
+     */
+    async readBody(c, headers, bodyLimit) {
+        const contentLength = headers[HeaderTypes.ContentLength];
+        if (Is.string(contentLength) && Number.parseInt(contentLength, 10) > bodyLimit) {
+            throw this.createBodyTooLargeError(bodyLimit);
+        }
+        // Reading the Node stream directly avoids wrapping it in a web stream
+        const source = c.env?.incoming ?? c.req.raw.body;
+        if (Is.empty(source)) {
+            return undefined;
+        }
+        const chunks = [];
+        let total = 0;
+        for await (const chunk of source) {
+            total += chunk.byteLength;
+            if (total > bodyLimit) {
+                throw this.createBodyTooLargeError(bodyLimit);
+            }
+            chunks.push(chunk);
+        }
+        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 new HTTPException(HttpStatusCode.payloadTooLarge, {
+            cause: new GeneralError(HonoWebServer.CLASS_NAME, "bodyTooLarge", { bodyLimit })
+        });
+    }
+    /**
+     * Build the transport response from the processed response.
+     * @param httpResponse The processed response.
+     * @returns The response.
+     * @internal
+     */
+    buildResponse(httpResponse) {
+        // A plain header record keeps the response on the node adapter's fast path,
+        // multiple values for a header can only be represented with a Headers instance
+        const headers = {};
+        let multiValueHeaders;
+        if (!Is.empty(httpResponse.headers)) {
+            for (const header of Object.keys(httpResponse.headers)) {
+                const value = httpResponse.headers[header];
+                if (Is.array(value)) {
+                    multiValueHeaders ??= new Headers();
+                    for (const item of value) {
+                        multiValueHeaders.append(header, item);
+                    }
+                }
+                else if (!Is.empty(value)) {
+                    headers[header.toLowerCase()] = String(value);
+                }
+            }
+        }
+        const status = httpResponse.statusCode ?? HttpStatusCode.ok;
+        const payload = httpResponse.body;
+        if (Is.empty(payload) ||
+            status === HttpStatusCode.noContent ||
+            status === HttpStatusCode.notModified) {
+            return new Response(null, {
+                status,
+                headers: this.mergeHeaders(headers, multiValueHeaders)
+            });
+        }
+        if (Is.function(payload.getReader)) {
+            headers[HeaderTypes.ContentType] ??= MimeTypes.OctetStream;
+            return new Response(payload, {
+                status,
+                headers: this.mergeHeaders(headers, multiValueHeaders)
+            });
+        }
+        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`;
+        }
+        // A known length lets compression skip small bodies and avoids a chunked response
+        headers[HeaderTypes.ContentLength] = body.byteLength.toString();
+        return new Response(body, {
+            status,
+            headers: this.mergeHeaders(headers, multiValueHeaders)
+        });
+    }
+    /**
+     * Merge the single value headers in to the multiple value headers, if there are any.
+     * @param headers The single value headers.
+     * @param multiValueHeaders The multiple value headers.
+     * @returns The headers to use for the response.
+     * @internal
+     */
+    mergeHeaders(headers, multiValueHeaders) {
+        if (Is.empty(multiValueHeaders)) {
+            return headers;
+        }
+        for (const header of Object.keys(headers)) {
+            multiValueHeaders.set(header, headers[header]);
+        }
+        return multiValueHeaders;
+    }
+    /**
+     * Initialize the cors options.
+     * @param options The web server options.
+     * @internal
+     */
+    initCors(options) {
+        const corsOptions = this.resolveCorsOptions(options);
+        const allowMethods = corsOptions.methods.join(", ");
+        const allowHeaders = corsOptions.allowedHeaders.join(", ");
+        const exposeHeaders = corsOptions.exposedHeaders.join(", ");
+        // Mirrors the Fastify CORS plugin, the headers are added after the handler has run
+        // because creating the response headers beforehand forces Hono to rebuild the response
+        this._app.use(async (c, next) => {
+            const headers = this.getRequestHeaders(c);
+            const origin = headers.origin;
+            const requestOrigin = Is.string(origin) ? origin : undefined;
+            const allowed = corsOptions.hasWildcardOrigin ||
+                (Is.stringValue(requestOrigin) && corsOptions.origins.includes(requestOrigin));
+            if (allowed && c.req.method === HttpMethod.OPTIONS) {
+                if (!Is.stringValue(requestOrigin) ||
+                    !Is.stringValue(headers["access-control-request-method"])) {
+                    return c.text("Invalid Preflight Request", HttpStatusCode.badRequest, {
+                        vary: "Origin"
+                    });
+                }
+                return new Response(null, {
+                    status: HttpStatusCode.noContent,
+                    headers: {
+                        vary: "Origin",
+                        "access-control-allow-origin": requestOrigin,
+                        "access-control-allow-credentials": "true",
+                        "access-control-expose-headers": exposeHeaders,
+                        "access-control-allow-methods": allowMethods,
+                        "access-control-allow-headers": allowHeaders,
+                        "content-length": "0"
+                    }
+                });
+            }
+            await next();
+            const responseHeaders = c.res.headers;
+            responseHeaders.append("vary", "Origin");
+            if (allowed) {
+                if (Is.stringValue(requestOrigin)) {
+                    responseHeaders.set("access-control-allow-origin", requestOrigin);
+                }
+                responseHeaders.set("access-control-allow-credentials", "true");
+                responseHeaders.set("access-control-expose-headers", exposeHeaders);
+            }
+        });
+    }
+    /**
+     * 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=honoWebServer.js.map