@twin.org/api-server-fastify 0.0.2-next.9 → 0.0.3-next.1

package/dist/cjs/index.cjs

@@ -1,562 +0,0 @@
-'use strict';
-
-var FastifyCompress = require('@fastify/compress');
-var FastifyCors = require('@fastify/cors');
-var apiModels = require('@twin.org/api-models');
-var apiProcessors = require('@twin.org/api-processors');
-var core = require('@twin.org/core');
-var web = require('@twin.org/web');
-var Fastify = require('fastify');
-var fp = require('fastify-plugin');
-var socket_io = require('socket.io');
-
-// This is a clone of fastify-socket.io which runs with recent fastify versions.
-const fastifySocketIO = fp(async (fastify, opts) => {
-    const ioServer = new socket_io.Server(fastify.server, opts);
-    fastify.decorate("io", ioServer);
-    fastify.addHook("preClose", done => {
-        ioServer.disconnectSockets();
-        ioServer.close();
-        done();
-    });
-}, { fastify: ">=5.x.x", name: "socket.io" });
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Implementation of the web server using Fastify.
- */
-class FastifyWebServer {
-    /**
-     * Runtime name for the class in camel case.
-     * @internal
-     */
-    static _CLASS_NAME_CAMEL_CASE = core.StringHelper.camelCase("FastifyWebServer");
-    /**
-     * Default port for running the server.
-     * @internal
-     */
-    static _DEFAULT_PORT = 3000;
-    /**
-     * Default host for running the server.
-     * @internal
-     */
-    static _DEFAULT_HOST = "localhost";
-    /**
-     * Runtime name for the class.
-     */
-    CLASS_NAME = "FastifyWebServer";
-    /**
-     * 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;
-    /**
-     * Create a new instance of FastifyWebServer.
-     * @param options The options for the server.
-     */
-    constructor(options) {
-        this._loggingComponentType = options?.loggingComponentType;
-        this._logging = core.ComponentFactory.getIfExists(options?.loggingComponentType ?? "logging");
-        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._mimeTypeProcessors = options?.mimeTypeProcessors ?? [];
-        const hasJsonLd = this._mimeTypeProcessors.find(processor => processor.CLASS_NAME === "json-ld");
-        if (!hasJsonLd) {
-            this._mimeTypeProcessors.push(new apiProcessors.JsonLdMimeTypeProcessor());
-        }
-        this._includeErrorStack = options?.config?.includeErrorStack ?? false;
-    }
-    /**
-     * 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 Nothing.
-     */
-    async build(restRouteProcessors, restRoutes, socketRouteProcessors, socketRoutes, options) {
-        if (core.Is.arrayValue(restRoutes) && !core.Is.arrayValue(restRouteProcessors)) {
-            throw new core.GeneralError(this.CLASS_NAME, "noRestProcessors");
-        }
-        if (core.Is.arrayValue(socketRoutes) && !core.Is.arrayValue(socketRouteProcessors)) {
-            throw new core.GeneralError(this.CLASS_NAME, "noSocketProcessors");
-        }
-        await this._logging?.log({
-            level: "info",
-            ts: Date.now(),
-            source: this.CLASS_NAME,
-            message: `${FastifyWebServer._CLASS_NAME_CAMEL_CASE}.building`
-        });
-        this._options = options;
-        await this._fastify.register(FastifyCompress);
-        if (core.Is.arrayValue(socketRoutes)) {
-            await this._fastify.register(fastifySocketIO, this._socketConfig);
-        }
-        if (core.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(core.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 (core.Is.number(error.code)) {
-                err = {
-                    source: this.CLASS_NAME,
-                    name: error.name,
-                    message: `${error.code}: ${error.message}`
-                };
-                httpStatusCode = error.statusCode ?? web.HttpStatusCode.badRequest;
-            }
-            else {
-                const errorAndCode = apiModels.HttpErrorHelper.processError(error);
-                err = errorAndCode.error;
-                httpStatusCode = errorAndCode.httpStatusCode;
-            }
-            await this._logging?.log({
-                level: "error",
-                ts: Date.now(),
-                source: this.CLASS_NAME,
-                message: `${FastifyWebServer._CLASS_NAME_CAMEL_CASE}.badRequest`,
-                error: err
-            });
-            return reply.status(httpStatusCode).send({
-                error: err
-            });
-        });
-        await this.addRoutesRest(restRouteProcessors, restRoutes);
-        await this.addRoutesSocket(socketRouteProcessors, socketRoutes);
-    }
-    /**
-     * Start the server.
-     * @returns Nothing.
-     */
-    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: this.CLASS_NAME,
-            message: `${FastifyWebServer._CLASS_NAME_CAMEL_CASE}.starting`,
-            data: {
-                host,
-                port
-            }
-        });
-        if (!this._started) {
-            try {
-                await this._fastify.listen({ port, host });
-                const addresses = this._fastify.addresses();
-                const protocol = core.Is.object(this._fastify.initialConfig.https) ? "https://" : "http://";
-                await this._logging?.log({
-                    level: "info",
-                    ts: Date.now(),
-                    source: this.CLASS_NAME,
-                    message: `${FastifyWebServer._CLASS_NAME_CAMEL_CASE}.started`,
-                    data: {
-                        addresses: addresses
-                            .map(a => `${protocol}${a.family === "IPv6" ? "[" : ""}${a.address}${a.family === "IPv6" ? "]" : ""}:${a.port}`)
-                            .join(", ")
-                    }
-                });
-                this._started = true;
-            }
-            catch (err) {
-                await this._logging?.log({
-                    level: "error",
-                    ts: Date.now(),
-                    source: this.CLASS_NAME,
-                    message: `${FastifyWebServer._CLASS_NAME_CAMEL_CASE}.startFailed`,
-                    error: core.BaseError.fromError(err)
-                });
-            }
-        }
-    }
-    /**
-     * Stop the server.
-     * @returns Nothing.
-     */
-    async stop() {
-        if (this._started) {
-            this._started = false;
-            await this._fastify.close();
-            await this._logging?.log({
-                level: "info",
-                ts: Date.now(),
-                source: this.CLASS_NAME,
-                message: `${FastifyWebServer._CLASS_NAME_CAMEL_CASE}.stopped`
-            });
-        }
-    }
-    /**
-     * 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 (core.Is.arrayValue(restRouteProcessors) && core.Is.arrayValue(restRoutes)) {
-            for (const restRoute of restRoutes) {
-                let path = core.StringHelper.trimTrailingSlashes(restRoute.path);
-                if (!path.startsWith("/")) {
-                    path = `/${path}`;
-                }
-                await this._logging?.log({
-                    level: "info",
-                    ts: Date.now(),
-                    source: this.CLASS_NAME,
-                    message: `${FastifyWebServer._CLASS_NAME_CAMEL_CASE}.restRouteAdded`,
-                    data: { route: path, method: restRoute.method }
-                });
-                const method = restRoute.method.toLowerCase();
-                this._fastify[method](path, async (request, reply) => this.handleRequestRest(restRouteProcessors, request, reply, 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) {
-        if (core.Is.arrayValue(socketRouteProcessors) && core.Is.arrayValue(socketRoutes)) {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const io = this._fastify.io;
-            for (const socketRoute of socketRoutes) {
-                const path = core.StringHelper.trimLeadingSlashes(core.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: this.CLASS_NAME,
-                    message: `${FastifyWebServer._CLASS_NAME_CAMEL_CASE}.socketRouteAdded`,
-                    data: {
-                        handshakePath: this._socketConfig.path,
-                        namespace,
-                        eventName: topic
-                    }
-                });
-                const socketNamespace = io.of(namespace);
-                socketNamespace.on("connection", async (socket) => {
-                    const socketServerRequest = {
-                        method: web.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 } = apiModels.HttpErrorHelper.processError(err, this._includeErrorStack);
-                        const response = {};
-                        apiModels.HttpErrorHelper.buildResponse(response, error, httpStatusCode);
-                        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) => {
-                        await this.handleRequestSocket(socketRouteProcessors, socketRoute, socket, `/${pathParts.join("/")}`, topic, data);
-                    });
-                });
-            }
-        }
-    }
-    /**
-     * 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.
-     * @internal
-     */
-    async handleRequestRest(restRouteProcessors, request, reply, restRoute) {
-        const httpServerRequest = {
-            method: request.method.toUpperCase(),
-            url: `${request.protocol}://${request.hostname}${request.url}`,
-            body: request.body,
-            query: request.query,
-            pathParams: request.params,
-            headers: request.headers
-        };
-        const httpResponse = {};
-        const httpRequestIdentity = {};
-        const processorState = {};
-        await this.runProcessorsRest(restRouteProcessors, restRoute, httpServerRequest, httpResponse, httpRequestIdentity, processorState);
-        if (!core.Is.empty(httpResponse.headers)) {
-            for (const header of Object.keys(httpResponse.headers)) {
-                reply.header(header, httpResponse.headers[header]);
-            }
-        }
-        return reply
-            .status((httpResponse.statusCode ?? web.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 httpRequestIdentity The identity context for the request.
-     * @internal
-     */
-    async runProcessorsRest(restRouteProcessors, restRoute, httpServerRequest, httpResponse, httpRequestIdentity, processorState) {
-        try {
-            for (const routeProcessor of restRouteProcessors) {
-                if (routeProcessor.pre) {
-                    await routeProcessor.pre(httpServerRequest, httpResponse, restRoute, httpRequestIdentity, processorState, this._loggingComponentType);
-                }
-            }
-            for (const routeProcessor of restRouteProcessors) {
-                if (routeProcessor.process) {
-                    await routeProcessor.process(httpServerRequest, httpResponse, restRoute, httpRequestIdentity, processorState, this._loggingComponentType);
-                }
-            }
-            for (const routeProcessor of restRouteProcessors) {
-                if (routeProcessor.post) {
-                    await routeProcessor.post(httpServerRequest, httpResponse, restRoute, httpRequestIdentity, processorState, this._loggingComponentType);
-                }
-            }
-        }
-        catch (err) {
-            const { error, httpStatusCode } = apiModels.HttpErrorHelper.processError(err, this._includeErrorStack);
-            apiModels.HttpErrorHelper.buildResponse(httpResponse, error, httpStatusCode);
-        }
-    }
-    /**
-     * 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 data The incoming data.
-     * @internal
-     */
-    async handleRequestSocket(socketRouteProcessors, socketRoute, socket, fullPath, emitTopic, request) {
-        const socketServerRequest = {
-            method: web.HttpMethod.GET,
-            url: fullPath,
-            query: socket.handshake.query,
-            headers: socket.handshake.headers,
-            body: request.body,
-            socketId: socket.id
-        };
-        const httpResponse = {};
-        const httpRequestIdentity = {};
-        const processorState = {};
-        delete socketServerRequest.query?.EIO;
-        delete socketServerRequest.query?.transport;
-        await this.runProcessorsSocket(socketRouteProcessors, socketRoute, socketServerRequest, httpResponse, httpRequestIdentity, processorState, emitTopic, async (topic, response) => {
-            await socket.emit(topic, response);
-        });
-    }
-    /**
-     * Run the socket processors for the route.
-     * @param socketId The id of the socket.
-     * @param socketRouteProcessors The processors to run.
-     * @param socketRoute The route to process.
-     * @param socketServerRequest The incoming request.
-     * @param httpResponse The outgoing response.
-     * @param httpRequestIdentity The identity context for the request.
-     * @param processorState The state handed through the processors.
-     * @param requestTopic The topic of the request.
-     * @internal
-     */
-    async runProcessorsSocket(socketRouteProcessors, socketRoute, socketServerRequest, httpResponse, httpRequestIdentity, 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 postSocketRouteProcessor of socketRouteProcessors) {
-                    if (postSocketRouteProcessor.post) {
-                        await postSocketRouteProcessor.post(socketServerRequest, response, socketRoute, httpRequestIdentity, responseProcessorState, this._loggingComponentType);
-                    }
-                }
-            }
-            catch (err) {
-                this._logging?.log({
-                    level: "error",
-                    ts: Date.now(),
-                    source: this.CLASS_NAME,
-                    message: `${FastifyWebServer._CLASS_NAME_CAMEL_CASE}.postProcessorError`,
-                    error: core.BaseError.fromError(err),
-                    data: {
-                        route: socketRoute.path
-                    }
-                });
-            }
-        };
-        try {
-            for (const socketRouteProcessor of socketRouteProcessors) {
-                if (socketRouteProcessor.pre) {
-                    await socketRouteProcessor.pre(socketServerRequest, httpResponse, socketRoute, httpRequestIdentity, processorState, 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 (!core.Is.empty(httpResponse.statusCode)) {
-                await postProcessEmit(requestTopic, httpResponse, processorState);
-            }
-            for (const socketRouteProcessor of socketRouteProcessors) {
-                if (socketRouteProcessor.process) {
-                    await socketRouteProcessor.process(socketServerRequest, httpResponse, socketRoute, httpRequestIdentity, 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 (core.Is.integer(httpResponse.statusCode) &&
-                httpResponse.statusCode >= web.HttpStatusCode.badRequest) {
-                await postProcessEmit(requestTopic, httpResponse, processorState);
-            }
-        }
-        catch (err) {
-            // Emit any unhandled errors manually
-            const { error, httpStatusCode } = apiModels.HttpErrorHelper.processError(err, this._includeErrorStack);
-            apiModels.HttpErrorHelper.buildResponse(httpResponse, error, httpStatusCode);
-            await postProcessEmit(requestTopic, httpResponse, processorState);
-        }
-    }
-    /**
-     * Initialize the cors options.
-     * @param options The web server options.
-     * @internal
-     */
-    async initCors(options) {
-        let origins = ["*"];
-        if (core.Is.arrayValue(options?.corsOrigins)) {
-            origins = options?.corsOrigins;
-        }
-        else if (core.Is.stringValue(options?.corsOrigins)) {
-            origins = [options?.corsOrigins];
-        }
-        const hasWildcardOrigin = origins.includes("*");
-        const methods = options?.methods ?? [
-            web.HttpMethod.GET,
-            web.HttpMethod.PUT,
-            web.HttpMethod.POST,
-            web.HttpMethod.DELETE,
-            web.HttpMethod.OPTIONS
-        ];
-        const allowedHeaders = [
-            "Access-Control-Allow-Origin",
-            "Content-Encoding",
-            "Accept-Encoding",
-            web.HeaderTypes.ContentType,
-            web.HeaderTypes.Authorization,
-            web.HeaderTypes.Accept
-        ];
-        const exposedHeaders = [web.HeaderTypes.ContentDisposition, web.HeaderTypes.Location];
-        if (core.Is.arrayValue(options?.allowedHeaders)) {
-            allowedHeaders.push(...options.allowedHeaders);
-        }
-        if (core.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
-        });
-    }
-}
-
-exports.FastifyWebServer = FastifyWebServer;