@twin.org/engine-core 0.0.2-next.9 → 0.0.3-next.2

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@twin.org/engine-core",
-	"version": "0.0.2-next.9",
+	"version": "0.0.3-next.2",
 	"description": "Engine core.",
 	"repository": {
 		"type": "git",
@@ -14,10 +14,11 @@
 		"node": ">=20.0.0"
 	},
 	"dependencies": {
+		"@twin.org/context": "next",
 		"@twin.org/core": "next",
 		"@twin.org/crypto": "next",
 		"@twin.org/data-core": "next",
-		"@twin.org/engine-models": "0.0.2-next.9",
+		"@twin.org/engine-models": "0.0.3-next.2",
 		"@twin.org/entity": "next",
 		"@twin.org/logging-connector-console": "next",
 		"@twin.org/logging-models": "next",
@@ -25,22 +26,35 @@
 		"@twin.org/modules": "next",
 		"@twin.org/nameof": "next"
 	},
-	"main": "./dist/cjs/index.cjs",
-	"module": "./dist/esm/index.mjs",
+	"main": "./dist/es/index.js",
 	"types": "./dist/types/index.d.ts",
 	"exports": {
 		".": {
 			"types": "./dist/types/index.d.ts",
-			"require": "./dist/cjs/index.cjs",
-			"import": "./dist/esm/index.mjs"
+			"import": "./dist/es/index.js",
+			"default": "./dist/es/index.js"
 		},
 		"./locales/*.json": "./locales/*.json"
 	},
 	"files": [
-		"dist/cjs",
-		"dist/esm",
+		"dist/es",
 		"dist/types",
 		"locales",
 		"docs"
-	]
+	],
+	"keywords": [
+		"twin",
+		"trade",
+		"iota",
+		"framework",
+		"blockchain",
+		"engine",
+		"core",
+		"foundation",
+		"utilities"
+	],
+	"bugs": {
+		"url": "git+https://github.com/twinfoundation/engine/issues"
+	},
+	"homepage": "https://twindev.org"
 }

package/dist/cjs/index.cjs

