@3sixty/api-server-fastify 0.0.0-stage → 0.20.0-next.0

package/dist/es/fastifyWebServer.js

@@ -0,0 +1,877 @@
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+import { HealthStatus, HttpBodyLimit, HttpContextIdKeys, HttpErrorHelper, HealthCategory } from "@3sixty/api-models";
+import { JsonLdMimeTypeProcessor } from "@3sixty/api-processors";
+import { ContextIdStore } from "@3sixty/context";
+import { BaseError, ComponentFactory, GeneralError, Is, RandomHelper, StringHelper, Url } from "@3sixty/core";
+import { HeaderTypes, HttpMethod, HttpStatusCode, HeaderHelper, MimeTypes } from "@3sixty/web";
+import FastifyCompress from "@fastify/compress";
+import FastifyCors from "@fastify/cors";
+import Fastify from "fastify";
+import FastifySocketIO from "./fastifySocketIo.js";
+/**
+ * Implementation of the web server using Fastify.
+ */
+export class FastifyWebServer {
+    /**
+     * Runtime name for the class.
+     */
+    static CLASS_NAME = "FastifyWebServer";
+    /**
+     * Default port for running the server.
+     * @internal
+     */
+    static _DEFAULT_PORT = 3000;
+    /**
+     * Default host for running the server.
+     * @internal
+     */
+    static _DEFAULT_HOST = "localhost";
+    /**
+     * Default named body size limits for routes.
+     * @internal
+     */
+    static _DEFAULT_BODY_LIMITS = {
+        [HttpBodyLimit.Default]: 1048576,
+        [HttpBodyLimit.Large]: 26214400
+    };
+    /**
+     * The logging component type.
+     * @internal
+     */
+    _loggingComponentType;
+    /**
+     * The logging component.
+     * @internal
+     */
+    _logging;
+    /**
+     * The options for the server.
+     * @internal
+     */
+    _options;
+    /**
+     * The Fastify instance.
+     * @internal
+     */
+    _fastify;
+    /**
+     * The options for the socket server.
+     * @internal
+     */
+    _socketConfig;
+    /**
+     * Whether the server has been started.
+     * @internal
+     */
+    _started;
+    /**
+     * The mime type processors.
+     * @internal
+     */
+    _mimeTypeProcessors;
+    /**
+     * Include the stack with errors.
+     * @internal
+     */
+    _includeErrorStack;
+    /**
+     * The public origin of the server, used for constructing the request URL and for CORS.
+     * @internal
+     */
+    _publicOrigin;
+    /**
+     * The local origin of the server, used for constructing the request URL and for CORS.
+     * @internal
+     */
+    _localOrigin;
+    /**
+     * The REST processor chains resolved when the server is built.
+     * @internal
+     */
+    _restChains;
+    /**
+     * The socket processor chains resolved when the server is built.
+     * @internal
+     */
+    _socketChains;
+    /**
+     * Create a new instance of FastifyWebServer.
+     * @param options The options for the server.
+     */
+    constructor(options) {
+        this._loggingComponentType = options?.loggingComponentType;
+        this._logging = ComponentFactory.getIfExists(options?.loggingComponentType);
+        this._fastify = Fastify({
+            routerOptions: {
+                maxParamLength: 2000
+            },
+            ...options?.config?.web
+            // Need this cast for now as maxParamLength has moved in to routerOptions
+            // but the TS defs has not been updated yet
+        });
+        this._socketConfig = {
+            path: "/socket",
+            ...options?.config?.socket
+        };
+        this._started = false;
+        this._restChains = { pre: [], process: [], post: [] };
+        this._socketChains = { connected: [], disconnected: [], pre: [], process: [], post: [] };
+        this._mimeTypeProcessors = options?.mimeTypeProcessors ?? [];
+        const hasJsonLd = this._mimeTypeProcessors.some(processor => processor.getTypes().includes(MimeTypes.JsonLd));
+        if (!hasJsonLd) {
+            this._mimeTypeProcessors.push(new JsonLdMimeTypeProcessor());
+        }
+        this._includeErrorStack = options?.config?.includeErrorStack ?? false;
+    }
+    /**
+     * Returns the class name of the component.
+     * @returns The class name of the component.
+     */
+    className() {
+        return FastifyWebServer.CLASS_NAME;
+    }
+    /**
+     * Get the web server instance.
+     * @returns The web server instance.
+     */
+    getInstance() {
+        return this._fastify;
+    }
+    /**
+     * 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) {
+        if (Is.arrayValue(restRoutes) && !Is.arrayValue(restRouteProcessors)) {
+            throw new GeneralError(FastifyWebServer.CLASS_NAME, "noRestProcessors");
+        }
+        if (Is.arrayValue(socketRoutes) && !Is.arrayValue(socketRouteProcessors)) {
+            throw new GeneralError(FastifyWebServer.CLASS_NAME, "noSocketProcessors");
+        }
+        await this._logging?.log({
+            level: "info",
+            ts: Date.now(),
+            source: FastifyWebServer.CLASS_NAME,
+            message: "building"
+        });
+        let localHost = options?.host ?? "127.0.0.1";
+        if (localHost === "0.0.0.0") {
+            localHost = "127.0.0.1";
+        }
+        this._localOrigin = `http://${localHost}:${options?.port ?? 3000}`;
+        if (Is.stringValue(options?.publicOrigin)) {
+            const publicUrl = Url.tryParseExact(options.publicOrigin);
+            if (!Is.empty(publicUrl)) {
+                const urlParts = publicUrl.parts();
+                this._publicOrigin = `${urlParts.schema}://${urlParts.host}${Is.integer(urlParts.port) ? `:${urlParts.port}` : ""}`;
+            }
+            else {
+                throw new GeneralError(FastifyWebServer.CLASS_NAME, "invalidPublicOrigin", {
+                    publicOrigin: options.publicOrigin
+                });
+            }
+        }
+        this._options = options;
+        await this._fastify.register(FastifyCompress);
+        if (Is.arrayValue(socketRoutes)) {
+            await this._fastify.register(FastifySocketIO, this._socketConfig);
+        }
+        if (Is.arrayValue(this._mimeTypeProcessors)) {
+            for (const contentTypeHandler of this._mimeTypeProcessors) {
+                this._fastify.addContentTypeParser(contentTypeHandler.getTypes(), { parseAs: "buffer" }, (request, body, done) => {
+                    // Fastify does not handle this method correctly if it is async
+                    // so we have to use the callback method
+                    contentTypeHandler
+                        .handle(body)
+                        // eslint-disable-next-line promise/prefer-await-to-then, promise/no-callback-in-promise
+                        .then(processed => done(null, processed))
+                        // eslint-disable-next-line promise/prefer-await-to-then, promise/no-callback-in-promise
+                        .catch(err => done(BaseError.fromError(err)));
+                });
+            }
+        }
+        await this.initCors(options);
+        this._fastify.setNotFoundHandler({}, async (request, reply) => this.handleRequestRest(restRouteProcessors ?? [], request, reply));
+        this._fastify.setErrorHandler(async (error, request, reply) => {
+            // If code property is set this is a fastify error
+            // otherwise it's from our framework
+            let httpStatusCode;
+            let err;
+            if (Is.number(error.code) || Is.string(error.code)) {
+                err = {
+                    source: FastifyWebServer.CLASS_NAME,
+                    name: error.name,
+                    message: `${error.code}: ${error.message}`
+                };
+                httpStatusCode = error.statusCode ?? HttpStatusCode.badRequest;
+            }
+            else {
+                const errorAndCode = HttpErrorHelper.processError(error);
+                err = errorAndCode.error;
+                httpStatusCode = errorAndCode.httpStatusCode;
+            }
+            await this._logging?.log({
+                level: "error",
+                ts: Date.now(),
+                source: FastifyWebServer.CLASS_NAME,
+                message: "badRequest",
+                error: err
+            });
+            return reply.status(httpStatusCode).send({
+                error: err
+            });
+        });
+        await this.addRoutesRest(restRouteProcessors, restRoutes);
+        await this.addRoutesSocket(socketRouteProcessors, socketRoutes);
+        this.buildProcessorChains(restRouteProcessors, socketRouteProcessors);
+    }
+    /**
+     * Start the server.
+     * @returns A promise that resolves when the server is listening for connections.
+     */
+    async start() {
+        const host = this._options?.host ?? FastifyWebServer._DEFAULT_HOST;
+        const port = this._options?.port ?? FastifyWebServer._DEFAULT_PORT;
+        await this._logging?.log({
+            level: "info",
+            ts: Date.now(),
+            source: FastifyWebServer.CLASS_NAME,
+            message: "starting",
+            data: {
+                host,
+                port
+            }
+        });
+        if (!this._started) {
+            try {
+                await this._fastify.listen({ port, host });
+                const addresses = this._fastify.addresses();
+                const protocol = Is.object(this._fastify.initialConfig.https) ? "https://" : "http://";
+                const normalizeAnyHost = (address) => {
+                    if (address === "0.0.0.0") {
+                        return "127.0.0.1";
+                    }
+                    if (address === "::") {
+                        return "::1";
+                    }
+                    return address;
+                };
+                const formatAddress = (address, family, forceProtocol) => {
+                    const displayAddress = normalizeAnyHost(address);
+                    const isIPv6 = family === "IPv6" || (Is.stringValue(displayAddress) && displayAddress.includes(":"));
+                    return `${forceProtocol ?? protocol}${isIPv6 ? "[" : ""}${displayAddress}${isIPv6 ? "]" : ""}`;
+                };
+                const startupAddresses = addresses.map(a => {
+                    const formatted = formatAddress(a.address, a.family, protocol);
+                    return `${formatted}:${a.port}`;
+                });
+                for (const origin of [this._localOrigin, this._publicOrigin]) {
+                    if (Is.stringValue(origin)) {
+                        const originUrl = Url.tryParseExact(origin);
+                        if (!Is.empty(originUrl)) {
+                            const originParts = originUrl.parts();
+                            const formatted = formatAddress(originParts.host, undefined, `${originParts.schema}://`);
+                            startupAddresses.push(`${formatted}${Is.integer(originParts.port) ? `:${originParts.port}` : ""}`);
+                        }
+                        else {
+                            startupAddresses.push(origin);
+                        }
+                    }
+                }
+                const distinctStartupAddresses = [...new Set(startupAddresses)];
+                await this._logging?.log({
+                    level: "info",
+                    ts: Date.now(),
+                    source: FastifyWebServer.CLASS_NAME,
+                    message: "started",
+                    data: {
+                        addresses: distinctStartupAddresses.join(", ")
+                    }
+                });
+                this._started = true;
+            }
+            catch (err) {
+                await this._logging?.log({
+                    level: "error",
+                    ts: Date.now(),
+                    source: FastifyWebServer.CLASS_NAME,
+                    message: "startFailed",
+                    error: BaseError.fromError(err)
+                });
+            }
+        }
+    }
+    /**
+     * Stop the server.
+     * @returns A promise that resolves when the server has shut down all connections.
+     */
+    async stop() {
+        if (this._started) {
+            this._started = false;
+            await this._fastify.close();
+            await this._logging?.log({
+                level: "info",
+                ts: Date.now(),
+                source: FastifyWebServer.CLASS_NAME,
+                message: "stopped"
+            });
+        }
+    }
+    /**
+     * Returns the health status of the component.
+     * @returns The health status of the component, can return multiple entries for elements within the component.
+     */
+    async health() {
+        let healthCheck;
+        if (this._fastify?.server?.listening) {
+            healthCheck = {
+                source: FastifyWebServer.CLASS_NAME,
+                status: HealthStatus.Ok,
+                category: HealthCategory.Connectivity,
+                description: "healthConnectivityDescription",
+                message: "reachable"
+            };
+        }
+        else {
+            healthCheck = {
+                source: FastifyWebServer.CLASS_NAME,
+                status: HealthStatus.Error,
+                category: HealthCategory.Connectivity,
+                description: "healthConnectivityDescription",
+                message: "unreachable"
+            };
+        }
+        return [healthCheck];
+    }
+    /**
+     * Verify the root endpoint is reachable and returns a body by making a real HTTP request.
+     * Skipped when GET / is not registered on this server instance.
+     * @param callback The callback to invoke when a deferred health result is ready.
+     * @returns The application health status of the component.
+     */
+    async healthApplication(callback) {
+        if (!this._fastify.hasRoute({ method: "GET", url: "/" })) {
+            return [];
+        }
+        if (!Is.stringValue(this._localOrigin)) {
+            return [
+                {
+                    source: FastifyWebServer.CLASS_NAME,
+                    status: HealthStatus.Error,
+                    category: HealthCategory.Application,
+                    description: "healthApplicationDescription",
+                    message: "serverNotBuilt"
+                }
+            ];
+        }
+        try {
+            const response = await fetch(`${this._localOrigin}/`);
+            const body = await response.text();
+            if (response.ok && Is.stringValue(body)) {
+                return [
+                    {
+                        source: FastifyWebServer.CLASS_NAME,
+                        status: HealthStatus.Ok,
+                        category: HealthCategory.Application,
+                        description: "healthApplicationDescription",
+                        message: "rootEndpointReachable"
+                    }
+                ];
+            }
+            return [
+                {
+                    source: FastifyWebServer.CLASS_NAME,
+                    status: HealthStatus.Error,
+                    category: HealthCategory.Application,
+                    description: "healthApplicationDescription",
+                    message: "rootEndpointError"
+                }
+            ];
+        }
+        catch (error) {
+            return [
+                {
+                    source: FastifyWebServer.CLASS_NAME,
+                    status: HealthStatus.Error,
+                    category: HealthCategory.Application,
+                    description: "healthApplicationDescription",
+                    error: BaseError.fromError(error)
+                }
+            ];
+        }
+    }
+    /**
+     * Add the REST routes to the server.
+     * @param restRouteProcessors The processors for the incoming requests.
+     * @param restRoutes The REST routes to add.
+     * @internal
+     */
+    async addRoutesRest(restRouteProcessors, restRoutes) {
+        if (Is.arrayValue(restRouteProcessors) && Is.arrayValue(restRoutes)) {
+            const bodyLimits = this.resolveBodyLimits();
+            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: FastifyWebServer.CLASS_NAME,
+                    message: "restRouteAdded",
+                    data: { route: path, method: restRoute.method }
+                });
+                const method = restRoute.method.toLowerCase();
+                const bodyLimitKey = Is.stringValue(restRoute.bodyLimit)
+                    ? restRoute.bodyLimit
+                    : HttpBodyLimit.Default;
+                const bodyLimit = bodyLimits[bodyLimitKey];
+                if (Is.empty(bodyLimit)) {
+                    throw new GeneralError(FastifyWebServer.CLASS_NAME, "unknownBodyLimit", {
+                        route: path,
+                        bodyLimit: bodyLimitKey
+                    });
+                }
+                this._fastify[method](path, { bodyLimit }, async (request, reply) => this.handleRequestRest(restRouteProcessors, request, reply, restRoute));
+            }
+        }
+    }
+    /**
+     * Merge the configured body limits over the built-in ones and validate them.
+     * @returns The named body limits in bytes.
+     * @throws GeneralError If a limit is not a positive integer.
+     * @internal
+     */
+    resolveBodyLimits() {
+        const bodyLimits = {
+            ...FastifyWebServer._DEFAULT_BODY_LIMITS,
+            ...this._options?.bodyLimits
+        };
+        for (const name of Object.keys(bodyLimits)) {
+            const bodyLimit = bodyLimits[name];
+            if (!Is.integer(bodyLimit) || bodyLimit <= 0) {
+                throw new GeneralError(FastifyWebServer.CLASS_NAME, "invalidBodyLimit", {
+                    bodyLimit: name,
+                    value: bodyLimit
+                });
+            }
+        }
+        return bodyLimits;
+    }
+    /**
+     * 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) {
+        if (Is.arrayValue(socketRouteProcessors) && Is.arrayValue(socketRoutes)) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const io = this._fastify.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: FastifyWebServer.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 socketRouteProcessor of socketRouteProcessors) {
+                            if (socketRouteProcessor.connected) {
+                                await socketRouteProcessor.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 socketRouteProcessor of socketRouteProcessors) {
+                                if (socketRouteProcessor.disconnected) {
+                                    await socketRouteProcessor.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(socketRouteProcessors, 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 restRouteProcessors The hooks to process the incoming requests.
+     * @param request The incoming request.
+     * @param reply The outgoing response.
+     * @param restRoute The REST route to handle.
+     * @returns The Fastify reply with the response.
+     * @internal
+     */
+    async handleRequestRest(restRouteProcessors, request, reply, restRoute) {
+        const port = (request.port === 80 && request.protocol === "http") ||
+            (request.port === 443 && request.protocol === "https") ||
+            !Is.integer(request.port)
+            ? ""
+            : `:${request.port}`;
+        const requestOrigin = `${request.protocol}://${request.hostname}${port}`;
+        const httpServerRequest = {
+            method: request.method.toUpperCase(),
+            url: `${requestOrigin}${request.url}`,
+            body: request.body,
+            query: request.query,
+            pathParams: request.params,
+            headers: request.headers
+        };
+        const httpResponse = {};
+        const contextIds = {
+            [HttpContextIdKeys.IpAddress]: HeaderHelper.extractClientIps(httpServerRequest.headers).join("|"),
+            [HttpContextIdKeys.UserAgent]: HeaderHelper.extractUserAgent(httpServerRequest.headers),
+            [HttpContextIdKeys.CorrelationId]: HeaderHelper.extractCorrelationId(httpServerRequest.headers),
+            [HttpContextIdKeys.RemoteRequest]: RandomHelper.generateUuidV7("compact"),
+            [HttpContextIdKeys.LocalOrigin]: this._localOrigin,
+            // This can be overridden by a processor if needed, for example a tenant processor
+            [HttpContextIdKeys.PublicOrigin]: this._publicOrigin ?? requestOrigin ?? this._localOrigin
+        };
+        const processorState = {};
+        if (Is.object(httpServerRequest.pathParams)) {
+            for (const key of Object.keys(httpServerRequest.pathParams)) {
+                httpServerRequest.pathParams[key] = decodeURIComponent(httpServerRequest.pathParams[key]);
+            }
+        }
+        if (Is.object(httpServerRequest.query)) {
+            for (const key of Object.keys(httpServerRequest.query)) {
+                httpServerRequest.query[key] = decodeURIComponent(httpServerRequest.query[key]);
+            }
+        }
+        await this.runProcessorsRest(restRouteProcessors, restRoute, httpServerRequest, httpResponse, contextIds, processorState);
+        if (!Is.empty(httpResponse.headers)) {
+            for (const header of Object.keys(httpResponse.headers)) {
+                reply.header(header, httpResponse.headers[header]);
+            }
+        }
+        return reply.status(httpResponse.statusCode ?? HttpStatusCode.ok).send(httpResponse.body);
+    }
+    /**
+     * Run the REST processors for the route.
+     * @param restRouteProcessors The processors to run.
+     * @param restRoute The route to process.
+     * @param httpServerRequest The incoming request.
+     * @param httpResponse The outgoing response.
+     * @param contextIds The context IDs of the request.
+     * @internal
+     */
+    async runProcessorsRest(restRouteProcessors, restRoute, httpServerRequest, httpResponse, contextIds, processorState) {
+        let hasPreError = false;
+        try {
+            // Run inside ContextIdStore.run so pre-processors can do tenant-scoped storage lookups.
+            await ContextIdStore.run(contextIds, async () => {
+                for (const pre of this._restChains.pre) {
+                    await pre(httpServerRequest, httpResponse, restRoute, contextIds, processorState, {
+                        loggingComponentType: this._loggingComponentType
+                    });
+                }
+            });
+        }
+        catch (err) {
+            const { error, httpStatusCode } = HttpErrorHelper.processError(err, this._includeErrorStack);
+            HttpErrorHelper.buildResponse(httpResponse, error, httpStatusCode, this._includeErrorStack);
+            hasPreError = true;
+        }
+        // A pre-processor may set an error response without throwing; treat that as halt.
+        if (!hasPreError &&
+            Is.integer(httpResponse.statusCode) &&
+            httpResponse.statusCode >= HttpStatusCode.badRequest) {
+            hasPreError = true;
+        }
+        // Don't run the main processing if there was an error in the pre processing
+        // As this is likely to perform tasks such as authentication which may have failed
+        if (!hasPreError) {
+            try {
+                // Run the processors within an async context
+                // so that any services can access the context ids
+                await ContextIdStore.run(contextIds, async () => {
+                    for (const process of this._restChains.process) {
+                        await process(httpServerRequest, httpResponse, restRoute, processorState, {
+                            loggingComponentType: this._loggingComponentType
+                        });
+                    }
+                });
+            }
+            catch (err) {
+                const { error, httpStatusCode } = HttpErrorHelper.processError(err, this._includeErrorStack);
+                HttpErrorHelper.buildResponse(httpResponse, error, httpStatusCode, this._includeErrorStack);
+            }
+        }
+        try {
+            // Always run the post processors, even if there was an error earlier
+            // as they may perform cleanup tasks, or logging etc
+            await ContextIdStore.run(contextIds, async () => {
+                for (const post of this._restChains.post) {
+                    await post(httpServerRequest, httpResponse, restRoute, contextIds, processorState, {
+                        loggingComponentType: this._loggingComponentType
+                    });
+                }
+            });
+        }
+        catch (err) {
+            // Just log post processor errors
+            await this._logging?.log({
+                level: "error",
+                ts: Date.now(),
+                source: FastifyWebServer.CLASS_NAME,
+                message: "postProcessorError",
+                error: BaseError.fromError(err),
+                data: {
+                    route: restRoute?.path ?? ""
+                }
+            });
+        }
+    }
+    /**
+     * Handle the incoming socket request.
+     * @param socketRouteProcessors The hooks to process the incoming requests.
+     * @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(socketRouteProcessors, 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(socketRouteProcessors, socketRoute, socketServerRequest, httpResponse, contextIds, processorState, emitTopic, async (topic, response) => {
+            socket.emit(topic, response);
+        });
+    }
+    /**
+     * Run the socket processors for the route.
+     * @param socketRouteProcessors The processors to run.
+     * @param socketRoute The route to process.
+     * @param socketServerRequest The incoming request.
+     * @param httpResponse The outgoing response.
+     * @param contextIds The context IDs of the request.
+     * @param processorState The state handed through the processors.
+     * @param requestTopic The topic of the request.
+     * @param responseEmitter The emitter to send the response on.
+     * @internal
+     */
+    async runProcessorsSocket(socketRouteProcessors, socketRoute, socketServerRequest, httpResponse, contextIds, processorState, requestTopic, responseEmitter) {
+        // Custom emit method which will also call the post processors
+        const postProcessEmit = async (topic, response, responseProcessorState) => {
+            await responseEmitter(topic, response);
+            try {
+                // The post processors are called after the response has been emitted
+                for (const post of this._socketChains.post) {
+                    await post(socketServerRequest, response, socketRoute, contextIds, responseProcessorState, {
+                        loggingComponentType: this._loggingComponentType
+                    });
+                }
+            }
+            catch (err) {
+                await this._logging?.log({
+                    level: "error",
+                    ts: Date.now(),
+                    source: FastifyWebServer.CLASS_NAME,
+                    message: "postProcessorError",
+                    error: BaseError.fromError(err),
+                    data: {
+                        route: socketRoute.path
+                    }
+                });
+            }
+        };
+        try {
+            for (const pre of this._socketChains.pre) {
+                await pre(socketServerRequest, httpResponse, socketRoute, contextIds, processorState, {
+                    loggingComponentType: this._loggingComponentType
+                });
+            }
+            // We always call all the processors regardless of any response set by a previous processor.
+            // But if a pre processor sets a status code, we will emit the response manually, as the pre
+            // and post processors do not receive the emit method, they just populate the response object.
+            if (!Is.empty(httpResponse.statusCode)) {
+                await postProcessEmit(requestTopic, httpResponse, processorState);
+            }
+            await ContextIdStore.run(contextIds, async () => {
+                for (const process of this._socketChains.process) {
+                    await process(socketServerRequest, httpResponse, socketRoute, processorState, async (topic, processResponse) => {
+                        await postProcessEmit(topic, processResponse, processorState);
+                    }, this._loggingComponentType);
+                }
+            });
+            // If the processors set the status to any kind of error then we should emit this manually
+            if (Is.integer(httpResponse.statusCode) &&
+                httpResponse.statusCode >= HttpStatusCode.badRequest) {
+                await postProcessEmit(requestTopic, httpResponse, processorState);
+            }
+        }
+        catch (err) {
+            // Emit any unhandled errors manually
+            const { error, httpStatusCode } = HttpErrorHelper.processError(err, this._includeErrorStack);
+            HttpErrorHelper.buildResponse(httpResponse, error, httpStatusCode, this._includeErrorStack);
+            await postProcessEmit(requestTopic, httpResponse, processorState);
+        }
+    }
+    /**
+     * Initialize the cors options.
+     * @param options The web server options.
+     * @internal
+     */
+    async initCors(options) {
+        let origins = ["*"];
+        if (Is.arrayValue(options?.corsOrigins)) {
+            origins = options?.corsOrigins;
+        }
+        else if (Is.stringValue(options?.corsOrigins)) {
+            origins = [options?.corsOrigins];
+        }
+        const hasWildcardOrigin = origins.includes("*");
+        const methods = options?.methods ?? [
+            HttpMethod.GET,
+            HttpMethod.PUT,
+            HttpMethod.POST,
+            HttpMethod.PATCH,
+            HttpMethod.DELETE,
+            HttpMethod.OPTIONS
+        ];
+        const allowedHeaders = [
+            "Access-Control-Allow-Origin",
+            "Content-Encoding",
+            "Accept-Encoding",
+            HeaderTypes.ContentType,
+            HeaderTypes.Authorization,
+            HeaderTypes.Accept
+        ];
+        const exposedHeaders = [HeaderTypes.ContentDisposition, HeaderTypes.Location];
+        if (Is.arrayValue(options?.allowedHeaders)) {
+            allowedHeaders.push(...options.allowedHeaders);
+        }
+        if (Is.arrayValue(options?.exposedHeaders)) {
+            exposedHeaders.push(...options.exposedHeaders);
+        }
+        await this._fastify.register(FastifyCors, {
+            origin: (origin, callback) => {
+                callback(null, hasWildcardOrigin ? true : origins.includes(origin));
+            },
+            methods,
+            allowedHeaders,
+            exposedHeaders,
+            credentials: true
+        });
+    }
+    /**
+     * Resolve the route processors in to per phase chains, so that the lookups and bindings
+     * are performed once when the server is built instead of on every request.
+     * @param restRouteProcessors The processors for the incoming REST requests.
+     * @param socketRouteProcessors The processors for the incoming socket requests.
+     * @internal
+     */
+    buildProcessorChains(restRouteProcessors, socketRouteProcessors) {
+        const restChains = { pre: [], process: [], post: [] };
+        for (const routeProcessor of restRouteProcessors ?? []) {
+            const pre = routeProcessor.pre?.bind(routeProcessor);
+            if (Is.function(pre)) {
+                restChains.pre.push(pre);
+            }
+            const process = routeProcessor.process?.bind(routeProcessor);
+            if (Is.function(process)) {
+                restChains.process.push(process);
+            }
+            const post = routeProcessor.post?.bind(routeProcessor);
+            if (Is.function(post)) {
+                restChains.post.push(post);
+            }
+        }
+        const socketChains = {
+            connected: [],
+            disconnected: [],
+            pre: [],
+            process: [],
+            post: []
+        };
+        for (const routeProcessor of socketRouteProcessors ?? []) {
+            const connected = routeProcessor.connected?.bind(routeProcessor);
+            if (Is.function(connected)) {
+                socketChains.connected.push(connected);
+            }
+            const disconnected = routeProcessor.disconnected?.bind(routeProcessor);
+            if (Is.function(disconnected)) {
+                socketChains.disconnected.push(disconnected);
+            }
+            const pre = routeProcessor.pre?.bind(routeProcessor);
+            if (Is.function(pre)) {
+                socketChains.pre.push(pre);
+            }
+            const process = routeProcessor.process?.bind(routeProcessor);
+            if (Is.function(process)) {
+                socketChains.process.push(process);
+            }
+            const post = routeProcessor.post?.bind(routeProcessor);
+            if (Is.function(post)) {
+                socketChains.post.push(post);
+            }
+        }
+        this._restChains = restChains;
+        this._socketChains = socketChains;
+    }
+}
+//# sourceMappingURL=fastifyWebServer.js.map