@twin.org/engine-core 0.0.1-next.1 → 0.0.1-next.11

package/dist/cjs/index.cjs

@@ -1,5 +1,6 @@
 'use strict';
 
+var path = require('node:path');
 var core = require('@twin.org/core');
 var engineModels = require('@twin.org/engine-models');
 var entityStorageConnectorCosmosdb = require('@twin.org/entity-storage-connector-cosmosdb');
@@ -103,7 +104,11 @@ function initialiseEntityStorageConnector(engineCore, context, typeCustom, schem
     else if (type === engineModels.EntityStorageConnectorType.File) {
         entityStorageConnector = new entityStorageConnectorFile.FileEntityStorageConnector({
             entitySchema: schema,
-            ...entityStorageConfig.options
+            ...entityStorageConfig.options,
+            config: {
+                ...entityStorageConfig.options.config,
+                directory: path.join(entityStorageConfig.options.config.directory, instanceName)
+            }
         });
     }
     else if (type === engineModels.EntityStorageConnectorType.AwsDynamoDb) {
@@ -436,7 +441,9 @@ function initialiseBlobStorageConnector(engineCore, context, instanceConfig, ove
             ...instanceConfig.options,
             config: {
                 ...instanceConfig.options.config,
-                directory: `${instanceConfig.options.storagePrefix ?? ""}${instanceConfig.options.config.directory}`
+                directory: core.Is.stringValue(instanceConfig.options.storagePrefix)
+                    ? path.join(instanceConfig.options.config.directory, instanceConfig.options.storagePrefix)
+                    : instanceConfig.options.config.directory
             }
         });
         instanceType = blobStorageConnectorFile.FileBlobStorageConnector.NAMESPACE;
@@ -598,6 +605,7 @@ function initialiseIdentityConnector(engineCore, context, instanceConfig, overri
     if (type === engineModels.IdentityConnectorType.Iota) {
         const dltConfig = context.config.dltConfig?.find(dlt => dlt.type === context.defaultTypes.dltConfig);
         connector = new identityConnectorIota.IotaIdentityConnector({
+            vaultConnectorType: context.defaultTypes.vaultConnector,
             ...instanceConfig.options,
             config: {
                 ...dltConfig?.options?.config,
@@ -800,6 +808,7 @@ function initialiseImmutableStorageConnector(engineCore, context, instanceConfig
     if (type === engineModels.ImmutableStorageConnectorType.Iota) {
         const dltConfig = context.config.dltConfig?.find(dlt => dlt.type === context.defaultTypes.dltConfig);
         connector = new immutableStorageConnectorIota.IotaImmutableStorageConnector({
+            vaultConnectorType: context.defaultTypes.vaultConnector,
             ...instanceConfig.options,
             config: {
                 ...dltConfig?.options?.config,
@@ -933,6 +942,7 @@ function initialiseNftConnector(engineCore, context, instanceConfig, overrideIns
     }
     else if (type === engineModels.NftConnectorType.Iota) {
         connector = new nftConnectorIota.IotaNftConnector({
+            vaultConnectorType: context.defaultTypes.vaultConnector,
             ...instanceConfig.options
         });
         instanceType = nftConnectorIota.IotaNftConnector.NAMESPACE;
@@ -1122,6 +1132,8 @@ function initialiseWalletConnector(engineCore, context, instanceConfig, override
     if (type === engineModels.WalletConnectorType.Iota) {
         const dltConfig = context.config.dltConfig?.find(dlt => dlt.type === context.defaultTypes.dltConfig);
         connector = new walletConnectorIota.IotaWalletConnector({
+            vaultConnectorType: context.defaultTypes.vaultConnector,
+            faucetConnectorType: context.defaultTypes.faucetConnector,
             ...instanceConfig.options,
             config: {
                 ...dltConfig?.options?.config,
@@ -1216,6 +1228,11 @@ class EngineCore {
      * @internal
      */
     _typeInitialisers;
+    /**
+     * Is the engine started.
+     * @internal
+     */
+    _isStarted;
     /**
      * Method for bootstrapping any data for the engine.
      * @internal
@@ -1241,6 +1258,7 @@ class EngineCore {
             stateDirty: false
         };
         this._stateStorage = options.stateStorage;
+        this._isStarted = false;
         this.addCoreTypeInitialisers();
     }
     /**
@@ -1260,19 +1278,23 @@ class EngineCore {
     }
     /**
      * Start the engine core.
-     * @returns Nothing.
+     * @returns True if the start was successful.
      */
     async start() {
+        if (this._isStarted) {
+            return false;
+        }
         this.setupEngineLogger();
         this.logInfo(core.I18n.formatMessage("engineCore.starting"));
         if (this._context.config.debug) {
             this.logInfo(core.I18n.formatMessage("engineCore.debuggingEnabled"));
         }
-        if (await this.stateLoad()) {
+        let canContinue = await this.stateLoad();
+        if (canContinue) {
             for (const { type, typeConfig, initialiser } of this._typeInitialisers) {
                 this.initialiseTypeConfig(type, typeConfig, initialiser);
             }
-            const canContinue = await this.bootstrap();
+            canContinue = await this.bootstrap();
             if (canContinue) {
                 this.logInfo(core.I18n.formatMessage("engineCore.componentsStarting"));
                 for (const instance of this._context.componentInstances) {
@@ -1284,7 +1306,11 @@ class EngineCore {
                 this.logInfo(core.I18n.formatMessage("engineCore.componentsComplete"));
             }
         }
-        this.logInfo(core.I18n.formatMessage("engineCore.started"));
+        if (canContinue) {
+            this.logInfo(core.I18n.formatMessage("engineCore.started"));
+            this._isStarted = true;
+        }
+        return canContinue;
     }
     /**
      * Stop the engine core.
@@ -1407,9 +1433,9 @@ class EngineCore {
     async stateLoad() {
         if (this._stateStorage) {
             try {
-                this._context.state = (await this._stateStorage.load(this)) ?? {
+                this._context.state = ((await this._stateStorage.load(this)) ?? {
                     bootstrappedComponents: []
-                };
+                });
                 this._context.state.bootstrappedComponents ??= [];
                 this._context.stateDirty = false;
                 return true;
@@ -1423,6 +1449,7 @@ class EngineCore {
     }
     /**
      * Save the state.
+     * @returns True if the state was saved.
      * @internal
      */
     async stateSave() {
@@ -1430,11 +1457,14 @@ class EngineCore {
             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.
@@ -1447,31 +1477,29 @@ class EngineCore {
             this.logInfo(core.I18n.formatMessage("engineCore.bootstrapStarted"));
             try {
                 // First bootstrap the components.
-                if (core.Is.arrayValue(this._context.state?.bootstrappedComponents)) {
-                    for (const instance of this._context.componentInstances) {
-                        if (core.Is.function(instance.component.bootstrap)) {
-                            const bootstrapName = `component-${instance.component.CLASS_NAME}-${instance.instanceType}`;
-                            if (!this._context.state.bootstrappedComponents.includes(bootstrapName)) {
-                                this.logInfo(core.I18n.formatMessage("engineCore.bootstrapping", {
-                                    element: bootstrapName
-                                }));
-                                const bootstrapSuccess = await instance.component.bootstrap(EngineCore.LOGGER_TYPE_NAME);
-                                // If the bootstrap method failed then throw an error
-                                if (!bootstrapSuccess) {
-                                    throw new core.GeneralError(this.CLASS_NAME, "bootstrapFailed", {
-                                        component: `${instance.component.CLASS_NAME}:${instance.instanceType}`
-                                    });
-                                }
-                                // Otherwise add the component to the bootstrapped list and set the state as dirty
-                                this._context.state.bootstrappedComponents.push(bootstrapName);
-                                this._context.stateDirty = true;
+                for (const instance of this._context.componentInstances) {
+                    if (core.Is.function(instance.component.bootstrap)) {
+                        const bootstrapName = `${instance.component.CLASS_NAME}-${instance.instanceType}`;
+                        if (!this._context.state.bootstrappedComponents.includes(bootstrapName)) {
+                            this.logInfo(core.I18n.formatMessage("engineCore.bootstrapping", {
+                                element: bootstrapName
+                            }));
+                            const bootstrapSuccess = await instance.component.bootstrap(EngineCore.LOGGER_TYPE_NAME);
+                            // If the bootstrap method failed then throw an error
+                            if (!bootstrapSuccess) {
+                                throw new core.GeneralError(this.CLASS_NAME, "bootstrapFailed", {
+                                    component: `${instance.component.CLASS_NAME}:${instance.instanceType}`
+                                });
                             }
+                            // Otherwise add the component to the bootstrapped list and set the state as dirty
+                            this._context.state.bootstrappedComponents.push(bootstrapName);
+                            this._context.stateDirty = true;
                         }
                     }
-                    // Now perform any custom bootstrap operations
-                    if (canContinue && core.Is.function(this._customBootstrap)) {
-                        await this._customBootstrap(this, this._context);
-                    }
+                }
+                // Now perform any custom bootstrap operations
+                if (canContinue && core.Is.function(this._customBootstrap)) {
+                    await this._customBootstrap(this, this._context);
                 }
             }
             catch (err) {
@@ -1479,7 +1507,7 @@ class EngineCore {
                 this.logError(core.BaseError.fromError(err));
             }
             finally {
-                await this.stateSave();
+                canContinue = await this.stateSave();
                 if (canContinue) {
                     this.logInfo(core.I18n.formatMessage("engineCore.bootstrapComplete"));
                 }
@@ -1580,7 +1608,11 @@ class FileStateStorage {
                 engineCore.logInfo(core.I18n.formatMessage(`${core.StringHelper.camelCase(this.CLASS_NAME)}.saving`, {
                     filename: this._filename
                 }));
-                await promises.writeFile(this._filename, JSON.stringify(state), "utf8");
+                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));
@@ -1656,7 +1688,534 @@ class MemoryStateStorage {
     }
 }
 
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Build the engine core configuration from environment variables.
+ * @param envVars The environment variables.
+ * @returns The config for the core.
+ */
+function buildEngineCoreConfiguration(envVars) {
+    envVars.stateFilename ??= "engine-state.json";
+    envVars.storageFileRoot = path.resolve(envVars.storageFileRoot);
+    envVars.stateFilename = path.join(envVars.storageFileRoot, envVars.stateFilename);
+    envVars.attestationAssertionMethodId ??= "attestation-assertion";
+    envVars.immutableProofHashKeyId ??= "immutable-proof-hash";
+    envVars.immutableProofAssertionMethodId ??= "immutable-proof-assertion";
+    envVars.blobStorageEnableEncryption ??= "false";
+    envVars.blobStorageEncryptionKey ??= "blob-encryption";
+    const coreConfig = {
+        debug: core.Coerce.boolean(envVars.debug) ?? false,
+        loggingConnector: [],
+        loggingComponent: [{ type: engineModels.LoggingComponentType.Service }],
+        entityStorageConnector: [],
+        blobStorageConnector: [],
+        blobStorageComponent: [
+            {
+                type: engineModels.BlobStorageComponentType.Service,
+                options: {
+                    config: {
+                        vaultKeyId: envVars.blobStorageEncryptionKey
+                    }
+                }
+            }
+        ],
+        backgroundTaskConnector: [],
+        telemetryConnector: [],
+        telemetryComponent: [{ type: engineModels.TelemetryComponentType.Service }],
+        vaultConnector: [],
+        walletConnector: [],
+        faucetConnector: [],
+        immutableStorageConnector: [],
+        nftConnector: [],
+        nftComponent: [{ type: engineModels.NftComponentType.Service }],
+        identityConnector: [],
+        identityComponent: [{ type: engineModels.IdentityComponentType.Service }],
+        identityProfileConnector: [],
+        identityProfileComponent: [{ type: engineModels.IdentityProfileComponentType.Service }],
+        immutableProofComponent: [
+            {
+                type: engineModels.ImmutableProofComponentType.Service,
+                options: {
+                    config: {
+                        assertionMethodId: envVars.immutableProofAssertionMethodId,
+                        proofHashKeyId: envVars.immutableProofHashKeyId
+                    }
+                }
+            }
+        ],
+        attestationConnector: [],
+        attestationComponent: [
+            {
+                type: engineModels.AttestationComponentType.Service
+            }
+        ],
+        auditableItemGraphComponent: [{ type: engineModels.AuditableItemGraphComponentType.Service }],
+        auditableItemStreamComponent: [{ type: engineModels.AuditableItemStreamComponentType.Service }]
+    };
+    configureEntityStorageConnectors(coreConfig, envVars);
+    configureBlobStorageConnectors(coreConfig, envVars);
+    configureVaultConnectors(coreConfig, envVars);
+    configureLogging(coreConfig, envVars);
+    configureBackgroundTaskConnectors(coreConfig, envVars);
+    configureTelemetryConnectors(coreConfig, envVars);
+    configureFaucetConnectors(coreConfig, envVars);
+    configureWalletConnectors(coreConfig, envVars);
+    configureNftConnectors(coreConfig, envVars);
+    configureImmutableStorageConnectors(coreConfig, envVars);
+    configureIdentityConnectors(coreConfig, envVars);
+    configureIdentityProfileConnectors(coreConfig, envVars);
+    configureAttestationConnectors(coreConfig, envVars);
+    return coreConfig;
+}
+/**
+ * Configures the entity storage connectors for the core.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ */
+function configureEntityStorageConnectors(coreConfig, envVars) {
+    coreConfig.entityStorageConnector ??= [];
+    if ((core.Coerce.boolean(envVars.entityMemoryEnable) ?? false) ||
+        envVars.blobStorageConnectorType === engineModels.EntityStorageConnectorType.Memory) {
+        coreConfig.entityStorageConnector.push({
+            type: engineModels.EntityStorageConnectorType.Memory
+        });
+    }
+    if ((core.Coerce.boolean(envVars.entityFileEnable) ?? false) ||
+        envVars.entityStorageConnectorType === engineModels.EntityStorageConnectorType.File) {
+        coreConfig.entityStorageConnector.push({
+            type: engineModels.EntityStorageConnectorType.File,
+            options: { config: { directory: envVars.storageFileRoot } }
+        });
+    }
+    if (core.Is.stringValue(envVars.awsDynamodbAccessKeyId)) {
+        coreConfig.entityStorageConnector.push({
+            type: engineModels.EntityStorageConnectorType.AwsDynamoDb,
+            options: {
+                config: {
+                    region: envVars.awsDynamodbRegion,
+                    accessKeyId: envVars.awsDynamodbAccessKeyId,
+                    secretAccessKey: envVars.awsDynamodbSecretAccessKey,
+                    endpoint: envVars.awsDynamodbEndpoint
+                },
+                tablePrefix: envVars.entityStorageTablePrefix
+            }
+        });
+    }
+    if (core.Is.stringValue(envVars.azureCosmosdbKey)) {
+        coreConfig.entityStorageConnector.push({
+            type: engineModels.EntityStorageConnectorType.AzureCosmosDb,
+            options: {
+                config: {
+                    endpoint: envVars.azureCosmosdbEndpoint,
+                    key: envVars.azureCosmosdbKey,
+                    databaseId: envVars.azureCosmosdbDatabaseId,
+                    containerId: envVars.azureCosmosdbContainerId
+                },
+                tablePrefix: envVars.entityStorageTablePrefix
+            }
+        });
+    }
+    if (core.Is.stringValue(envVars.gcpFirestoreCredentials)) {
+        coreConfig.entityStorageConnector.push({
+            type: engineModels.EntityStorageConnectorType.GcpFirestoreDb,
+            options: {
+                config: {
+                    projectId: envVars.gcpFirestoreProjectId,
+                    credentials: envVars.gcpFirestoreCredentials,
+                    databaseId: envVars.gcpFirestoreDatabaseId,
+                    collectionName: envVars.gcpFirestoreCollectionName,
+                    endpoint: envVars.gcpFirestoreApiEndpoint
+                },
+                tablePrefix: envVars.entityStorageTablePrefix
+            }
+        });
+    }
+    if (core.Is.stringValue(envVars.scylladbHosts)) {
+        coreConfig.entityStorageConnector.push({
+            type: engineModels.EntityStorageConnectorType.ScyllaDb,
+            options: {
+                config: {
+                    hosts: envVars.scylladbHosts.split(","),
+                    localDataCenter: envVars.scylladbLocalDataCenter,
+                    keyspace: envVars.scylladbKeyspace
+                },
+                tablePrefix: envVars.entityStorageTablePrefix
+            }
+        });
+    }
+    const defaultStorageConnector = envVars.entityStorageConnectorType;
+    if (core.Is.stringValue(defaultStorageConnector)) {
+        for (const config of coreConfig.entityStorageConnector) {
+            if (config.type === defaultStorageConnector) {
+                config.isDefault = true;
+            }
+        }
+    }
+}
+/**
+ * Configures the blob storage connectors for the core.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ */
+function configureBlobStorageConnectors(coreConfig, envVars) {
+    coreConfig.blobStorageConnector ??= [];
+    if ((core.Coerce.boolean(envVars.blobMemoryEnable) ?? false) ||
+        envVars.blobStorageConnectorType === engineModels.BlobStorageConnectorType.Memory) {
+        coreConfig.blobStorageConnector.push({
+            type: engineModels.BlobStorageConnectorType.Memory
+        });
+    }
+    if ((core.Coerce.boolean(envVars.blobFileEnable) ?? false) ||
+        envVars.blobStorageConnectorType === engineModels.BlobStorageConnectorType.File) {
+        coreConfig.blobStorageConnector.push({
+            type: engineModels.BlobStorageConnectorType.File,
+            options: {
+                config: { directory: path.join(envVars.storageFileRoot, "blob-storage") },
+                storagePrefix: envVars.blobStoragePrefix
+            }
+        });
+    }
+    if (core.Is.stringValue(envVars.ipfsApiUrl)) {
+        coreConfig.blobStorageConnector.push({
+            type: engineModels.BlobStorageConnectorType.Ipfs,
+            options: {
+                config: {
+                    apiUrl: envVars.ipfsApiUrl,
+                    bearerToken: envVars.ipfsBearerToken
+                }
+            }
+        });
+    }
+    if (core.Is.stringValue(envVars.awsS3AccessKeyId)) {
+        coreConfig.blobStorageConnector.push({
+            type: engineModels.BlobStorageConnectorType.AwsS3,
+            options: {
+                config: {
+                    region: envVars.awsS3Region,
+                    bucketName: envVars.awsS3BucketName,
+                    accessKeyId: envVars.awsS3AccessKeyId,
+                    secretAccessKey: envVars.awsS3SecretAccessKey,
+                    endpoint: envVars.awsS3Endpoint
+                },
+                storagePrefix: envVars.blobStoragePrefix
+            }
+        });
+    }
+    if (core.Is.stringValue(envVars.azureStorageAccountKey)) {
+        coreConfig.blobStorageConnector.push({
+            type: engineModels.BlobStorageConnectorType.AzureStorage,
+            options: {
+                config: {
+                    accountName: envVars.azureStorageAccountName,
+                    accountKey: envVars.azureStorageAccountKey,
+                    containerName: envVars.azureStorageContainerName,
+                    endpoint: envVars.azureStorageEndpoint
+                },
+                storagePrefix: envVars.blobStoragePrefix
+            }
+        });
+    }
+    if (core.Is.stringValue(envVars.gcpStorageCredentials)) {
+        coreConfig.blobStorageConnector.push({
+            type: engineModels.BlobStorageConnectorType.GcpStorage,
+            options: {
+                config: {
+                    projectId: envVars.gcpStorageProjectId,
+                    credentials: envVars.gcpStorageCredentials,
+                    bucketName: envVars.gcpStorageBucketName,
+                    apiEndpoint: envVars.gcpFirestoreApiEndpoint
+                },
+                storagePrefix: envVars.blobStoragePrefix
+            }
+        });
+    }
+    const defaultStorageConnectorType = envVars.blobStorageConnectorType;
+    if (core.Is.stringValue(defaultStorageConnectorType)) {
+        for (const config of coreConfig.blobStorageConnector) {
+            if (config.type === defaultStorageConnectorType) {
+                config.isDefault = true;
+            }
+        }
+    }
+}
+/**
+ * Configures the logging connectors for the core.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ */
+function configureLogging(coreConfig, envVars) {
+    const loggingConnectors = (envVars.loggingConnector ?? "").split(",");
+    for (const loggingConnector of loggingConnectors) {
+        if (loggingConnector === engineModels.LoggingConnectorType.Console) {
+            coreConfig.loggingConnector?.push({
+                type: engineModels.LoggingConnectorType.Console,
+                options: {
+                    config: {
+                        translateMessages: true,
+                        hideGroups: true
+                    }
+                }
+            });
+        }
+        else if (loggingConnector === engineModels.LoggingConnectorType.EntityStorage) {
+            coreConfig.loggingConnector?.push({
+                type: engineModels.LoggingConnectorType.EntityStorage
+            });
+        }
+    }
+    if (loggingConnectors.length > 1) {
+        coreConfig.loggingConnector?.push({
+            type: engineModels.LoggingConnectorType.Multi,
+            isDefault: true,
+            options: {
+                loggingConnectorTypes: loggingConnectors
+            }
+        });
+    }
+}
+/**
+ * Configures the vault connectors for the core.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ */
+function configureVaultConnectors(coreConfig, envVars) {
+    coreConfig.vaultConnector ??= [];
+    if (envVars.vaultConnector === engineModels.VaultConnectorType.EntityStorage) {
+        coreConfig.vaultConnector.push({
+            type: engineModels.VaultConnectorType.EntityStorage
+        });
+    }
+    else if (envVars.vaultConnector === engineModels.VaultConnectorType.Hashicorp) {
+        coreConfig.vaultConnector.push({
+            type: engineModels.VaultConnectorType.Hashicorp,
+            options: {
+                config: { endpoint: envVars.hashicorpVaultEndpoint, token: envVars.hashicorpVaultToken }
+            }
+        });
+    }
+}
+/**
+ * Configures the background task connectors for the core.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ */
+function configureBackgroundTaskConnectors(coreConfig, envVars) {
+    coreConfig.backgroundTaskConnector ??= [];
+    if (envVars.backgroundTaskConnector === engineModels.BackgroundTaskConnectorType.EntityStorage) {
+        coreConfig.backgroundTaskConnector.push({
+            type: engineModels.BackgroundTaskConnectorType.EntityStorage
+        });
+    }
+}
+/**
+ * Configures the telemetry connectors for the core.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ */
+function configureTelemetryConnectors(coreConfig, envVars) {
+    coreConfig.telemetryConnector ??= [];
+    if (envVars.telemetryConnector === engineModels.TelemetryConnectorType.EntityStorage) {
+        coreConfig.telemetryConnector.push({
+            type: engineModels.TelemetryConnectorType.EntityStorage
+        });
+    }
+}
+/**
+ * Configures the faucet connectors for the core.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ */
+function configureFaucetConnectors(coreConfig, envVars) {
+    coreConfig.faucetConnector ??= [];
+    if (envVars.faucetConnector === engineModels.FaucetConnectorType.EntityStorage) {
+        coreConfig.faucetConnector.push({
+            type: engineModels.FaucetConnectorType.EntityStorage
+        });
+    }
+    else if (envVars.faucetConnector === engineModels.FaucetConnectorType.Iota) {
+        coreConfig.faucetConnector.push({
+            type: engineModels.FaucetConnectorType.Iota,
+            options: {
+                config: {
+                    endpoint: envVars.iotaFaucetEndpoint,
+                    clientOptions: {
+                        nodes: [envVars.iotaNodeEndpoint]
+                    },
+                    bech32Hrp: envVars.iotaBech32Hrp,
+                    coinType: core.Coerce.number(envVars.iotaCoinType)
+                }
+            }
+        });
+    }
+}
+/**
+ * Configures the wallet connectors for the core.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ */
+function configureWalletConnectors(coreConfig, envVars) {
+    coreConfig.walletConnector ??= [];
+    if (envVars.walletConnector === engineModels.WalletConnectorType.EntityStorage) {
+        coreConfig.walletConnector.push({
+            type: engineModels.WalletConnectorType.EntityStorage
+        });
+    }
+    else if (envVars.walletConnector === engineModels.WalletConnectorType.Iota) {
+        coreConfig.walletConnector.push({
+            type: engineModels.WalletConnectorType.Iota,
+            options: {
+                config: {
+                    clientOptions: {
+                        nodes: [envVars.iotaNodeEndpoint]
+                    },
+                    bech32Hrp: envVars.iotaBech32Hrp,
+                    coinType: core.Coerce.number(envVars.iotaCoinType)
+                }
+            }
+        });
+    }
+}
+/**
+ * Configures the NFT connectors for the core.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ */
+function configureNftConnectors(coreConfig, envVars) {
+    coreConfig.nftConnector ??= [];
+    if (envVars.nftConnector === engineModels.NftConnectorType.EntityStorage) {
+        coreConfig.nftConnector.push({
+            type: engineModels.NftConnectorType.EntityStorage
+        });
+    }
+    else if (envVars.nftConnector === engineModels.NftConnectorType.Iota) {
+        coreConfig.nftConnector.push({
+            type: engineModels.NftConnectorType.Iota,
+            options: {
+                config: {
+                    clientOptions: {
+                        nodes: [envVars.iotaNodeEndpoint]
+                    },
+                    bech32Hrp: envVars.iotaBech32Hrp,
+                    coinType: core.Coerce.number(envVars.iotaCoinType)
+                }
+            }
+        });
+    }
+}
+/**
+ * Configures the immutable storage connectors for the core.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ */
+function configureImmutableStorageConnectors(coreConfig, envVars) {
+    coreConfig.immutableStorageConnector ??= [];
+    if (envVars.immutableStorageConnector === engineModels.ImmutableStorageConnectorType.EntityStorage) {
+        coreConfig.immutableStorageConnector.push({
+            type: engineModels.ImmutableStorageConnectorType.EntityStorage
+        });
+    }
+    else if (envVars.immutableStorageConnector === engineModels.ImmutableStorageConnectorType.Iota) {
+        coreConfig.immutableStorageConnector.push({
+            type: engineModels.ImmutableStorageConnectorType.Iota,
+            options: {
+                config: {
+                    clientOptions: {
+                        nodes: [envVars.iotaNodeEndpoint]
+                    },
+                    bech32Hrp: envVars.iotaBech32Hrp,
+                    coinType: core.Coerce.number(envVars.iotaCoinType)
+                }
+            }
+        });
+    }
+}
+/**
+ * Configures the identity connectors for the core.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ */
+function configureIdentityConnectors(coreConfig, envVars) {
+    coreConfig.identityConnector ??= [];
+    if (envVars.identityConnector === engineModels.IdentityConnectorType.EntityStorage) {
+        coreConfig.identityConnector.push({
+            type: engineModels.IdentityConnectorType.EntityStorage
+        });
+    }
+    else if (envVars.identityConnector === engineModels.IdentityConnectorType.Iota) {
+        coreConfig.identityConnector.push({
+            type: engineModels.IdentityConnectorType.Iota,
+            options: {
+                config: {
+                    clientOptions: {
+                        nodes: [envVars.iotaNodeEndpoint]
+                    },
+                    bech32Hrp: envVars.iotaBech32Hrp,
+                    coinType: core.Coerce.number(envVars.iotaCoinType)
+                }
+            }
+        });
+    }
+}
+/**
+ * Configures the identity profile connectors for the core.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ */
+function configureIdentityProfileConnectors(coreConfig, envVars) {
+    coreConfig.identityProfileConnector ??= [];
+    if (envVars.identityProfileConnector === engineModels.IdentityConnectorType.EntityStorage) {
+        coreConfig.identityProfileConnector.push({
+            type: engineModels.IdentityProfileConnectorType.EntityStorage
+        });
+    }
+}
+/**
+ * Configures the attestation connectors for the core.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ */
+function configureAttestationConnectors(coreConfig, envVars) {
+    coreConfig.attestationConnector ??= [];
+    if (envVars.attestationConnector === engineModels.AttestationConnectorType.EntityStorage) {
+        coreConfig.attestationConnector.push({
+            type: engineModels.AttestationConnectorType.EntityStorage
+        });
+    }
+    else if (envVars.attestationConnector === engineModels.AttestationConnectorType.Iota) {
+        coreConfig.attestationConnector.push({
+            type: engineModels.AttestationConnectorType.Iota
+        });
+    }
+}
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Environment variable helper.
+ */
+class EnvHelper {
+    /**
+     * Get the environment variable as an object with camel cased names.
+     * @param envVars The environment variables.
+     * @param prefix The prefix of the environment variables.
+     * @returns The object with camel cased names.
+     */
+    static envToJson(envVars, prefix) {
+        const result = {};
+        for (const envVar in envVars) {
+            if (envVar.startsWith(prefix) && core.Is.stringValue(process.env[envVar])) {
+                const camelCaseName = core.StringHelper.camelCase(envVar.replace(prefix, "").toLowerCase());
+                core.ObjectHelper.propertySet(result, camelCaseName, process.env[envVar]);
+            }
+        }
+        return result;
+    }
+}
+
 exports.EngineCore = EngineCore;
+exports.EnvHelper = EnvHelper;
 exports.FileStateStorage = FileStateStorage;
 exports.MemoryStateStorage = MemoryStateStorage;
+exports.buildEngineCoreConfiguration = buildEngineCoreConfiguration;
 exports.initialiseEntityStorageConnector = initialiseEntityStorageConnector;