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

package/dist/esm/index.mjs

@@ -1,7 +1,9 @@
-import { I18n, StringHelper, Is, ObjectHelper, BaseError, GeneralError, ErrorHelper, Guards } from '@twin.org/core';
+import { isMainThread } from 'node:worker_threads';
+import { I18n, StringHelper, Is, Guards, BaseError, GeneralError, ErrorHelper, ComponentFactory } from '@twin.org/core';
 import { EntitySchemaFactory } from '@twin.org/entity';
 import { ConsoleLoggingConnector } from '@twin.org/logging-connector-console';
 import { SilentLoggingConnector, LoggingConnectorFactory } from '@twin.org/logging-models';
+import { LoggingService } from '@twin.org/logging-service';
 import { ModuleHelper } from '@twin.org/modules';
 import { readFile, mkdir, writeFile, stat } from 'node:fs/promises';
 import path from 'node:path';
@@ -67,13 +69,14 @@ class MemoryStateStorage {
  */
 class EngineCore {
     /**
-     * Name for the engine logger.
+     * Name for the engine logger, used for direct console logging.
      */
-    static LOGGER_TYPE_NAME = "engine";
+    static LOGGING_TYPE_NAME = "engine-logging-service";
     /**
      * Runtime name for the class.
+     * @internal
      */
-    CLASS_NAME = "EngineCore";
+    static _CLASS_NAME = "EngineCore";
     /**
      * The core context.
      */
@@ -84,20 +87,15 @@ class EngineCore {
      */
     _stateStorage;
     /**
-     * The logging connector for the engine.
+     * The logging component for the engine.
      * @internal
      */
-    _engineLoggingConnector;
+    _engineLoggingComponent;
     /**
      * Skip the bootstrap process.
      * @internal
      */
     _skipBootstrap;
-    /**
-     * The logger type name to use.
-     * @internal
-     */
-    _loggerTypeName;
     /**
      * The type initialisers.
      * @internal
@@ -108,6 +106,11 @@ class EngineCore {
      * @internal
      */
     _isStarted;
+    /**
+     * Is the engine a clone.
+     * @internal
+     */
+    _isClone;
     /**
      * Add type initialisers to the engine.
      * @internal
@@ -131,17 +134,17 @@ class EngineCore {
         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,
-            defaultTypes: {},
+            registeredInstances: {},
             componentInstances: [],
-            state: { componentStates: {} },
+            state: {},
             stateDirty: false
         };
         this._stateStorage = options.stateStorage;
         this._isStarted = false;
+        this._isClone = false;
         if (Is.function(this._populateTypeInitialisers)) {
             this._populateTypeInitialisers(this, this._context);
         }
@@ -149,19 +152,27 @@ class EngineCore {
     /**
      * 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 (!Is.empty(typeConfig)) {
-            this._typeInitialisers.push({
-                type,
-                typeConfig,
-                module,
-                method
-            });
-        }
+    addTypeInitialiser(type, module, method) {
+        Guards.stringValue(EngineCore._CLASS_NAME, "type", type);
+        Guards.stringValue(EngineCore._CLASS_NAME, "module", module);
+        Guards.stringValue(EngineCore._CLASS_NAME, "method", method);
+        this._typeInitialisers.push({
+            type,
+            module,
+            method
+        });
+    }
+    /**
+     * Get the type config for a specific type.
+     * @param type The type to get the config for.
+     * @returns The type config or undefined if not found.
+     */
+    getTypeConfig(type) {
+        Guards.stringValue(EngineCore._CLASS_NAME, "type", type);
+        return this._context.config.types?.[type];
     }
     /**
      * Start the engine core.
@@ -172,37 +183,30 @@ class EngineCore {
             return false;
         }
         this.setupEngineLogger();
-        this.logInfo(I18n.formatMessage("engineCore.starting"));
+        this.logInfo(I18n.formatMessage(`${"engineCore"}.starting`));
         if (this._context.config.debug) {
-            this.logInfo(I18n.formatMessage("engineCore.debuggingEnabled"));
+            this.logInfo(I18n.formatMessage(`${"engineCore"}.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);
+                for (const { type, module, method } of this._typeInitialisers) {
+                    await this.initialiseTypeConfig(type, module, method);
                 }
                 await this.bootstrap();
-                this.logInfo(I18n.formatMessage("engineCore.componentsStarting"));
+                this.logInfo(I18n.formatMessage(`${"engineCore"}.componentsStarting`));
                 for (const instance of this._context.componentInstances) {
                     if (Is.function(instance.component.start)) {
-                        const instanceName = this.getInstanceName(instance);
-                        this.logInfo(I18n.formatMessage("engineCore.componentStarting", {
+                        this.logInfo(I18n.formatMessage(`${"engineCore"}.componentStarting`, {
                             element: instance.instanceType
                         }));
-                        const componentState = this._context.state.componentStates[instanceName] ?? {};
-                        const lastState = ObjectHelper.clone(componentState);
-                        await instance.component.start(this._context.state.nodeIdentity, this._loggerTypeName, componentState);
-                        if (!ObjectHelper.equal(lastState, componentState)) {
-                            this._context.state.componentStates[instanceName] = componentState;
-                            this._context.stateDirty = true;
-                        }
+                        await instance.component.start(this._context.state.nodeIdentity, EngineCore.LOGGING_TYPE_NAME);
                     }
                 }
-                this.logInfo(I18n.formatMessage("engineCore.componentsComplete"));
+                this.logInfo(I18n.formatMessage(`${"engineCore"}.componentsComplete`));
             }
-            this.logInfo(I18n.formatMessage("engineCore.started"));
+            this.logInfo(I18n.formatMessage(`${"engineCore"}.started`));
             this._isStarted = true;
         }
         catch (err) {
@@ -221,39 +225,55 @@ class EngineCore {
      * @returns Nothing.
      */
     async stop() {
-        this.logInfo(I18n.formatMessage("engineCore.stopping"));
-        this.logInfo(I18n.formatMessage("engineCore.componentsStopping"));
+        this.logInfo(I18n.formatMessage(`${"engineCore"}.stopping`));
+        this.logInfo(I18n.formatMessage(`${"engineCore"}.componentsStopping`));
         for (const instance of this._context.componentInstances) {
             if (Is.function(instance.component.stop)) {
-                const instanceName = this.getInstanceName(instance);
-                const componentState = this._context.state.componentStates[instanceName] ?? {};
-                const lastState = ObjectHelper.clone(componentState);
-                this.logInfo(I18n.formatMessage("engineCore.componentStopping", { element: instance.instanceType }));
+                this.logInfo(I18n.formatMessage(`${"engineCore"}.componentStopping`, {
+                    element: instance.instanceType
+                }));
                 try {
-                    await instance.component.stop(this._context.state.nodeIdentity, this._loggerTypeName, componentState);
-                    if (!ObjectHelper.equal(lastState, componentState)) {
-                        this._context.state.componentStates[instanceName] = componentState;
-                        this._context.stateDirty = true;
-                    }
+                    await instance.component.stop(this._context.state.nodeIdentity, EngineCore.LOGGING_TYPE_NAME);
                 }
                 catch (err) {
-                    this.logError(new GeneralError(this.CLASS_NAME, "componentStopFailed", {
+                    this.logError(new GeneralError(EngineCore._CLASS_NAME, "componentStopFailed", {
                         component: instance.instanceType
                     }, BaseError.fromError(err)));
                 }
             }
         }
         await this.stateSave();
-        this.logInfo(I18n.formatMessage("engineCore.componentsStopped"));
-        this.logInfo(I18n.formatMessage("engineCore.stopped"));
+        this.logInfo(I18n.formatMessage(`${"engineCore"}.componentsStopped`));
+        this.logInfo(I18n.formatMessage(`${"engineCore"}.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 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._engineLoggingConnector?.log({
-            source: this.CLASS_NAME,
+        this._engineLoggingComponent?.log({
+            source: EngineCore._CLASS_NAME,
             level: "info",
             message
         });
@@ -271,8 +291,8 @@ class EngineCore {
             if (this._context.config.debug && Is.stringValue(formattedError.stack)) {
                 message += `\n${formattedError.stack}`;
             }
-            this._engineLoggingConnector?.log({
-                source: this.CLASS_NAME,
+            this._engineLoggingComponent?.log({
+                source: EngineCore._CLASS_NAME,
                 level: "error",
                 message
             });
@@ -293,11 +313,48 @@ class EngineCore {
         return this._context.state;
     }
     /**
-     * Get the types for the component.
-     * @returns The default types.
+     * Get all the registered instances.
+     * @returns The registered instances.
      */
-    getDefaultTypes() {
-        return this._context.defaultTypes;
+    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) {
+        Guards.stringValue(EngineCore._CLASS_NAME, "componentConnectorType", componentConnectorType);
+        const registeredType = this.getRegisteredInstanceTypeOptional(componentConnectorType, features);
+        if (!Is.stringValue(registeredType)) {
+            throw new 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 (Is.arrayValue(registeredTypes)) {
+            if (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.
@@ -313,8 +370,7 @@ class EngineCore {
             config: this._context.config,
             state: this._context.state,
             typeInitialisers: this._typeInitialisers,
-            entitySchemas,
-            loggerTypeName: this._loggerTypeName
+            entitySchemas
         };
         return cloneData;
     }
@@ -324,20 +380,20 @@ class EngineCore {
      * @param silent Should the clone be silent.
      */
     populateClone(cloneData, silent) {
-        Guards.object(this.CLASS_NAME, "cloneData", cloneData);
-        Guards.object(this.CLASS_NAME, "cloneData.config", cloneData.config);
-        Guards.object(this.CLASS_NAME, "cloneData.state", cloneData.state);
-        Guards.array(this.CLASS_NAME, "cloneData.typeInitialisers", cloneData.typeInitialisers);
-        this._loggerTypeName = cloneData.loggerTypeName;
+        Guards.object(EngineCore._CLASS_NAME, "cloneData", cloneData);
+        Guards.object(EngineCore._CLASS_NAME, "cloneData.config", cloneData.config);
+        Guards.object(EngineCore._CLASS_NAME, "cloneData.state", cloneData.state);
+        Guards.array(EngineCore._CLASS_NAME, "cloneData.typeInitialisers", cloneData.typeInitialisers);
         this._skipBootstrap = true;
+        this._isClone = true;
         if (silent ?? false) {
             cloneData.config.silent = true;
         }
         this._context = {
             config: cloneData.config,
-            defaultTypes: {},
+            registeredInstances: {},
             componentInstances: [],
-            state: { componentStates: {} },
+            state: {},
             stateDirty: false
         };
         this._typeInitialisers = cloneData.typeInitialisers;
@@ -353,14 +409,41 @@ class EngineCore {
      * @param instanceMethod The function to initialise the instance.
      * @internal
      */
-    async initialiseTypeConfig(typeKey, typeConfig, module, method) {
+    async initialiseTypeConfig(typeKey, module, method) {
+        const typeConfig = this._context.config.types?.[typeKey];
         if (Is.arrayValue(typeConfig)) {
             const instanceMethod = await ModuleHelper.getModuleEntry(module, method);
             for (let i = 0; i < typeConfig.length; i++) {
-                const instanceType = instanceMethod(this, this._context, typeConfig[i], typeConfig[i].overrideInstanceType);
-                if (Is.stringValue(instanceType) &&
-                    (Is.empty(this._context.defaultTypes[typeKey]) || typeConfig[i].isDefault)) {
-                    this._context.defaultTypes[typeKey] = instanceType;
+                this.logInfo(I18n.formatMessage("engineCore.configuring", {
+                    element: `${typeKey}: ${typeConfig[i].type}`
+                }));
+                const result = await instanceMethod(this, this._context, typeConfig[i]);
+                if (Is.stringValue(result.instanceType) && Is.object(result.component)) {
+                    const finalInstanceType = typeConfig[i].overrideInstanceType ?? result.instanceType;
+                    this._context.componentInstances.push({
+                        instanceType: finalInstanceType,
+                        component: result.component
+                    });
+                    result.factory?.register(finalInstanceType, () => result.component);
+                    this._context.registeredInstances[typeKey] ??= [];
+                    if (typeConfig[i].isDefault ?? false) {
+                        this._context.registeredInstances[typeKey].unshift({
+                            type: finalInstanceType,
+                            features: typeConfig[i].features
+                        });
+                    }
+                    else {
+                        this._context.registeredInstances[typeKey].push({
+                            type: finalInstanceType,
+                            features: typeConfig[i].features
+                        });
+                    }
+                }
+                else {
+                    throw new GeneralError("engineCore", "componentUnknownType", {
+                        type: typeConfig[i].type,
+                        componentType: typeKey
+                    });
                 }
             }
         }
@@ -371,7 +454,7 @@ class EngineCore {
      */
     setupEngineLogger() {
         const silent = this._context.config.silent ?? false;
-        const engineLogger = silent
+        const engineLoggerConnector = silent
             ? new SilentLoggingConnector()
             : new ConsoleLoggingConnector({
                 config: {
@@ -380,12 +463,25 @@ class EngineCore {
                 }
             });
         this._context.componentInstances.push({
-            instanceType: this._loggerTypeName,
-            component: engineLogger
+            instanceType: EngineCore.LOGGING_TYPE_NAME,
+            component: engineLoggerConnector
         });
-        LoggingConnectorFactory.register(this._loggerTypeName, () => engineLogger);
-        this._engineLoggingConnector = engineLogger;
-        this._context.defaultTypes.loggingConnector = this._loggerTypeName;
+        LoggingConnectorFactory.register(EngineCore.LOGGING_TYPE_NAME, () => engineLoggerConnector);
+        this._context.registeredInstances.loggingConnector = [
+            {
+                type: EngineCore.LOGGING_TYPE_NAME
+            }
+        ];
+        const engineLoggerComponent = new LoggingService({
+            loggingConnectorType: EngineCore.LOGGING_TYPE_NAME
+        });
+        this._engineLoggingComponent = engineLoggerComponent;
+        ComponentFactory.register(EngineCore.LOGGING_TYPE_NAME, () => engineLoggerComponent);
+        this._context.registeredInstances.loggingComponent = [
+            {
+                type: EngineCore.LOGGING_TYPE_NAME
+            }
+        ];
     }
     /**
      * Load the state.
@@ -395,10 +491,7 @@ class EngineCore {
     async stateLoad() {
         if (this._stateStorage) {
             try {
-                this._context.state = ((await this._stateStorage.load(this)) ?? {
-                    componentStates: {}
-                });
-                this._context.state.componentStates ??= {};
+                this._context.state = ((await this._stateStorage.load(this)) ?? {});
                 this._context.stateDirty = false;
                 return true;
             }
@@ -434,34 +527,28 @@ class EngineCore {
      */
     async bootstrap() {
         if (!this._skipBootstrap) {
-            this.logInfo(I18n.formatMessage("engineCore.bootstrapStarted"));
+            this.logInfo(I18n.formatMessage(`${"engineCore"}.bootstrapStarted`));
             // First bootstrap the components.
             for (const instance of this._context.componentInstances) {
                 if (Is.function(instance.component.bootstrap)) {
                     const instanceName = this.getInstanceName(instance);
-                    this.logInfo(I18n.formatMessage("engineCore.bootstrapping", {
+                    this.logInfo(I18n.formatMessage(`${"engineCore"}.bootstrapping`, {
                         element: instanceName
                     }));
-                    const componentState = this._context.state.componentStates[instanceName] ?? {};
-                    const lastState = ObjectHelper.clone(componentState);
-                    const bootstrapSuccess = await instance.component.bootstrap(this._loggerTypeName, componentState);
+                    const bootstrapSuccess = await instance.component.bootstrap(EngineCore.LOGGING_TYPE_NAME);
                     // If the bootstrap method failed then throw an error
                     if (!bootstrapSuccess) {
-                        throw new GeneralError(this.CLASS_NAME, "bootstrapFailed", {
+                        throw new GeneralError(EngineCore._CLASS_NAME, "bootstrapFailed", {
                             component: `${instance.component.CLASS_NAME}:${instance.instanceType}`
                         });
                     }
-                    if (!ObjectHelper.equal(lastState, componentState)) {
-                        this._context.state.componentStates[instanceName] = componentState;
-                        this._context.stateDirty = true;
-                    }
                 }
             }
             // Now perform any custom bootstrap operations
             if (Is.function(this._customBootstrap)) {
                 await this._customBootstrap(this, this._context);
             }
-            this.logInfo(I18n.formatMessage("engineCore.bootstrapComplete"));
+            this.logInfo(I18n.formatMessage(`${"engineCore"}.bootstrapComplete`));
         }
     }
     /**
@@ -566,4 +653,48 @@ class FileStateStorage {
     }
 }
 
-export { EngineCore, FileStateStorage, MemoryStateStorage };
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Helper class for engine modules.
+ */
+class EngineModuleHelper {
+    /**
+     * Runtime name for the class.
+     */
+    static CLASS_NAME = "EngineModuleHelper";
+    /**
+     * Loads an engine component and constructs it with the relevant dependencies and configuration.
+     * @param engineCore The engine core.
+     * @param engineModuleConfig The configuration for the module.
+     * @returns The instantiated component.
+     */
+    static async loadComponent(engineCore, engineModuleConfig) {
+        const moduleClass = await ModuleHelper.getModuleEntry(engineModuleConfig.moduleName, engineModuleConfig.className);
+        const isClass = Is.class(moduleClass);
+        if (!isClass) {
+            throw new GeneralError(EngineModuleHelper.CLASS_NAME, "moduleNotClass", {
+                moduleName: engineModuleConfig.moduleName,
+                className: engineModuleConfig.className
+            });
+        }
+        const constructorOptions = {};
+        if (Is.arrayValue(engineModuleConfig.dependencies)) {
+            for (const dependency of engineModuleConfig.dependencies) {
+                if (dependency.isOptional ?? false) {
+                    constructorOptions[dependency.propertyName] = engineCore.getRegisteredInstanceType(dependency.componentName, dependency.features);
+                }
+                else {
+                    constructorOptions[dependency.propertyName] =
+                        engineCore.getRegisteredInstanceTypeOptional(dependency.componentName, dependency.features);
+                }
+            }
+        }
+        if (Is.object(engineModuleConfig.config)) {
+            constructorOptions.config = engineModuleConfig.config;
+        }
+        return new moduleClass(constructorOptions);
+    }
+}
+
+export { EngineCore, EngineModuleHelper, FileStateStorage, MemoryStateStorage };

package/dist/types/engineCore.d.ts

@@ -6,13 +6,9 @@ import type { IEngineCoreOptions } from "./models/IEngineCoreOptions";
  */
 export declare class EngineCore<C extends IEngineCoreConfig = IEngineCoreConfig, S extends IEngineState = IEngineState> implements IEngineCore<C, S> {
     /**
-     * Name for the engine logger.
+     * Name for the engine logger, used for direct console logging.
      */
-    static readonly LOGGER_TYPE_NAME: string;
-    /**
-     * Runtime name for the class.
-     */
-    readonly CLASS_NAME: string;
+    static readonly LOGGING_TYPE_NAME: string;
     /**
      * The core context.
      */
@@ -25,11 +21,16 @@ export declare class EngineCore<C extends IEngineCoreConfig = IEngineCoreConfig,
     /**
      * 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: string, typeConfig: IEngineCoreTypeConfig[] | undefined, module: string, method: string): void;
+    addTypeInitialiser(type: string, module: string, method: string): void;
+    /**
+     * Get the type config for a specific type.
+     * @param type The type to get the config for.
+     * @returns The type config or undefined if not found.
+     */
+    getTypeConfig(type: string): IEngineCoreTypeConfig[] | undefined;
     /**
      * Start the engine core.
      * @returns True if the start was successful.
@@ -40,6 +41,21 @@ export declare class EngineCore<C extends IEngineCoreConfig = IEngineCoreConfig,
      * @returns Nothing.
      */
     stop(): Promise<void>;
+    /**
+     * Is the engine started.
+     * @returns True if the engine is started.
+     */
+    isStarted(): boolean;
+    /**
+     * Is this the primary engine instance.
+     * @returns True if the engine is the primary instance.
+     */
+    isPrimary(): boolean;
+    /**
+     * Is this engine instance a clone.
+     * @returns True if the engine instance is a clone.
+     */
+    isClone(): boolean;
     /**
      * Log info.
      * @param message The message to log.
@@ -61,12 +77,30 @@ export declare class EngineCore<C extends IEngineCoreConfig = IEngineCoreConfig,
      */
     getState(): S;
     /**
-     * Get the types for the component.
-     * @returns The default types.
+     * Get all the registered instances.
+     * @returns The registered instances.
      */
-    getDefaultTypes(): {
-        [type: string]: string;
+    getRegisteredInstances(): {
+        [name: string]: {
+            type: string;
+            features?: string[];
+        }[];
     };
+    /**
+     * 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: string, features?: string[]): string;
+    /**
+     * 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: string, features?: string[]): string | undefined;
     /**
      * Get the data required to create a clone of the engine.
      * @returns The clone data.

package/dist/types/index.d.ts

@@ -2,3 +2,4 @@ export * from "./engineCore";
 export * from "./models/IEngineCoreOptions";
 export * from "./storage/fileStateStorage";
 export * from "./storage/memoryStateStorage";
+export * from "./utils/engineModuleHelper";

package/dist/types/models/IEngineCoreOptions.d.ts

@@ -23,9 +23,4 @@ export interface IEngineCoreOptions<C extends IEngineCoreConfig = IEngineCoreCon
      * Custom bootstrap method for the engine.
      */
     customBootstrap?: (engineCore: IEngineCore<C, S>, context: IEngineCoreContext<C, S>) => Promise<void>;
-    /**
-     * The name of the logger to use in the engine.
-     * @default engine
-     */
-    loggerTypeName?: string;
 }

package/dist/types/utils/engineModuleHelper.d.ts

@@ -0,0 +1,17 @@
+import type { IEngineCore, IEngineModuleConfig } from "@twin.org/engine-models";
+/**
+ * Helper class for engine modules.
+ */
+export declare class EngineModuleHelper {
+    /**
+     * Runtime name for the class.
+     */
+    static readonly CLASS_NAME: string;
+    /**
+     * Loads an engine component and constructs it with the relevant dependencies and configuration.
+     * @param engineCore The engine core.
+     * @param engineModuleConfig The configuration for the module.
+     * @returns The instantiated component.
+     */
+    static loadComponent<T>(engineCore: IEngineCore, engineModuleConfig: IEngineModuleConfig): Promise<T>;
+}