@@ -1,649 +0,0 @@
-'use strict';
-
-var node_worker_threads = require('node:worker_threads');
-var core = require('@twin.org/core');
-var entity = require('@twin.org/entity');
-var loggingConnectorConsole = require('@twin.org/logging-connector-console');
-var loggingModels = require('@twin.org/logging-models');
-var loggingService = require('@twin.org/logging-service');
-var modules = require('@twin.org/modules');
-var promises = require('node:fs/promises');
-var path = require('node:path');
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Store state in memory.
- */
-class MemoryStateStorage {
-    /**
-     * Runtime name for the class.
-     */
-    CLASS_NAME = "MemoryStateStorage";
-    /**
-     * Readonly mode state file is not updated.
-     * @internal
-     */
-    _readonlyMode;
-    /**
-     * The state object.
-     * @internal
-     */
-    _engineState;
-    /**
-     * Create a new instance of MemoryStateStorage.
-     * @param readonlyMode Whether the file is in read-only mode.
-     * @param state The initial state.
-     */
-    constructor(readonlyMode = false, state) {
-        this._readonlyMode = readonlyMode;
-        this._engineState = state;
-    }
-    /**
-     * Method for loading the state.
-     * @param engineCore The engine core to load the state for.
-     * @returns The state of the engine or undefined if it doesn't exist.
-     */
-    async load(engineCore) {
-        engineCore.logInfo(core.I18n.formatMessage(`${core.StringHelper.camelCase(this.CLASS_NAME)}.loading`, {
-            filename: this._engineState
-        }));
-        return this._engineState;
-    }
-    /**
-     * Method for saving the state.
-     * @param engineCore The engine core to save the state for.
-     * @param state The state of the engine to save.
-     * @returns Nothing.
-     */
-    async save(engineCore, state) {
-        if (!this._readonlyMode) {
-            engineCore.logInfo(core.I18n.formatMessage(`${core.StringHelper.camelCase(this.CLASS_NAME)}.saving`));
-            this._engineState = state;
-        }
-    }
-}
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Core for the engine.
- */
-class EngineCore {
-    /**
-     * Name for the engine logger.
-     */
-    static LOGGER_TYPE_NAME = "engine";
-    /**
-     * Runtime name for the class in camel case.
-     * @internal
-     */
-    static _CLASS_NAME_CAMEL_CASE = core.StringHelper.camelCase("EngineCore");
-    /**
-     * Runtime name for the class.
-     * @internal
-     */
-    static _CLASS_NAME = "EngineCore";
-    /**
-     * The core context.
-     */
-    _context;
-    /**
-     * The state storage interface.
-     * @internal
-     */
-    _stateStorage;
-    /**
-     * The logging component for the engine.
-     * @internal
-     */
-    _engineLoggingComponent;
-    /**
-     * Skip the bootstrap process.
-     * @internal
-     */
-    _skipBootstrap;
-    /**
-     * The logger type name to use.
-     * @internal
-     */
-    _loggerTypeName;
-    /**
-     * The type initialisers.
-     * @internal
-     */
-    _typeInitialisers;
-    /**
-     * Is the engine started.
-     * @internal
-     */
-    _isStarted;
-    /**
-     * Is the engine a clone.
-     * @internal
-     */
-    _isClone;
-    /**
-     * Add type initialisers to the engine.
-     * @internal
-     */
-    _populateTypeInitialisers;
-    /**
-     * Method for bootstrapping any data for the engine.
-     * @internal
-     */
-    _customBootstrap;
-    /**
-     * Create a new instance of EngineCore.
-     * @param options The options for the engine.
-     */
-    constructor(options) {
-        options = options ?? {};
-        options.config = options.config ?? {};
-        options.config.debug = options.config.debug ?? false;
-        options.config.silent = options.config.silent ?? false;
-        options.config.types ??= {};
-        this._skipBootstrap = options.skipBootstrap ?? false;
-        this._populateTypeInitialisers = options.populateTypeInitialisers;
-        this._customBootstrap = options.customBootstrap;
-        this._loggerTypeName = options.loggerTypeName ?? EngineCore.LOGGER_TYPE_NAME;
-        this._typeInitialisers = [];
-        this._context = {
-            config: options.config,
-            registeredInstances: {},
-            componentInstances: [],
-            state: {},
-            stateDirty: false
-        };
-        this._stateStorage = options.stateStorage;
-        this._isStarted = false;
-        this._isClone = false;
-        if (core.Is.function(this._populateTypeInitialisers)) {
-            this._populateTypeInitialisers(this, this._context);
-        }
-    }
-    /**
-     * Add a type initialiser.
-     * @param type The type to add the initialiser for.
-     * @param typeConfig The type config.
-     * @param module The name of the module which contains the initialiser method.
-     * @param method The name of the method to call.
-     */
-    addTypeInitialiser(type, typeConfig, module, method) {
-        if (!core.Is.empty(typeConfig)) {
-            this._typeInitialisers.push({
-                type,
-                typeConfig,
-                module,
-                method
-            });
-        }
-    }
-    /**
-     * Start the engine core.
-     * @returns True if the start was successful.
-     */
-    async start() {
-        if (this._isStarted) {
-            return false;
-        }
-        this.setupEngineLogger();
-        this.logInfo(core.I18n.formatMessage(`${EngineCore._CLASS_NAME_CAMEL_CASE}.starting`));
-        if (this._context.config.debug) {
-            this.logInfo(core.I18n.formatMessage(`${EngineCore._CLASS_NAME_CAMEL_CASE}.debuggingEnabled`));
-        }
-        let canContinue;
-        try {
-            canContinue = await this.stateLoad();
-            if (canContinue) {
-                for (const { type, typeConfig, module, method } of this._typeInitialisers) {
-                    await this.initialiseTypeConfig(type, typeConfig, module, method);
-                }
-                await this.bootstrap();
-                this.logInfo(core.I18n.formatMessage(`${EngineCore._CLASS_NAME_CAMEL_CASE}.componentsStarting`));
-                for (const instance of this._context.componentInstances) {
-                    if (core.Is.function(instance.component.start)) {
-                        this.logInfo(core.I18n.formatMessage(`${EngineCore._CLASS_NAME_CAMEL_CASE}.componentStarting`, {
-                            element: instance.instanceType
-                        }));
-                        await instance.component.start(this._context.state.nodeIdentity, this._loggerTypeName);
-                    }
-                }
-                this.logInfo(core.I18n.formatMessage(`${EngineCore._CLASS_NAME_CAMEL_CASE}.componentsComplete`));
-            }
-            this.logInfo(core.I18n.formatMessage(`${EngineCore._CLASS_NAME_CAMEL_CASE}.started`));
-            this._isStarted = true;
-        }
-        catch (err) {
-            canContinue = false;
-            this.logError(core.BaseError.fromError(err));
-        }
-        finally {
-            if (!(await this.stateSave())) {
-                canContinue = false;
-            }
-        }
-        return canContinue;
-    }
-    /**
-     * Stop the engine core.
-     * @returns Nothing.
-     */
-    async stop() {
-        this.logInfo(core.I18n.formatMessage(`${EngineCore._CLASS_NAME_CAMEL_CASE}.stopping`));
-        this.logInfo(core.I18n.formatMessage(`${EngineCore._CLASS_NAME_CAMEL_CASE}.componentsStopping`));
-        for (const instance of this._context.componentInstances) {
-            if (core.Is.function(instance.component.stop)) {
-                this.logInfo(core.I18n.formatMessage(`${EngineCore._CLASS_NAME_CAMEL_CASE}.componentStopping`, {
-                    element: instance.instanceType
-                }));
-                try {
-                    await instance.component.stop(this._context.state.nodeIdentity, this._loggerTypeName);
-                }
-                catch (err) {
-                    this.logError(new core.GeneralError(EngineCore._CLASS_NAME, "componentStopFailed", {
-                        component: instance.instanceType
-                    }, core.BaseError.fromError(err)));
-                }
-            }
-        }
-        await this.stateSave();
-        this.logInfo(core.I18n.formatMessage(`${EngineCore._CLASS_NAME_CAMEL_CASE}.componentsStopped`));
-        this.logInfo(core.I18n.formatMessage(`${EngineCore._CLASS_NAME_CAMEL_CASE}.stopped`));
-    }
-    /**
-     * Is the engine started.
-     * @returns True if the engine is started.
-     */
-    isStarted() {
-        return this._isStarted;
-    }
-    /**
-     * Is this the primary engine instance.
-     * @returns True if the engine is the primary instance.
-     */
-    isPrimary() {
-        return node_worker_threads.isMainThread && !this._isClone;
-    }
-    /**
-     * Is this engine instance a clone.
-     * @returns True if the engine instance is a clone.
-     */
-    isClone() {
-        return this._isClone;
-    }
-    /**
-     * Log info.
-     * @param message The message to log.
-     */
-    logInfo(message) {
-        this._engineLoggingComponent?.log({
-            source: EngineCore._CLASS_NAME,
-            level: "info",
-            message
-        });
-    }
-    /**
-     * Log error.
-     * @param error The error to log.
-     */
-    logError(error) {
-        const formattedErrors = core.ErrorHelper.localizeErrors(error);
-        for (const formattedError of formattedErrors) {
-            let message = core.Is.stringValue(formattedError.source)
-                ? `${formattedError.source}: ${formattedError.message}`
-                : formattedError.message;
-            if (this._context.config.debug && core.Is.stringValue(formattedError.stack)) {
-                message += `\n${formattedError.stack}`;
-            }
-            this._engineLoggingComponent?.log({
-                source: EngineCore._CLASS_NAME,
-                level: "error",
-                message
-            });
-        }
-    }
-    /**
-     * Get the config for the engine.
-     * @returns The config for the engine.
-     */
-    getConfig() {
-        return this._context.config;
-    }
-    /**
-     * Get the state of the engine.
-     * @returns The state of the engine.
-     */
-    getState() {
-        return this._context.state;
-    }
-    /**
-     * Get all the registered instances.
-     * @returns The registered instances.
-     */
-    getRegisteredInstances() {
-        return this._context.registeredInstances;
-    }
-    /**
-     * Get the registered instance type for the component/connector.
-     * @param componentConnectorType The type of the component/connector.
-     * @param features The requested features of the component, if not specified the default entry will be retrieved.
-     * @returns The instance type matching the criteria if one is registered.
-     * @throws If a matching instance was not found.
-     */
-    getRegisteredInstanceType(componentConnectorType, features) {
-        core.Guards.stringValue(EngineCore._CLASS_NAME, "componentConnectorType", componentConnectorType);
-        const registeredType = this.getRegisteredInstanceTypeOptional(componentConnectorType, features);
-        if (!core.Is.stringValue(registeredType)) {
-            throw new core.GeneralError(EngineCore._CLASS_NAME, "instanceTypeNotFound", {
-                type: componentConnectorType,
-                features: (features ?? ["default"]).join(",")
-            });
-        }
-        return registeredType;
-    }
-    /**
-     * Get the registered instance type for the component/connector if it exists.
-     * @param componentConnectorType The type of the component/connector.
-     * @param features The requested features of the component, if not specified the default entry will be retrieved.
-     * @returns The instance type matching the criteria if one is registered.
-     */
-    getRegisteredInstanceTypeOptional(componentConnectorType, features) {
-        let registeredType;
-        const registeredTypes = this._context.registeredInstances[componentConnectorType];
-        if (core.Is.arrayValue(registeredTypes)) {
-            if (core.Is.arrayValue(features)) {
-                registeredType = registeredTypes.find(t => t.features?.every(f => features.includes(f)))?.type;
-            }
-            else {
-                registeredType = registeredTypes[0]?.type;
-            }
-        }
-        return registeredType;
-    }
-    /**
-     * Get the data required to create a clone of the engine.
-     * @returns The clone data.
-     */
-    getCloneData() {
-        const entitySchemas = {};
-        const entitySchemaNames = entity.EntitySchemaFactory.names();
-        for (const schemaName of entitySchemaNames) {
-            entitySchemas[schemaName] = entity.EntitySchemaFactory.get(schemaName);
-        }
-        const cloneData = {
-            config: this._context.config,
-            state: this._context.state,
-            typeInitialisers: this._typeInitialisers,
-            entitySchemas,
-            loggerTypeName: this._loggerTypeName
-        };
-        return cloneData;
-    }
-    /**
-     * Populate the engine from the clone data.
-     * @param cloneData The clone data to populate from.
-     * @param silent Should the clone be silent.
-     */
-    populateClone(cloneData, silent) {
-        core.Guards.object(EngineCore._CLASS_NAME, "cloneData", cloneData);
-        core.Guards.object(EngineCore._CLASS_NAME, "cloneData.config", cloneData.config);
-        core.Guards.object(EngineCore._CLASS_NAME, "cloneData.state", cloneData.state);
-        core.Guards.array(EngineCore._CLASS_NAME, "cloneData.typeInitialisers", cloneData.typeInitialisers);
-        this._loggerTypeName = cloneData.loggerTypeName;
-        this._skipBootstrap = true;
-        this._isClone = true;
-        if (silent ?? false) {
-            cloneData.config.silent = true;
-        }
-        this._context = {
-            config: cloneData.config,
-            registeredInstances: {},
-            componentInstances: [],
-            state: {},
-            stateDirty: false
-        };
-        this._typeInitialisers = cloneData.typeInitialisers;
-        for (const schemaName of Object.keys(cloneData.entitySchemas)) {
-            entity.EntitySchemaFactory.register(schemaName, () => cloneData.entitySchemas[schemaName]);
-        }
-        this._stateStorage = new MemoryStateStorage(true, cloneData.state);
-        this._isStarted = false;
-    }
-    /**
-     * Initialise the types from connector.
-     * @param typeKey The key for the default types.
-     * @param instanceMethod The function to initialise the instance.
-     * @internal
-     */
-    async initialiseTypeConfig(typeKey, typeConfig, module, method) {
-        if (core.Is.arrayValue(typeConfig)) {
-            const instanceMethod = await modules.ModuleHelper.getModuleEntry(module, method);
-            for (let i = 0; i < typeConfig.length; i++) {
-                const instanceType = instanceMethod(this, this._context, typeConfig[i], typeConfig[i].overrideInstanceType);
-                if (core.Is.stringValue(instanceType)) {
-                    this._context.registeredInstances[typeKey] ??= [];
-                    if (typeConfig[i].isDefault ?? false) {
-                        this._context.registeredInstances[typeKey].unshift({
-                            type: instanceType,
-                            features: typeConfig[i].features
-                        });
-                    }
-                    else {
-                        this._context.registeredInstances[typeKey].push({
-                            type: instanceType,
-                            features: typeConfig[i].features
-                        });
-                    }
-                }
-            }
-        }
-    }
-    /**
-     * Setup the engine logger.
-     * @internal
-     */
-    setupEngineLogger() {
-        const silent = this._context.config.silent ?? false;
-        const engineLoggerConnector = silent
-            ? new loggingModels.SilentLoggingConnector()
-            : new loggingConnectorConsole.ConsoleLoggingConnector({
-                config: {
-                    translateMessages: true,
-                    hideGroups: true
-                }
-            });
-        this._context.componentInstances.push({
-            instanceType: this._loggerTypeName,
-            component: engineLoggerConnector
-        });
-        loggingModels.LoggingConnectorFactory.register(this._loggerTypeName, () => engineLoggerConnector);
-        this._context.registeredInstances.loggingConnector = [
-            {
-                type: this._loggerTypeName
-            }
-        ];
-        const engineLoggerComponent = new loggingService.LoggingService({
-            loggingConnectorType: this._loggerTypeName
-        });
-        this._engineLoggingComponent = engineLoggerComponent;
-        core.ComponentFactory.register("logging-service", () => engineLoggerComponent);
-        this._context.registeredInstances.loggingComponent = [
-            {
-                type: "logging-service"
-            }
-        ];
-    }
-    /**
-     * Load the state.
-     * @returns True if the state was loaded and can continue.
-     * @internal
-     */
-    async stateLoad() {
-        if (this._stateStorage) {
-            try {
-                this._context.state = ((await this._stateStorage.load(this)) ?? {});
-                this._context.stateDirty = false;
-                return true;
-            }
-            catch (err) {
-                this.logError(core.BaseError.fromError(err));
-                return false;
-            }
-        }
-        return true;
-    }
-    /**
-     * Save the state.
-     * @returns True if the state was saved.
-     * @internal
-     */
-    async stateSave() {
-        if (this._stateStorage && !core.Is.empty(this._context.state) && this._context.stateDirty) {
-            try {
-                await this._stateStorage.save(this, this._context.state);
-                this._context.stateDirty = false;
-                return true;
-            }
-            catch (err) {
-                this.logError(core.BaseError.fromError(err));
-            }
-            return false;
-        }
-        return true;
-    }
-    /**
-     * Bootstrap the engine.
-     * @internal
-     */
-    async bootstrap() {
-        if (!this._skipBootstrap) {
-            this.logInfo(core.I18n.formatMessage(`${EngineCore._CLASS_NAME_CAMEL_CASE}.bootstrapStarted`));
-            // First bootstrap the components.
-            for (const instance of this._context.componentInstances) {
-                if (core.Is.function(instance.component.bootstrap)) {
-                    const instanceName = this.getInstanceName(instance);
-                    this.logInfo(core.I18n.formatMessage(`${EngineCore._CLASS_NAME_CAMEL_CASE}.bootstrapping`, {
-                        element: instanceName
-                    }));
-                    const bootstrapSuccess = await instance.component.bootstrap(this._loggerTypeName);
-                    // If the bootstrap method failed then throw an error
-                    if (!bootstrapSuccess) {
-                        throw new core.GeneralError(EngineCore._CLASS_NAME, "bootstrapFailed", {
-                            component: `${instance.component.CLASS_NAME}:${instance.instanceType}`
-                        });
-                    }
-                }
-            }
-            // Now perform any custom bootstrap operations
-            if (core.Is.function(this._customBootstrap)) {
-                await this._customBootstrap(this, this._context);
-            }
-            this.logInfo(core.I18n.formatMessage(`${EngineCore._CLASS_NAME_CAMEL_CASE}.bootstrapComplete`));
-        }
-    }
-    /**
-     * Get the instance name.
-     * @param instance The instance to get the name for.
-     * @param instance.instanceType The instance type.
-     * @param instance.component The component.
-     * @returns The instance name.
-     * @internal
-     */
-    getInstanceName(instance) {
-        return `${instance.component.CLASS_NAME}-${instance.instanceType}`;
-    }
-}
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Store state in a file.
- */
-class FileStateStorage {
-    /**
-     * Runtime name for the class.
-     */
-    CLASS_NAME = "FileStateStorage";
-    /**
-     * The filename to store the state.
-     * @internal
-     */
-    _filename;
-    /**
-     * Readonly mode state file is not updated.
-     * @internal
-     */
-    _readonlyMode;
-    /**
-     * Create a new instance of FileStateStorage.
-     * @param filename The filename to store the state.
-     * @param readonlyMode Whether the file is in read-only mode.
-     */
-    constructor(filename, readonlyMode = false) {
-        core.Guards.stringValue(this.CLASS_NAME, "filename", filename);
-        this._filename = filename;
-        this._readonlyMode = readonlyMode;
-    }
-    /**
-     * Method for loading the state.
-     * @param engineCore The engine core to load the state for.
-     * @returns The state of the engine or undefined if it doesn't exist.
-     */
-    async load(engineCore) {
-        try {
-            engineCore.logInfo(core.I18n.formatMessage(`${core.StringHelper.camelCase(this.CLASS_NAME)}.loading`, {
-                filename: this._filename
-            }));
-            if (await this.fileExists(this._filename)) {
-                const content = await promises.readFile(this._filename, "utf8");
-                return JSON.parse(content.toString());
-            }
-        }
-        catch (err) {
-            throw new core.GeneralError(this.CLASS_NAME, "loadingError", { filename: this._filename }, core.BaseError.fromError(err));
-        }
-    }
-    /**
-     * Method for saving the state.
-     * @param engineCore The engine core to save the state for.
-     * @param state The state of the engine to save.
-     * @returns Nothing.
-     */
-    async save(engineCore, state) {
-        if (!this._readonlyMode) {
-            try {
-                engineCore.logInfo(core.I18n.formatMessage(`${core.StringHelper.camelCase(this.CLASS_NAME)}.saving`, {
-                    filename: this._filename
-                }));
-                try {
-                    await promises.mkdir(path.dirname(this._filename), { recursive: true });
-                }
-                catch { }
-                await promises.writeFile(this._filename, JSON.stringify(state, undefined, "\t"), "utf8");
-            }
-            catch (err) {
-                throw new core.GeneralError(this.CLASS_NAME, "savingError", { filename: this._filename }, core.BaseError.fromError(err));
-            }
-        }
-    }
-    /**
-     * Does the specified file exist.
-     * @param filename The filename to check for existence.
-     * @returns True if the file exists.
-     * @internal
-     */
-    async fileExists(filename) {
-        try {
-            const stats = await promises.stat(filename);
-            return stats.isFile();
-        }
-        catch {
-            return false;
-        }
-    }
-}
-
-exports.EngineCore = EngineCore;
-exports.FileStateStorage = FileStateStorage;
-exports.MemoryStateStorage = MemoryStateStorage;