@twin.org/engine-server 0.0.1-next.1

package/dist/cjs/index.cjs

@@ -0,0 +1,513 @@
+'use strict';
+
+var apiAuthEntityStorageService = require('@twin.org/api-auth-entity-storage-service');
+var apiModels = require('@twin.org/api-models');
+var apiServerFastify = require('@twin.org/api-server-fastify');
+var apiService = require('@twin.org/api-service');
+var attestationService = require('@twin.org/attestation-service');
+var auditableItemGraphService = require('@twin.org/auditable-item-graph-service');
+var auditableItemStreamService = require('@twin.org/auditable-item-stream-service');
+var blobStorageService = require('@twin.org/blob-storage-service');
+var core = require('@twin.org/core');
+var engineModels = require('@twin.org/engine-models');
+var entityStorageService = require('@twin.org/entity-storage-service');
+var identityService = require('@twin.org/identity-service');
+var loggingService = require('@twin.org/logging-service');
+var nftService = require('@twin.org/nft-service');
+var telemetryService = require('@twin.org/telemetry-service');
+var engineCore = require('@twin.org/engine-core');
+var apiProcessors = require('@twin.org/api-processors');
+
+/**
+ * Initialise the authentication.
+ * @param engineCore The engine core.
+ * @param context The context for the engine.
+ * @param instanceConfig The instance config.
+ * @param overrideInstanceType The instance type to override the default.
+ * @returns The name of the instance created.
+ * @throws GeneralError if the component type is unknown.
+ */
+function initialiseAuthenticationComponent(engineCore$1, context, instanceConfig, overrideInstanceType) {
+    engineCore$1.logInfo(core.I18n.formatMessage("engineCore.configuring", {
+        element: `Authentication Component: ${instanceConfig.type}`
+    }));
+    const type = instanceConfig.type;
+    let component;
+    let instanceType;
+    if (type === engineModels.AuthenticationComponentType.AuthEntityStorage) {
+        apiAuthEntityStorageService.initSchema();
+        engineCore.initialiseEntityStorageConnector(engineCore$1, context, instanceConfig.options?.userEntityStorageType, "AuthenticationUser");
+        component = new apiAuthEntityStorageService.EntityStorageAuthenticationService({
+            vaultConnectorType: context.defaultTypes.vaultConnector,
+            ...instanceConfig.options
+        });
+        instanceType = apiAuthEntityStorageService.EntityStorageAuthenticationService.NAMESPACE;
+    }
+    else {
+        throw new core.GeneralError("engineCore", "componentUnknownType", {
+            type,
+            componentType: "authenticationComponent"
+        });
+    }
+    const finalInstanceType = overrideInstanceType ?? instanceType;
+    context.componentInstances.push({
+        instanceType: finalInstanceType,
+        component
+    });
+    core.ComponentFactory.register(finalInstanceType, () => component);
+    return finalInstanceType;
+}
+
+/**
+ * Initialise the information component.
+ * @param engineCore The engine core.
+ * @param context The context for the engine.
+ * @param instanceConfig The instance config.
+ * @param overrideInstanceType The instance type to override the default.
+ * @returns The name of the instance created.
+ * @throws GeneralError if the component type is unknown.
+ */
+function initialiseInformationComponent(engineCore, context, instanceConfig, overrideInstanceType) {
+    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
+        element: `Information Component: ${instanceConfig.type}`
+    }));
+    const type = instanceConfig.type;
+    let component;
+    let instanceType;
+    if (type === engineModels.InformationComponentType.Service) {
+        component = new apiService.InformationService(instanceConfig.options);
+        instanceType = apiService.InformationService.NAMESPACE;
+    }
+    else {
+        throw new core.GeneralError("engineCore", "componentUnknownType", {
+            type,
+            componentType: "informationComponent"
+        });
+    }
+    const finalInstanceType = overrideInstanceType ?? instanceType;
+    context.componentInstances.push({
+        instanceType: finalInstanceType,
+        component
+    });
+    core.ComponentFactory.register(finalInstanceType, () => component);
+    return finalInstanceType;
+}
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Initialise the mime type processor.
+ * @param engineCore The engine core.
+ * @param context The context for the engine.
+ * @param instanceConfig The instance config.
+ * @param overrideInstanceType The instance type to override the default.
+ * @returns The name of the instance created.
+ * @throws GeneralError if the component type is unknown.
+ */
+function initialiseMimeTypeProcessorComponent(engineCore, context, instanceConfig, overrideInstanceType) {
+    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
+        element: `Mime Type Processor: ${instanceConfig.type}`
+    }));
+    const type = instanceConfig.type;
+    let component;
+    let instanceType;
+    if (type === engineModels.MimeTypeProcessorType.Jwt) {
+        component = new apiProcessors.JwtMimeTypeProcessor();
+        instanceType = apiProcessors.JwtMimeTypeProcessor.NAMESPACE;
+    }
+    else {
+        throw new core.GeneralError("engineCore", "componentUnknownType", {
+            type,
+            componentType: "mimeTypeProcessorComponent"
+        });
+    }
+    const finalInstanceType = overrideInstanceType ?? instanceType;
+    context.componentInstances.push({
+        instanceType: finalInstanceType,
+        component
+    });
+    apiModels.MimeTypeProcessorFactory.register(finalInstanceType, () => component);
+    return finalInstanceType;
+}
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Initialise the rest route processor.
+ * @param engineCore The engine core.
+ * @param context The context for the engine.
+ * @param instanceConfig The instance config.
+ * @param overrideInstanceType The instance type to override the default.
+ * @returns The name of the instance created.
+ * @throws GeneralError if the component type is unknown.
+ */
+function initialiseRestRouteProcessorComponent(engineCore, context, instanceConfig, overrideInstanceType) {
+    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
+        element: `REST Route Processor: ${instanceConfig.type}`
+    }));
+    const type = instanceConfig.type;
+    let component;
+    let instanceType;
+    if (type === engineModels.RestRouteProcessorType.AuthHeader) {
+        component = new apiAuthEntityStorageService.AuthHeaderProcessor({
+            vaultConnectorType: context.defaultTypes.vaultConnector,
+            config: {
+                ...instanceConfig.options?.config
+            }
+        });
+        instanceType = apiAuthEntityStorageService.AuthHeaderProcessor.NAMESPACE;
+    }
+    else if (type === engineModels.RestRouteProcessorType.Logging) {
+        component = new apiProcessors.LoggingProcessor({
+            loggingConnectorType: context.defaultTypes.loggingConnector,
+            config: {
+                ...instanceConfig.options?.config
+            }
+        });
+        instanceType = apiProcessors.LoggingProcessor.NAMESPACE;
+    }
+    else if (type === engineModels.RestRouteProcessorType.NodeIdentity) {
+        component = new apiProcessors.NodeIdentityProcessor();
+        instanceType = apiProcessors.NodeIdentityProcessor.NAMESPACE;
+    }
+    else if (type === engineModels.RestRouteProcessorType.StaticUserIdentity) {
+        component = new apiProcessors.StaticUserIdentityProcessor(instanceConfig.options);
+        instanceType = apiProcessors.StaticUserIdentityProcessor.NAMESPACE;
+    }
+    else if (type === engineModels.RestRouteProcessorType.RestRoute) {
+        component = new apiProcessors.RestRouteProcessor(instanceConfig.options);
+        instanceType = apiProcessors.RestRouteProcessor.NAMESPACE;
+    }
+    else {
+        throw new core.GeneralError("engineCore", "componentUnknownType", {
+            type,
+            componentType: "restRouteProcessorComponent"
+        });
+    }
+    const finalInstanceType = overrideInstanceType ?? instanceType;
+    context.componentInstances.push({
+        instanceType: finalInstanceType,
+        component
+    });
+    apiModels.RestRouteProcessorFactory.register(finalInstanceType, () => component);
+    return finalInstanceType;
+}
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Initialise the socket route processor.
+ * @param engineCore The engine core.
+ * @param context The context for the engine.
+ * @param instanceConfig The instance config.
+ * @param overrideInstanceType The instance type to override the default.
+ * @returns The name of the instance created.
+ * @throws GeneralError if the component type is unknown.
+ */
+function initialiseSocketRouteProcessorComponent(engineCore, context, instanceConfig, overrideInstanceType) {
+    engineCore.logInfo(core.I18n.formatMessage("engineCore.configuring", {
+        element: `Socket Route Processor: ${instanceConfig.type}`
+    }));
+    const type = instanceConfig.type;
+    let component;
+    let instanceType;
+    if (type === engineModels.SocketRouteProcessorType.AuthHeader) {
+        component = new apiAuthEntityStorageService.AuthHeaderProcessor({
+            vaultConnectorType: context.defaultTypes.vaultConnector,
+            config: {
+                ...instanceConfig.options?.config
+            }
+        });
+        instanceType = apiAuthEntityStorageService.AuthHeaderProcessor.NAMESPACE;
+    }
+    else if (type === engineModels.SocketRouteProcessorType.Logging) {
+        component = new apiProcessors.LoggingProcessor({
+            loggingConnectorType: context.defaultTypes.loggingConnector,
+            config: {
+                ...instanceConfig.options.config
+            }
+        });
+        instanceType = apiProcessors.LoggingProcessor.NAMESPACE;
+    }
+    else if (type === engineModels.SocketRouteProcessorType.NodeIdentity) {
+        component = new apiProcessors.NodeIdentityProcessor();
+        instanceType = apiProcessors.NodeIdentityProcessor.NAMESPACE;
+    }
+    else if (type === engineModels.SocketRouteProcessorType.StaticUserIdentity) {
+        component = new apiProcessors.StaticUserIdentityProcessor(instanceConfig.options);
+        instanceType = apiProcessors.StaticUserIdentityProcessor.NAMESPACE;
+    }
+    else if (type === engineModels.SocketRouteProcessorType.SocketRoute) {
+        component = new apiProcessors.SocketRouteProcessor(instanceConfig.options);
+        instanceType = apiProcessors.SocketRouteProcessor.NAMESPACE;
+    }
+    else {
+        throw new core.GeneralError("engineCore", "componentUnknownType", {
+            type,
+            componentType: "socketRouteProcessorComponent"
+        });
+    }
+    const finalInstanceType = overrideInstanceType ?? instanceType;
+    context.componentInstances.push({
+        instanceType: finalInstanceType,
+        component
+    });
+    apiModels.SocketRouteProcessorFactory.register(finalInstanceType, () => component);
+    return finalInstanceType;
+}
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Server for the engine.
+ */
+class EngineServer {
+    /**
+     * Runtime name for the class.
+     */
+    CLASS_NAME = "EngineServer";
+    /**
+     * The server config.
+     */
+    _config;
+    /**
+     * The engine.
+     * @internal
+     */
+    _engineCore;
+    /**
+     * The REST route generators.
+     * @internal
+     */
+    _restRouteGenerators;
+    /**
+     * The socket route generators.
+     * @internal
+     */
+    _socketRouteGenerators;
+    /**
+     * The web server.
+     * @internal
+     */
+    _webServer;
+    /**
+     * The logging connector type.
+     * @internal
+     */
+    _loggingConnectorType;
+    /**
+     * Create a new instance of EngineServer.
+     * @param options The options for the engine.
+     * @param options.server The server options for the engine.
+     * @param options.engineCore The engine core to serve from.
+     */
+    constructor(options) {
+        core.Guards.object(this.CLASS_NAME, "options", options);
+        core.Guards.object(this.CLASS_NAME, "options.engineCore", options.engineCore);
+        this._config = options?.server ?? {};
+        this._engineCore = options.engineCore;
+        this._restRouteGenerators = [];
+        this._socketRouteGenerators = [];
+        const coreConfig = this._engineCore.getConfig();
+        const defaults = this._engineCore.getDefaultTypes();
+        this._loggingConnectorType = coreConfig.silent ? undefined : defaults.loggingConnector;
+        if (!core.Is.arrayValue(this._config.restRouteProcessor)) {
+            this._config.restRouteProcessor = [];
+            if (!coreConfig.silent) {
+                this._config.restRouteProcessor.push({
+                    type: engineModels.RestRouteProcessorType.Logging,
+                    options: {
+                        config: {
+                            includeBody: coreConfig.debug
+                        }
+                    }
+                });
+            }
+            this._config.restRouteProcessor.push({
+                type: engineModels.RestRouteProcessorType.RestRoute,
+                options: {
+                    config: {
+                        includeErrorStack: coreConfig.debug
+                    }
+                }
+            });
+        }
+        this.addServerTypeInitialisers();
+        this.addServerRestRouteGenerators();
+        this.addServerSocketRouteGenerators();
+    }
+    /**
+     * Add a REST route generator.
+     * @param type The type to add the generator for.
+     * @param typeConfig The type config.
+     * @param generator The generator to add.
+     */
+    addRestRouteGenerator(type, typeConfig, generator) {
+        if (!core.Is.empty(typeConfig)) {
+            this._restRouteGenerators.push({
+                type,
+                typeConfig,
+                generator
+            });
+        }
+    }
+    /**
+     * Add a socket route generator.
+     * @param type The type to add the generator for.
+     * @param typeConfig The type config.
+     * @param generator The generator to add.
+     */
+    addSocketRouteGenerator(type, typeConfig, generator) {
+        if (!core.Is.empty(typeConfig)) {
+            this._socketRouteGenerators.push({
+                type,
+                typeConfig,
+                generator
+            });
+        }
+    }
+    /**
+     * Start the engine server.
+     * @returns Nothing.
+     */
+    async start() {
+        await this._engineCore.start();
+        await this.startWebServer();
+    }
+    /**
+     * Stop the engine server.
+     * @returns Nothing.
+     */
+    async stop() {
+        if (this._webServer) {
+            await this._webServer.stop();
+            this._webServer = undefined;
+        }
+        await this._engineCore.stop();
+    }
+    /**
+     * Starts the web server.
+     * @internal
+     */
+    async startWebServer() {
+        const restRoutes = this.buildRestRoutes();
+        const socketRoutes = this.buildSocketRoutes();
+        const restRouteProcessors = apiModels.RestRouteProcessorFactory.names().map(n => apiModels.RestRouteProcessorFactory.get(n));
+        const socketRouteProcessors = apiModels.SocketRouteProcessorFactory.names().map(n => apiModels.SocketRouteProcessorFactory.get(n));
+        const mimeTypeProcessors = apiModels.MimeTypeProcessorFactory.names().map(n => apiModels.MimeTypeProcessorFactory.get(n));
+        this._webServer = new apiServerFastify.FastifyWebServer({
+            loggingConnectorType: this._loggingConnectorType,
+            mimeTypeProcessors
+        });
+        await this._webServer.build(restRouteProcessors, restRoutes, socketRouteProcessors, socketRoutes, this._config.web);
+        await this._webServer.start();
+    }
+    /**
+     * The REST routes for the application.
+     * @returns The REST routes for the application.
+     * @internal
+     */
+    buildRestRoutes() {
+        const routes = [];
+        for (const { type, typeConfig, generator } of this._restRouteGenerators) {
+            this.initialiseRestTypeRoute(routes, type, typeConfig, generator);
+        }
+        return routes;
+    }
+    /**
+     * The socket routes for the application.
+     * @returns The socket routes for the application.
+     * @internal
+     */
+    buildSocketRoutes() {
+        const routes = [];
+        for (const { type, typeConfig, generator } of this._socketRouteGenerators) {
+            this.initialiseSocketTypeRoute(routes, type, typeConfig, generator);
+        }
+        return routes;
+    }
+    /**
+     * Initialise the rest routes from connector.
+     * @param routes The routes to add to.
+     * @param typeKey The key for the default types.
+     * @param typeConfig The type config.
+     * @param generateRoutes The function to generate the routes.
+     * @internal
+     */
+    initialiseRestTypeRoute(routes, typeKey, typeConfig, generateRoutes) {
+        if (core.Is.arrayValue(typeConfig)) {
+            const defaultEngineTypes = this._engineCore.getDefaultTypes();
+            for (let i = 0; i < typeConfig.length; i++) {
+                const restPath = typeConfig[i].restPath;
+                if (core.Is.string(restPath)) {
+                    const serviceType = typeConfig[i].overrideInstanceType ?? defaultEngineTypes[typeKey];
+                    if (core.Is.stringValue(serviceType)) {
+                        routes.push(...generateRoutes(restPath, serviceType));
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * Initialise the rest routes from connector.
+     * @param routes The routes to add to.
+     * @param typeKey The key for the default types.
+     * @param typeConfig The type config.
+     * @param generateRoutes The function to generate the routes.
+     * @internal
+     */
+    initialiseSocketTypeRoute(routes, typeKey, typeConfig, generateRoutes) {
+        if (core.Is.arrayValue(typeConfig)) {
+            const defaultEngineTypes = this._engineCore.getDefaultTypes();
+            for (let i = 0; i < typeConfig.length; i++) {
+                const socketPath = typeConfig[i].socketPath;
+                if (core.Is.string(socketPath)) {
+                    const serviceType = typeConfig[i].overrideInstanceType ?? defaultEngineTypes[typeKey];
+                    if (core.Is.stringValue(serviceType)) {
+                        routes.push(...generateRoutes(socketPath, serviceType));
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * Add the server type initializers.
+     * @internal
+     */
+    addServerTypeInitialisers() {
+        this._engineCore.addTypeInitialiser("authenticationComponent", this._config.authenticationComponent, initialiseAuthenticationComponent);
+        this._engineCore.addTypeInitialiser("informationComponent", this._config.informationComponent, initialiseInformationComponent);
+        this._engineCore.addTypeInitialiser("restRouteProcessor", this._config.restRouteProcessor, initialiseRestRouteProcessorComponent);
+        this._engineCore.addTypeInitialiser("socketRouteProcessor", this._config.socketRouteProcessor, initialiseSocketRouteProcessorComponent);
+        this._engineCore.addTypeInitialiser("mimeTypeProcessor", this._config.mimeTypeProcessor, initialiseMimeTypeProcessorComponent);
+    }
+    /**
+     * Add the server REST route generators.
+     * @internal
+     */
+    addServerRestRouteGenerators() {
+        this.addRestRouteGenerator("informationComponent", this._config.informationComponent, apiService.generateRestRoutesInformation);
+        this.addRestRouteGenerator("authenticationComponent", this._config.authenticationComponent, apiAuthEntityStorageService.generateRestRoutesAuthentication);
+        const coreConfig = this._engineCore.getConfig();
+        this.addRestRouteGenerator("loggingComponent", coreConfig.loggingComponent, blobStorageService.generateRestRoutesBlobStorage);
+        this.addRestRouteGenerator("telemetryComponent", coreConfig.telemetryComponent, telemetryService.generateRestRoutesTelemetry);
+        this.addRestRouteGenerator("blobStorageComponent", coreConfig.blobStorageComponent, loggingService.generateRestRoutesLogging);
+        this.addRestRouteGenerator("identityComponent", coreConfig.identityComponent, identityService.generateRestRoutesIdentity);
+        this.addRestRouteGenerator("identityProfileComponent", coreConfig.identityProfileComponent, identityService.generateRestRoutesIdentityProfile);
+        this.addRestRouteGenerator("nftComponent", coreConfig.nftComponent, nftService.generateRestRoutesNft);
+        this.addRestRouteGenerator("attestationComponent", coreConfig.attestationComponent, attestationService.generateRestRoutesAttestation);
+        this.addRestRouteGenerator("auditableItemGraphComponent", coreConfig.auditableItemGraphComponent, auditableItemGraphService.generateRestRoutesAuditableItemGraph);
+        this.addRestRouteGenerator("auditableItemStreamComponent", coreConfig.auditableItemStreamComponent, auditableItemStreamService.generateRestRoutesAuditableItemStream);
+        this.addRestRouteGenerator("entityStorageComponent", coreConfig.entityStorageComponent, entityStorageService.generateRestRoutesEntityStorage);
+    }
+    /**
+     * Add the server socket route generators.
+     * @internal
+     */
+    addServerSocketRouteGenerators() {
+        // const coreConfig = this._engineCore.getConfig();
+        // this.addSocketRouteGenerator("eventBusComponent", coreConfig.eventBusComponent, generateSocketRoutesEventBus);
+    }
+}
+
+exports.EngineServer = EngineServer;