@twin.org/node-core 0.0.1-next.8 → 0.0.1

package/dist/esm/index.mjs

@@ -1,7 +1,7 @@
 import { PasswordHelper } from '@twin.org/api-auth-entity-storage-service';
-import { I18n, Is, Converter, RandomHelper, StringHelper, Coerce, Urn, GeneralError, EnvHelper, ErrorHelper } from '@twin.org/core';
+import { I18n, Is, Converter, RandomHelper, StringHelper, Coerce, Urn, GeneralError, ErrorHelper, EnvHelper } from '@twin.org/core';
 import { PasswordGenerator, Bip39 } from '@twin.org/crypto';
-import { WalletConnectorType, IdentityConnectorType, EntityStorageConnectorType, BlobStorageConnectorType } from '@twin.org/engine-types';
+import { WalletConnectorType, IdentityConnectorType, EntityStorageConnectorType, BlobStorageConnectorType, BlobStorageComponentType, VaultConnectorType, DltConfigType, LoggingConnectorType, LoggingComponentType, BackgroundTaskConnectorType, EventBusConnectorType, EventBusComponentType, TelemetryConnectorType, TelemetryComponentType, MessagingEmailConnectorType, MessagingSmsConnectorType, MessagingPushNotificationConnectorType, MessagingComponentType, FaucetConnectorType, NftConnectorType, NftComponentType, VerifiableStorageConnectorType, VerifiableStorageComponentType, ImmutableProofComponentType, AuditableItemGraphComponentType, AuditableItemStreamComponentType, IdentityComponentType, IdentityResolverConnectorType, IdentityResolverComponentType, IdentityProfileConnectorType, IdentityProfileComponentType, AttestationConnectorType, AttestationComponentType, DataConverterConnectorType, DataExtractorConnectorType, DataProcessingComponentType, DocumentManagementComponentType, FederatedCatalogueComponentType, RightsManagementPapComponentType, RightsManagementComponentType, TaskSchedulerComponentType } from '@twin.org/engine-types';
 import { EntityStorageConnectorFactory } from '@twin.org/entity-storage-models';
 import { IdentityProfileConnectorFactory, IdentityConnectorFactory, IdentityResolverConnectorFactory, DocumentHelper } from '@twin.org/identity-models';
 import { VaultConnectorFactory, VaultKeyType } from '@twin.org/vault-models';
@@ -9,10 +9,11 @@ import { WalletConnectorFactory } from '@twin.org/wallet-models';
 import { readFile, stat } from 'node:fs/promises';
 import path from 'node:path';
 import * as dotenv from 'dotenv';
-import { buildEngineConfiguration, Engine } from '@twin.org/engine';
+import { addDefaultRestPaths, addDefaultSocketPaths, EngineServer } from '@twin.org/engine-server';
+import { InformationComponentType, RestRouteProcessorType, SocketRouteProcessorType, AuthenticationAdminComponentType, AuthenticationComponentType } from '@twin.org/engine-server-types';
+import { Engine } from '@twin.org/engine';
 import { FileStateStorage } from '@twin.org/engine-core';
 import { EngineCoreFactory } from '@twin.org/engine-models';
-import { buildEngineServerConfiguration, EngineServer } from '@twin.org/engine-server';
 
 // Copyright 2024 IOTA Stiftung.
 // SPDX-License-Identifier: Apache-2.0.
@@ -70,6 +71,15 @@ async function fileExists(filename) {
         return false;
     }
 }
+/**
+ * Load the JSON file.
+ * @param filename The filename of the JSON file to load.
+ * @returns The contents of the JSON file or null if it could not be loaded.
+ */
+async function loadJsonFile(filename) {
+    const content = await readFile(filename, "utf8");
+    return JSON.parse(content);
+}
 /**
  * Get the features that are enabled on the node.
  * @param env The environment variables for the node.
@@ -134,7 +144,6 @@ async function bootstrapNodeIdentity(engineCore, context, envVars, features) {
             await finaliseWallet(engineCore, envVars, features, finalIdentity, addresses);
             await finaliseMnemonic(vaultConnector, workingIdentity, finalIdentity);
             context.state.nodeIdentity = finalIdentity;
-            context.state.addresses = addresses;
             context.stateDirty = true;
             engineCore.logInfo(I18n.formatMessage("node.nodeIdentity", {
                 identity: context.state.nodeIdentity
@@ -158,12 +167,13 @@ async function bootstrapIdentity(engineCore, envVars, features, nodeIdentity) {
     try {
         const identityResolverConnector = IdentityResolverConnectorFactory.get(engineDefaultTypes.identityResolverConnector);
         identityDocument = await identityResolverConnector.resolveDocument(nodeIdentity);
-        engineCore.logInfo(I18n.formatMessage("node.existingNodeIdentity"));
+        engineCore.logInfo(I18n.formatMessage("node.existingNodeIdentity", { identity: nodeIdentity }));
     }
     catch { }
     if (Is.empty(identityDocument)) {
         engineCore.logInfo(I18n.formatMessage("node.generatingNodeIdentity"));
         identityDocument = await identityConnector.createDocument(nodeIdentity);
+        engineCore.logInfo(I18n.formatMessage("node.createdNodeIdentity", { identity: identityDocument.id }));
     }
     if (engineDefaultTypes.identityConnector === IdentityConnectorType.Iota) {
         const didUrn = Urn.fromValidString(identityDocument.id);
@@ -288,7 +298,7 @@ async function bootstrapNodeUser(engineCore, context, envVars, features) {
             const email = envVars.username ?? DEFAULT_NODE_USERNAME;
             let nodeAdminUser = await authUserEntityStorage.get(email);
             if (Is.empty(nodeAdminUser)) {
-                engineCore.logInfo(I18n.formatMessage("node.creatingNodeUser"));
+                engineCore.logInfo(I18n.formatMessage("node.creatingNodeUser", { email }));
                 const generatedPassword = envVars.password ?? PasswordGenerator.generate(16);
                 const passwordBytes = Converter.utf8ToBytes(generatedPassword);
                 const saltBytes = RandomHelper.generate(16);
@@ -304,7 +314,7 @@ async function bootstrapNodeUser(engineCore, context, envVars, features) {
                 await authUserEntityStorage.set(nodeAdminUser);
             }
             else {
-                engineCore.logInfo(I18n.formatMessage("node.existingNodeUser"));
+                engineCore.logInfo(I18n.formatMessage("node.existingNodeUser", { email }));
                 // The user already exists, so double check the other details match
                 let needsUpdate = false;
                 if (nodeAdminUser.identity !== context.state.nodeIdentity) {
@@ -333,7 +343,7 @@ async function bootstrapNodeUser(engineCore, context, envVars, features) {
                 }
                 catch { }
                 if (Is.empty(userProfile)) {
-                    engineCore.logInfo(I18n.formatMessage("node.creatingUserProfile"));
+                    engineCore.logInfo(I18n.formatMessage("node.creatingUserProfile", { identity: context.state.nodeIdentity }));
                     const publicProfile = {
                         "@context": "https://schema.org",
                         "@type": "Person",
@@ -349,7 +359,7 @@ async function bootstrapNodeUser(engineCore, context, envVars, features) {
                     await identityProfileConnector.create(context.state.nodeIdentity, publicProfile, privateProfile);
                 }
                 else {
-                    engineCore.logInfo(I18n.formatMessage("node.existingUserProfile"));
+                    engineCore.logInfo(I18n.formatMessage("node.existingUserProfile", { identity: context.state.nodeIdentity }));
                 }
             }
         }
@@ -370,20 +380,25 @@ async function bootstrapAttestationMethod(engineCore, context, envVars, features
         const identityConnector = IdentityConnectorFactory.get(engineDefaultTypes.identityConnector);
         const identityResolverConnector = IdentityResolverConnectorFactory.get(engineDefaultTypes.identityResolverConnector);
         const identityDocument = await identityResolverConnector.resolveDocument(context.state.nodeIdentity);
+        const fullMethodId = `${identityDocument.id}#${envVars.attestationVerificationMethodId}`;
         let createVm = true;
         try {
-            DocumentHelper.getVerificationMethod(identityDocument, `${identityDocument.id}#${envVars.attestationVerificationMethodId}`, "assertionMethod");
+            DocumentHelper.getVerificationMethod(identityDocument, fullMethodId, "assertionMethod");
             createVm = false;
         }
         catch { }
         if (createVm) {
             // Add attestation verification method to DID, the correct node context is now in place
             // so the keys for the verification method will be stored correctly
-            engineCore.logInfo(I18n.formatMessage("node.addingAttestation"));
+            engineCore.logInfo(I18n.formatMessage("node.addingAttestation", {
+                methodId: fullMethodId
+            }));
             await identityConnector.addVerificationMethod(context.state.nodeIdentity, context.state.nodeIdentity, "assertionMethod", envVars.attestationVerificationMethodId);
         }
         else {
-            engineCore.logInfo(I18n.formatMessage("node.existingAttestation"));
+            engineCore.logInfo(I18n.formatMessage("node.existingAttestation", {
+                methodId: fullMethodId
+            }));
         }
     }
 }
@@ -402,20 +417,25 @@ async function bootstrapImmutableProofMethod(engineCore, context, envVars, featu
         const identityConnector = IdentityConnectorFactory.get(engineDefaultTypes.identityConnector);
         const identityResolverConnector = IdentityResolverConnectorFactory.get(engineDefaultTypes.identityResolverConnector);
         const identityDocument = await identityResolverConnector.resolveDocument(context.state.nodeIdentity);
+        const fullMethodId = `${identityDocument.id}#${envVars.immutableProofVerificationMethodId}`;
         let createVm = true;
         try {
-            DocumentHelper.getVerificationMethod(identityDocument, `${identityDocument.id}#${envVars.immutableProofVerificationMethodId}`, "assertionMethod");
+            DocumentHelper.getVerificationMethod(identityDocument, fullMethodId, "assertionMethod");
             createVm = false;
         }
         catch { }
         if (createVm) {
             // Add AIG verification method to DID, the correct node context is now in place
             // so the keys for the verification method will be stored correctly
-            engineCore.logInfo(I18n.formatMessage("node.addingImmutableProof"));
+            engineCore.logInfo(I18n.formatMessage("node.addingImmutableProof", {
+                methodId: fullMethodId
+            }));
             await identityConnector.addVerificationMethod(context.state.nodeIdentity, context.state.nodeIdentity, "assertionMethod", envVars.immutableProofVerificationMethodId);
         }
         else {
-            engineCore.logInfo(I18n.formatMessage("node.existingImmutableProof"));
+            engineCore.logInfo(I18n.formatMessage("node.existingImmutableProof", {
+                methodId: fullMethodId
+            }));
         }
     }
 }
@@ -439,11 +459,11 @@ async function bootstrapBlobEncryption(engineCore, context, envVars, features) {
         }
         catch { }
         if (Is.empty(existingKey)) {
-            engineCore.logInfo(I18n.formatMessage("node.creatingBlobEncryptionKey"));
-            await vaultConnector.createKey(`${context.state.nodeIdentity}/${envVars.blobStorageEncryptionKey}`, VaultKeyType.ChaCha20Poly1305);
+            engineCore.logInfo(I18n.formatMessage("node.creatingBlobEncryptionKey", { keyName }));
+            await vaultConnector.createKey(keyName, VaultKeyType.ChaCha20Poly1305);
         }
         else {
-            engineCore.logInfo(I18n.formatMessage("node.existingBlobEncryptionKey"));
+            engineCore.logInfo(I18n.formatMessage("node.existingBlobEncryptionKey", { keyName }));
         }
     }
 }
@@ -467,60 +487,1070 @@ async function bootstrapAuth(engineCore, context, envVars, features) {
         }
         catch { }
         if (Is.empty(existingKey)) {
-            engineCore.logInfo(I18n.formatMessage("node.creatingAuthKey"));
-            await vaultConnector.createKey(`${context.state.nodeIdentity}/${envVars.authSigningKeyId}`, VaultKeyType.Ed25519);
+            engineCore.logInfo(I18n.formatMessage("node.creatingAuthKey", { keyName }));
+            await vaultConnector.createKey(keyName, VaultKeyType.Ed25519);
         }
         else {
-            engineCore.logInfo(I18n.formatMessage("node.existingAuthKey"));
+            engineCore.logInfo(I18n.formatMessage("node.existingAuthKey", { keyName }));
         }
     }
 }
 
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
 /**
- * Start the engine server.
+ * Build the engine core configuration from environment variables.
+ * @param envVars The environment variables.
+ * @returns The config for the core.
+ */
+function buildEngineConfiguration(envVars) {
+    if (Is.stringValue(envVars.storageFileRoot)) {
+        envVars.stateFilename ??= "engine-state.json";
+        envVars.storageFileRoot = path.resolve(envVars.storageFileRoot);
+        envVars.stateFilename = path.join(envVars.storageFileRoot, envVars.stateFilename);
+    }
+    envVars.attestationVerificationMethodId ??= "attestation-assertion";
+    envVars.immutableProofVerificationMethodId ??= "immutable-proof-assertion";
+    envVars.blobStorageEnableEncryption ??= "false";
+    envVars.blobStorageEncryptionKey ??= "blob-encryption";
+    const coreConfig = {
+        debug: Coerce.boolean(envVars.debug) ?? false,
+        types: {}
+    };
+    configureEntityStorage(coreConfig, envVars);
+    configureBlobStorage(coreConfig, envVars);
+    configureVault(coreConfig, envVars);
+    configureDlt(coreConfig, envVars);
+    configureLogging(coreConfig, envVars);
+    configureBackgroundTask(coreConfig, envVars);
+    configureEventBus(coreConfig, envVars);
+    configureTelemetry(coreConfig, envVars);
+    configureMessaging(coreConfig, envVars);
+    configureFaucet(coreConfig, envVars);
+    configureWallet(coreConfig, envVars);
+    configureNft(coreConfig, envVars);
+    configureVerifiableStorage(coreConfig, envVars);
+    configureIdentity(coreConfig, envVars);
+    configureIdentityResolver(coreConfig, envVars);
+    configureIdentityProfile(coreConfig, envVars);
+    configureAttestation(coreConfig, envVars);
+    configureDataProcessing(coreConfig, envVars);
+    configureAuditableItemGraph(coreConfig);
+    configureAuditableItemStream(coreConfig);
+    configureDocumentManagement(coreConfig);
+    configureFederatedCatalogue(coreConfig, envVars);
+    configureRightsManagement(coreConfig, envVars);
+    configureTaskScheduler(coreConfig, envVars);
+    return coreConfig;
+}
+/**
+ * Helper function to get IOTA configuration from centralized dltConfig.
+ * @param coreConfig The core config.
+ * @returns The IOTA configuration if found, undefined otherwise.
+ */
+function getIotaConfig(coreConfig) {
+    const dltConfig = coreConfig.types.dltConfig?.find(config => config.type === DltConfigType.Iota && config.isDefault);
+    return dltConfig?.options?.config;
+}
+/**
+ * Configures the entity storage.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ */
+function configureEntityStorage(coreConfig, envVars) {
+    coreConfig.types ??= {};
+    coreConfig.types.entityStorageConnector ??= [];
+    if ((Coerce.boolean(envVars.entityMemoryEnable) ?? false) ||
+        envVars.entityStorageConnectorType === EntityStorageConnectorType.Memory) {
+        coreConfig.types.entityStorageConnector.push({
+            type: EntityStorageConnectorType.Memory
+        });
+    }
+    if ((Coerce.boolean(envVars.entityFileEnable) ?? false) ||
+        envVars.entityStorageConnectorType === EntityStorageConnectorType.File) {
+        coreConfig.types.entityStorageConnector.push({
+            type: EntityStorageConnectorType.File,
+            options: {
+                config: { directory: envVars.storageFileRoot ?? "" },
+                folderPrefix: envVars.entityStorageTablePrefix
+            }
+        });
+    }
+    if (Is.stringValue(envVars.awsDynamodbAccessKeyId)) {
+        coreConfig.types.entityStorageConnector.push({
+            type: EntityStorageConnectorType.AwsDynamoDb,
+            options: {
+                config: {
+                    region: envVars.awsDynamodbRegion ?? "",
+                    accessKeyId: envVars.awsDynamodbAccessKeyId ?? "",
+                    secretAccessKey: envVars.awsDynamodbSecretAccessKey ?? "",
+                    endpoint: envVars.awsDynamodbEndpoint ?? ""
+                },
+                tablePrefix: envVars.entityStorageTablePrefix
+            }
+        });
+    }
+    if (Is.stringValue(envVars.azureCosmosdbKey)) {
+        coreConfig.types.entityStorageConnector.push({
+            type: EntityStorageConnectorType.AzureCosmosDb,
+            options: {
+                config: {
+                    endpoint: envVars.azureCosmosdbEndpoint ?? "",
+                    key: envVars.azureCosmosdbKey ?? "",
+                    databaseId: envVars.azureCosmosdbDatabaseId ?? "",
+                    containerId: envVars.azureCosmosdbContainerId ?? ""
+                },
+                tablePrefix: envVars.entityStorageTablePrefix
+            }
+        });
+    }
+    if (Is.stringValue(envVars.gcpFirestoreCredentials)) {
+        coreConfig.types.entityStorageConnector.push({
+            type: EntityStorageConnectorType.GcpFirestoreDb,
+            options: {
+                config: {
+                    projectId: envVars.gcpFirestoreProjectId ?? "",
+                    credentials: envVars.gcpFirestoreCredentials ?? "",
+                    databaseId: envVars.gcpFirestoreDatabaseId ?? "",
+                    collectionName: envVars.gcpFirestoreCollectionName ?? "",
+                    endpoint: envVars.gcpFirestoreApiEndpoint ?? ""
+                },
+                tablePrefix: envVars.entityStorageTablePrefix
+            }
+        });
+    }
+    if (Is.stringValue(envVars.scylladbHosts)) {
+        coreConfig.types.entityStorageConnector.push({
+            type: EntityStorageConnectorType.ScyllaDb,
+            options: {
+                config: {
+                    hosts: envVars.scylladbHosts.split(",") ?? "",
+                    localDataCenter: envVars.scylladbLocalDataCenter ?? "",
+                    keyspace: envVars.scylladbKeyspace ?? ""
+                },
+                tablePrefix: envVars.entityStorageTablePrefix
+            }
+        });
+    }
+    if (Is.stringValue(envVars.mySqlHost)) {
+        coreConfig.types.entityStorageConnector.push({
+            type: EntityStorageConnectorType.MySqlDb,
+            options: {
+                config: {
+                    host: envVars.mySqlHost,
+                    port: envVars.mySqlPort ?? 3306,
+                    user: envVars.mySqlUser ?? "",
+                    password: envVars.mySqlPassword ?? "",
+                    database: envVars.mySqlDatabase ?? ""
+                },
+                tablePrefix: envVars.entityStorageTablePrefix
+            }
+        });
+    }
+    if (Is.stringValue(envVars.mySqlHost)) {
+        coreConfig.types.entityStorageConnector.push({
+            type: EntityStorageConnectorType.MySqlDb,
+            options: {
+                config: {
+                    host: envVars.mySqlHost,
+                    port: envVars.mySqlPort ?? 3306,
+                    user: envVars.mySqlUser ?? "",
+                    password: envVars.mySqlPassword ?? "",
+                    database: envVars.mySqlDatabase ?? ""
+                },
+                tablePrefix: envVars.entityStorageTablePrefix
+            }
+        });
+    }
+    if (Is.stringValue(envVars.mongoDbHost)) {
+        coreConfig.types.entityStorageConnector.push({
+            type: EntityStorageConnectorType.MongoDb,
+            options: {
+                config: {
+                    host: envVars.mongoDbHost,
+                    port: envVars.mongoDbPort,
+                    user: envVars.mongoDbUser ?? "",
+                    password: envVars.mongoDbPassword ?? "",
+                    database: envVars.mongoDbDatabase ?? ""
+                },
+                tablePrefix: envVars.entityStorageTablePrefix
+            }
+        });
+    }
+    if (Is.stringValue(envVars.postgreSqlHost)) {
+        coreConfig.types.entityStorageConnector.push({
+            type: EntityStorageConnectorType.PostgreSql,
+            options: {
+                config: {
+                    host: envVars.postgreSqlHost,
+                    port: envVars.postgreSqlPort,
+                    user: envVars.postgreSqlUser ?? "",
+                    password: envVars.postgreSqlPassword ?? "",
+                    database: envVars.postgreSqlDatabase ?? ""
+                },
+                tablePrefix: envVars.entityStorageTablePrefix
+            }
+        });
+    }
+    const defaultStorageConnector = envVars.entityStorageConnectorType;
+    if (Is.stringValue(defaultStorageConnector)) {
+        for (const config of coreConfig.types.entityStorageConnector) {
+            if (config.type === defaultStorageConnector) {
+                config.isDefault = true;
+            }
+        }
+    }
+}
+/**
+ * Configures the blob storage.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ */
+function configureBlobStorage(coreConfig, envVars) {
+    coreConfig.types.blobStorageConnector ??= [];
+    if ((Coerce.boolean(envVars.blobMemoryEnable) ?? false) ||
+        envVars.blobStorageConnectorType === BlobStorageConnectorType.Memory) {
+        coreConfig.types.blobStorageConnector.push({
+            type: BlobStorageConnectorType.Memory
+        });
+    }
+    if ((Coerce.boolean(envVars.blobFileEnable) ?? false) ||
+        envVars.blobStorageConnectorType === BlobStorageConnectorType.File) {
+        coreConfig.types.blobStorageConnector.push({
+            type: BlobStorageConnectorType.File,
+            options: {
+                config: {
+                    directory: Is.stringValue(envVars.storageFileRoot)
+                        ? path.join(envVars.storageFileRoot, "blob-storage")
+                        : ""
+                },
+                storagePrefix: envVars.blobStoragePrefix
+            }
+        });
+    }
+    if (Is.stringValue(envVars.ipfsApiUrl)) {
+        coreConfig.types.blobStorageConnector.push({
+            type: BlobStorageConnectorType.Ipfs,
+            options: {
+                config: {
+                    apiUrl: envVars.ipfsApiUrl,
+                    bearerToken: envVars.ipfsBearerToken
+                }
+            }
+        });
+    }
+    if (Is.stringValue(envVars.awsS3AccessKeyId)) {
+        coreConfig.types.blobStorageConnector.push({
+            type: BlobStorageConnectorType.AwsS3,
+            options: {
+                config: {
+                    region: envVars.awsS3Region ?? "",
+                    bucketName: envVars.awsS3BucketName ?? "",
+                    accessKeyId: envVars.awsS3AccessKeyId ?? "",
+                    secretAccessKey: envVars.awsS3SecretAccessKey ?? "",
+                    endpoint: envVars.awsS3Endpoint ?? ""
+                },
+                storagePrefix: envVars.blobStoragePrefix
+            }
+        });
+    }
+    if (Is.stringValue(envVars.azureStorageAccountKey)) {
+        coreConfig.types.blobStorageConnector.push({
+            type: BlobStorageConnectorType.AzureStorage,
+            options: {
+                config: {
+                    accountName: envVars.azureStorageAccountName ?? "",
+                    accountKey: envVars.azureStorageAccountKey ?? "",
+                    containerName: envVars.azureStorageContainerName ?? "",
+                    endpoint: envVars.azureStorageEndpoint ?? ""
+                },
+                storagePrefix: envVars.blobStoragePrefix
+            }
+        });
+    }
+    if (Is.stringValue(envVars.gcpStorageCredentials)) {
+        coreConfig.types.blobStorageConnector.push({
+            type: BlobStorageConnectorType.GcpStorage,
+            options: {
+                config: {
+                    projectId: envVars.gcpStorageProjectId ?? "",
+                    credentials: envVars.gcpStorageCredentials ?? "",
+                    bucketName: envVars.gcpStorageBucketName ?? "",
+                    apiEndpoint: envVars.gcpFirestoreApiEndpoint
+                },
+                storagePrefix: envVars.blobStoragePrefix
+            }
+        });
+    }
+    const defaultStorageConnectorType = envVars.blobStorageConnectorType;
+    if (Is.stringValue(defaultStorageConnectorType)) {
+        for (const config of coreConfig.types.blobStorageConnector) {
+            if (config.type === defaultStorageConnectorType) {
+                config.isDefault = true;
+            }
+        }
+    }
+    if (coreConfig.types.blobStorageConnector.length > 0) {
+        coreConfig.types.blobStorageComponent ??= [];
+        coreConfig.types.blobStorageComponent.push({
+            type: BlobStorageComponentType.Service,
+            options: {
+                config: {
+                    vaultKeyId: (envVars.blobStorageEnableEncryption ?? false)
+                        ? envVars.blobStorageEncryptionKey
+                        : undefined
+                }
+            }
+        });
+    }
+}
+/**
+ * Configures the logging.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ */
+function configureLogging(coreConfig, envVars) {
+    coreConfig.types.loggingConnector ??= [];
+    const loggingConnectors = (envVars.loggingConnector ?? "").split(",");
+    for (const loggingConnector of loggingConnectors) {
+        if (loggingConnector === LoggingConnectorType.Console) {
+            coreConfig.types.loggingConnector?.push({
+                type: LoggingConnectorType.Console,
+                options: {
+                    config: {
+                        translateMessages: true,
+                        hideGroups: true
+                    }
+                },
+                isDefault: loggingConnectors.length === 1
+            });
+        }
+        else if (loggingConnector === LoggingConnectorType.EntityStorage) {
+            coreConfig.types.loggingConnector?.push({
+                type: LoggingConnectorType.EntityStorage,
+                isDefault: loggingConnectors.length === 1
+            });
+        }
+    }
+    if (loggingConnectors.length > 1) {
+        coreConfig.types.loggingConnector?.push({
+            type: LoggingConnectorType.Multi,
+            isDefault: true,
+            options: {
+                loggingConnectorTypes: loggingConnectors
+            }
+        });
+    }
+    if (loggingConnectors.length > 0) {
+        coreConfig.types.loggingComponent ??= [];
+        coreConfig.types.loggingComponent.push({ type: LoggingComponentType.Service });
+    }
+}
+/**
+ * Configures the vault.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ */
+function configureVault(coreConfig, envVars) {
+    coreConfig.types.vaultConnector ??= [];
+    if (envVars.vaultConnector === VaultConnectorType.EntityStorage) {
+        coreConfig.types.vaultConnector.push({
+            type: VaultConnectorType.EntityStorage
+        });
+    }
+    else if (envVars.vaultConnector === VaultConnectorType.Hashicorp) {
+        coreConfig.types.vaultConnector.push({
+            type: VaultConnectorType.Hashicorp,
+            options: {
+                config: {
+                    endpoint: envVars.hashicorpVaultEndpoint ?? "",
+                    token: envVars.hashicorpVaultToken ?? ""
+                }
+            }
+        });
+    }
+}
+/**
+ * Configures the background task.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ */
+function configureBackgroundTask(coreConfig, envVars) {
+    coreConfig.types.backgroundTaskConnector ??= [];
+    if (envVars.backgroundTaskConnector === BackgroundTaskConnectorType.EntityStorage) {
+        coreConfig.types.backgroundTaskConnector.push({
+            type: BackgroundTaskConnectorType.EntityStorage
+        });
+    }
+}
+/**
+ * Configures the event bud.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ */
+function configureEventBus(coreConfig, envVars) {
+    coreConfig.types.eventBusConnector ??= [];
+    if (envVars.eventBusConnector === EventBusConnectorType.Local) {
+        coreConfig.types.eventBusConnector.push({
+            type: EventBusConnectorType.Local
+        });
+    }
+    if (coreConfig.types.eventBusConnector.length > 0) {
+        coreConfig.types.eventBusComponent ??= [];
+        coreConfig.types.eventBusComponent.push({ type: EventBusComponentType.Service });
+    }
+}
+/**
+ * Configures the telemetry.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ */
+function configureTelemetry(coreConfig, envVars) {
+    coreConfig.types.telemetryConnector ??= [];
+    if (envVars.telemetryConnector === TelemetryConnectorType.EntityStorage) {
+        coreConfig.types.telemetryConnector.push({
+            type: TelemetryConnectorType.EntityStorage
+        });
+    }
+    if (coreConfig.types.telemetryConnector.length > 0) {
+        coreConfig.types.telemetryComponent ??= [];
+        coreConfig.types.telemetryComponent.push({ type: TelemetryComponentType.Service });
+    }
+}
+/**
+ * Configures the messaging.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ */
+function configureMessaging(coreConfig, envVars) {
+    coreConfig.types.messagingEmailConnector ??= [];
+    coreConfig.types.messagingSmsConnector ??= [];
+    coreConfig.types.messagingPushNotificationConnector ??= [];
+    if (envVars.messagingEmailConnector === MessagingEmailConnectorType.EntityStorage) {
+        coreConfig.types.messagingEmailConnector.push({
+            type: MessagingEmailConnectorType.EntityStorage
+        });
+    }
+    else if (envVars.messagingEmailConnector === MessagingEmailConnectorType.Aws) {
+        coreConfig.types.messagingEmailConnector.push({
+            type: MessagingEmailConnectorType.Aws,
+            options: {
+                config: {
+                    region: envVars.awsS3Region ?? "",
+                    accessKeyId: envVars.awsS3AccessKeyId ?? "",
+                    secretAccessKey: envVars.awsS3SecretAccessKey ?? "",
+                    endpoint: envVars.awsS3Endpoint ?? ""
+                }
+            }
+        });
+    }
+    if (envVars.messagingSmsConnector === MessagingSmsConnectorType.EntityStorage) {
+        coreConfig.types.messagingSmsConnector.push({
+            type: MessagingSmsConnectorType.EntityStorage
+        });
+    }
+    else if (envVars.messagingSmsConnector === MessagingSmsConnectorType.Aws) {
+        coreConfig.types.messagingSmsConnector.push({
+            type: MessagingSmsConnectorType.Aws,
+            options: {
+                config: {
+                    region: envVars.awsS3Region ?? "",
+                    accessKeyId: envVars.awsS3AccessKeyId ?? "",
+                    secretAccessKey: envVars.awsS3SecretAccessKey ?? "",
+                    endpoint: envVars.awsS3Endpoint ?? ""
+                }
+            }
+        });
+    }
+    if (envVars.messagingPushNotificationConnector ===
+        MessagingPushNotificationConnectorType.EntityStorage) {
+        coreConfig.types.messagingPushNotificationConnector.push({
+            type: MessagingPushNotificationConnectorType.EntityStorage
+        });
+    }
+    else if (envVars.messagingPushNotificationConnector === MessagingPushNotificationConnectorType.Aws) {
+        coreConfig.types.messagingPushNotificationConnector.push({
+            type: MessagingPushNotificationConnectorType.Aws,
+            options: {
+                config: {
+                    region: envVars.awsS3Region ?? "",
+                    accessKeyId: envVars.awsS3AccessKeyId ?? "",
+                    secretAccessKey: envVars.awsS3SecretAccessKey ?? "",
+                    endpoint: envVars.awsS3Endpoint ?? "",
+                    applicationsSettings: Is.json(envVars.awsMessagingPushNotificationApplications)
+                        ? JSON.parse(envVars.awsMessagingPushNotificationApplications)
+                        : []
+                }
+            }
+        });
+    }
+    if (coreConfig.types.messagingEmailConnector.length > 0 ||
+        coreConfig.types.messagingSmsConnector.length > 0 ||
+        coreConfig.types.messagingPushNotificationConnector.length > 0) {
+        coreConfig.types.messagingComponent ??= [];
+        coreConfig.types.messagingComponent.push({ type: MessagingComponentType.Service });
+    }
+}
+/**
+ * Configures the faucet.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ */
+function configureFaucet(coreConfig, envVars) {
+    coreConfig.types.faucetConnector ??= [];
+    if (envVars.faucetConnector === FaucetConnectorType.EntityStorage) {
+        coreConfig.types.faucetConnector.push({
+            type: FaucetConnectorType.EntityStorage
+        });
+    }
+    else if (envVars.faucetConnector === FaucetConnectorType.Iota) {
+        const iotaConfig = getIotaConfig(coreConfig);
+        coreConfig.types.faucetConnector.push({
+            type: FaucetConnectorType.Iota,
+            options: {
+                config: {
+                    endpoint: envVars.iotaFaucetEndpoint ?? "",
+                    clientOptions: iotaConfig?.clientOptions ?? { url: "" },
+                    network: iotaConfig?.network ?? ""
+                }
+            }
+        });
+    }
+}
+/**
+ * Configures the wallet.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ */
+function configureWallet(coreConfig, envVars) {
+    coreConfig.types.walletConnector ??= [];
+    if (envVars.walletConnector === WalletConnectorType.EntityStorage) {
+        coreConfig.types.walletConnector.push({
+            type: WalletConnectorType.EntityStorage
+        });
+    }
+    else if (envVars.walletConnector === WalletConnectorType.Iota) {
+        const iotaConfig = getIotaConfig(coreConfig);
+        coreConfig.types.walletConnector.push({
+            type: WalletConnectorType.Iota,
+            options: {
+                config: iotaConfig ?? {}
+            }
+        });
+    }
+}
+/**
+ * Configures the NFT.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ */
+function configureNft(coreConfig, envVars) {
+    coreConfig.types.nftConnector ??= [];
+    if (envVars.nftConnector === NftConnectorType.EntityStorage) {
+        coreConfig.types.nftConnector.push({
+            type: NftConnectorType.EntityStorage
+        });
+    }
+    else if (envVars.nftConnector === NftConnectorType.Iota) {
+        const iotaConfig = getIotaConfig(coreConfig);
+        coreConfig.types.nftConnector.push({
+            type: NftConnectorType.Iota,
+            options: {
+                config: iotaConfig ?? {}
+            }
+        });
+    }
+    if (coreConfig.types.nftConnector.length > 0) {
+        coreConfig.types.nftComponent ??= [];
+        coreConfig.types.nftComponent.push({ type: NftComponentType.Service });
+    }
+}
+/**
+ * Configures the verifiable storage.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ */
+function configureVerifiableStorage(coreConfig, envVars) {
+    coreConfig.types.verifiableStorageConnector ??= [];
+    if (envVars.verifiableStorageConnector === VerifiableStorageConnectorType.EntityStorage) {
+        coreConfig.types.verifiableStorageConnector.push({
+            type: VerifiableStorageConnectorType.EntityStorage
+        });
+    }
+    else if (envVars.verifiableStorageConnector === VerifiableStorageConnectorType.Iota) {
+        const iotaConfig = getIotaConfig(coreConfig);
+        coreConfig.types.verifiableStorageConnector.push({
+            type: VerifiableStorageConnectorType.Iota,
+            options: {
+                config: iotaConfig ?? {}
+            }
+        });
+    }
+    if (coreConfig.types.verifiableStorageConnector.length > 0) {
+        coreConfig.types.verifiableStorageComponent ??= [];
+        coreConfig.types.verifiableStorageComponent.push({
+            type: VerifiableStorageComponentType.Service
+        });
+        coreConfig.types.immutableProofComponent ??= [];
+        coreConfig.types.immutableProofComponent.push({
+            type: ImmutableProofComponentType.Service,
+            options: {
+                config: {
+                    verificationMethodId: envVars.immutableProofVerificationMethodId
+                }
+            }
+        });
+        coreConfig.types.auditableItemGraphComponent ??= [];
+        coreConfig.types.auditableItemGraphComponent.push({
+            type: AuditableItemGraphComponentType.Service
+        });
+        coreConfig.types.auditableItemStreamComponent ??= [];
+        coreConfig.types.auditableItemStreamComponent.push({
+            type: AuditableItemStreamComponentType.Service
+        });
+    }
+}
+/**
+ * Configures the identity.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ */
+function configureIdentity(coreConfig, envVars) {
+    coreConfig.types.identityConnector ??= [];
+    if (envVars.identityConnector === IdentityConnectorType.EntityStorage) {
+        coreConfig.types.identityConnector.push({
+            type: IdentityConnectorType.EntityStorage
+        });
+    }
+    else if (envVars.identityConnector === IdentityConnectorType.Iota) {
+        const iotaConfig = getIotaConfig(coreConfig);
+        coreConfig.types.identityConnector.push({
+            type: IdentityConnectorType.Iota,
+            options: {
+                config: iotaConfig ?? {}
+            }
+        });
+    }
+    if (coreConfig.types.identityConnector.length > 0) {
+        coreConfig.types.identityComponent ??= [];
+        coreConfig.types.identityComponent.push({ type: IdentityComponentType.Service });
+    }
+}
+/**
+ * Configures the identity resolver.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ */
+function configureIdentityResolver(coreConfig, envVars) {
+    coreConfig.types.identityResolverConnector ??= [];
+    if (envVars.identityResolverConnector === IdentityResolverConnectorType.EntityStorage) {
+        coreConfig.types.identityResolverConnector.push({
+            type: IdentityResolverConnectorType.EntityStorage
+        });
+    }
+    else if (envVars.identityResolverConnector === IdentityResolverConnectorType.Iota) {
+        const iotaConfig = getIotaConfig(coreConfig);
+        coreConfig.types.identityResolverConnector.push({
+            type: IdentityResolverConnectorType.Iota,
+            options: {
+                config: iotaConfig ?? {}
+            }
+        });
+    }
+    else if (envVars.identityResolverConnector === IdentityResolverConnectorType.Universal) {
+        coreConfig.types.identityResolverConnector.push({
+            type: IdentityResolverConnectorType.Universal,
+            options: {
+                config: {
+                    endpoint: envVars.universalResolverEndpoint ?? ""
+                }
+            }
+        });
+    }
+    if (coreConfig.types.identityResolverConnector.length > 0) {
+        coreConfig.types.identityResolverComponent ??= [];
+        coreConfig.types.identityResolverComponent.push({
+            type: IdentityResolverComponentType.Service
+        });
+    }
+}
+/**
+ * Configures the identity profile.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ */
+function configureIdentityProfile(coreConfig, envVars) {
+    coreConfig.types.identityProfileConnector ??= [];
+    if (envVars.identityProfileConnector === IdentityConnectorType.EntityStorage) {
+        coreConfig.types.identityProfileConnector.push({
+            type: IdentityProfileConnectorType.EntityStorage
+        });
+    }
+    if (coreConfig.types.identityProfileConnector.length > 0) {
+        coreConfig.types.identityProfileComponent ??= [];
+        coreConfig.types.identityProfileComponent.push({ type: IdentityProfileComponentType.Service });
+    }
+}
+/**
+ * Configures the attestation.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ */
+function configureAttestation(coreConfig, envVars) {
+    coreConfig.types.attestationConnector ??= [];
+    if (envVars.attestationConnector === AttestationConnectorType.Nft) {
+        coreConfig.types.attestationConnector.push({
+            type: AttestationConnectorType.Nft
+        });
+    }
+    if (coreConfig.types.attestationConnector.length > 0) {
+        coreConfig.types.attestationComponent ??= [];
+        coreConfig.types.attestationComponent.push({
+            type: AttestationComponentType.Service,
+            options: {
+                config: {
+                    verificationMethodId: envVars.attestationVerificationMethodId
+                }
+            }
+        });
+    }
+}
+/**
+ * Configures the auditable item graph.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ */
+function configureAuditableItemGraph(coreConfig, envVars) {
+    if (Is.arrayValue(coreConfig.types.verifiableStorageConnector)) {
+        coreConfig.types.auditableItemGraphComponent ??= [];
+        coreConfig.types.auditableItemGraphComponent.push({
+            type: AuditableItemGraphComponentType.Service
+        });
+    }
+}
+/**
+ * Configures the auditable item stream.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ */
+function configureAuditableItemStream(coreConfig, envVars) {
+    if (Is.arrayValue(coreConfig.types.verifiableStorageConnector)) {
+        coreConfig.types.auditableItemStreamComponent ??= [];
+        coreConfig.types.auditableItemStreamComponent.push({
+            type: AuditableItemStreamComponentType.Service
+        });
+    }
+}
+/**
+ * Configures the data processing.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ */
+function configureDataProcessing(coreConfig, envVars) {
+    coreConfig.types.dataConverterConnector ??= [];
+    coreConfig.types.dataExtractorConnector ??= [];
+    const converterConnectors = envVars.dataConverterConnectors?.split(",") ?? [];
+    for (const converterConnector of converterConnectors) {
+        if (converterConnector === DataConverterConnectorType.Json) {
+            coreConfig.types.dataConverterConnector.push({
+                type: DataConverterConnectorType.Json
+            });
+        }
+        else if (converterConnector === DataConverterConnectorType.Xml) {
+            coreConfig.types.dataConverterConnector.push({
+                type: DataConverterConnectorType.Xml
+            });
+        }
+    }
+    const extractorConnectors = envVars.dataExtractorConnectors?.split(",") ?? [];
+    for (const extractorConnector of extractorConnectors) {
+        if (extractorConnector === DataExtractorConnectorType.JsonPath) {
+            coreConfig.types.dataExtractorConnector.push({
+                type: DataExtractorConnectorType.JsonPath
+            });
+        }
+    }
+    if (coreConfig.types.dataConverterConnector.length > 0 ||
+        coreConfig.types.dataExtractorConnector.length > 0) {
+        coreConfig.types.dataProcessingComponent ??= [];
+        coreConfig.types.dataProcessingComponent.push({ type: DataProcessingComponentType.Service });
+    }
+}
+/**
+ * Configures the document management.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ */
+function configureDocumentManagement(coreConfig, envVars) {
+    if (Is.arrayValue(coreConfig.types.auditableItemGraphComponent) &&
+        Is.arrayValue(coreConfig.types.blobStorageComponent) &&
+        Is.arrayValue(coreConfig.types.attestationComponent)) {
+        coreConfig.types.documentManagementComponent ??= [];
+        coreConfig.types.documentManagementComponent.push({
+            type: DocumentManagementComponentType.Service
+        });
+    }
+}
+/**
+ * Configures the federated catalogue.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ */
+function configureFederatedCatalogue(coreConfig, envVars) {
+    if (Is.arrayValue(coreConfig.types.identityResolverComponent)) {
+        coreConfig.types.federatedCatalogueComponent ??= [];
+        coreConfig.types.federatedCatalogueComponent.push({
+            type: FederatedCatalogueComponentType.Service,
+            options: {
+                config: {
+                    subResourceCacheTtlMs: Coerce.number(envVars.federatedCatalogueCacheTtlMs),
+                    clearingHouseApproverList: Coerce.object(envVars.federatedCatalogueClearingHouseApproverList) ?? []
+                }
+            }
+        });
+    }
+}
+/**
+ * Configures the rights management.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ */
+function configureRightsManagement(coreConfig, envVars) {
+    if (Coerce.boolean(envVars.rightsManagementEnabled) ?? false) {
+        coreConfig.types.rightsManagementPapComponent ??= [];
+        coreConfig.types.rightsManagementPapComponent.push({
+            type: RightsManagementPapComponentType.Service
+        });
+        coreConfig.types.rightsManagementComponent ??= [];
+        coreConfig.types.rightsManagementComponent.push({
+            type: RightsManagementComponentType.Service
+        });
+    }
+}
+/**
+ * Configures the task scheduler.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ */
+function configureTaskScheduler(coreConfig, envVars) {
+    if (Coerce.boolean(envVars.taskSchedulerEnabled) ?? true) {
+        coreConfig.types.taskSchedulerComponent ??= [];
+        coreConfig.types.taskSchedulerComponent.push({
+            type: TaskSchedulerComponentType.Default
+        });
+    }
+}
+/**
+ * Configures the DLT.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ */
+function configureDlt(coreConfig, envVars) {
+    // Create centralized DLT configuration for IOTA if essential IOTA variables are set
+    if (Is.stringValue(envVars.iotaNodeEndpoint) && Is.stringValue(envVars.iotaNetwork)) {
+        coreConfig.types.dltConfig ??= [];
+        const gasStationConfig = Is.stringValue(envVars.iotaGasStationEndpoint) &&
+            Is.stringValue(envVars.iotaGasStationAuthToken)
+            ? {
+                gasStationUrl: envVars.iotaGasStationEndpoint,
+                gasStationAuthToken: envVars.iotaGasStationAuthToken
+            }
+            : undefined;
+        coreConfig.types.dltConfig.push({
+            type: DltConfigType.Iota,
+            isDefault: true,
+            options: {
+                config: {
+                    clientOptions: {
+                        url: envVars.iotaNodeEndpoint ?? ""
+                    },
+                    network: envVars.iotaNetwork ?? "",
+                    coinType: Coerce.number(envVars.iotaCoinType),
+                    gasStation: gasStationConfig
+                }
+            }
+        });
+    }
+}
+
+/**
+ * Handles the configuration of the server.
+ * @param envVars The environment variables for the engine server.
+ * @param coreEngineConfig The core engine config.
  * @param serverInfo The server information.
- * @param envVarsPrefix The prefix for the environment variables.
+ * @param openApiSpecPath The path to the open api spec.
+ * @returns The the config for the core and the server.
+ */
+function buildEngineServerConfiguration(envVars, coreEngineConfig, serverInfo, openApiSpecPath) {
+    envVars.authSigningKeyId ??= "auth-signing";
+    const webServerOptions = {
+        port: Coerce.number(envVars.port),
+        host: Coerce.string(envVars.host),
+        methods: Is.stringValue(envVars.httpMethods)
+            ? envVars.httpMethods.split(",")
+            : undefined,
+        allowedHeaders: Is.stringValue(envVars.httpAllowedHeaders)
+            ? envVars.httpAllowedHeaders.split(",")
+            : undefined,
+        exposedHeaders: Is.stringValue(envVars.httpExposedHeaders)
+            ? envVars.httpExposedHeaders.split(",")
+            : undefined,
+        corsOrigins: Is.stringValue(envVars.corsOrigins) ? envVars.corsOrigins.split(",") : undefined
+    };
+    const serverConfig = {
+        ...coreEngineConfig,
+        web: webServerOptions,
+        types: {
+            ...coreEngineConfig.types,
+            informationComponent: [
+                {
+                    type: InformationComponentType.Service,
+                    options: {
+                        config: {
+                            serverInfo,
+                            openApiSpecPath
+                        }
+                    }
+                }
+            ]
+        }
+    };
+    if (Is.stringValue(envVars.mimeTypeProcessors)) {
+        const mimeTypeProcessors = envVars.mimeTypeProcessors.split(",");
+        if (Is.arrayValue(mimeTypeProcessors)) {
+            serverConfig.types.mimeTypeProcessor ??= [];
+            for (const mimeTypeProcessor of mimeTypeProcessors) {
+                serverConfig.types.mimeTypeProcessor.push({
+                    type: mimeTypeProcessor
+                });
+            }
+        }
+    }
+    serverConfig.types.restRouteProcessor ??= [];
+    serverConfig.types.socketRouteProcessor ??= [];
+    const disableNodeIdentity = Coerce.boolean(envVars.disableNodeIdentity);
+    if (!disableNodeIdentity) {
+        serverConfig.types.restRouteProcessor.push({
+            type: RestRouteProcessorType.NodeIdentity
+        });
+        serverConfig.types.socketRouteProcessor.push({
+            type: SocketRouteProcessorType.NodeIdentity
+        });
+    }
+    if (!coreEngineConfig.silent) {
+        serverConfig.types.restRouteProcessor.push({
+            type: RestRouteProcessorType.Logging,
+            options: {
+                config: {
+                    includeBody: coreEngineConfig.debug
+                }
+            }
+        });
+        serverConfig.types.socketRouteProcessor.push({
+            type: SocketRouteProcessorType.Logging,
+            options: {
+                config: {
+                    includeBody: coreEngineConfig.debug
+                }
+            }
+        });
+    }
+    serverConfig.types.restRouteProcessor.push({
+        type: RestRouteProcessorType.RestRoute,
+        options: {
+            config: {
+                includeErrorStack: coreEngineConfig.debug
+            }
+        }
+    });
+    serverConfig.types.socketRouteProcessor.push({
+        type: SocketRouteProcessorType.SocketRoute,
+        options: {
+            config: {
+                includeErrorStack: coreEngineConfig.debug
+            }
+        }
+    });
+    const authAdminProcessorType = envVars.authAdminProcessorType;
+    if (authAdminProcessorType === AuthenticationAdminComponentType.EntityStorage) {
+        serverConfig.types.authenticationAdminComponent ??= [];
+        serverConfig.types.authenticationAdminComponent.push({
+            type: AuthenticationAdminComponentType.EntityStorage,
+            options: {
+                config: {}
+            }
+        });
+    }
+    const authProcessorType = envVars.authProcessorType;
+    if (authProcessorType === AuthenticationComponentType.EntityStorage) {
+        serverConfig.types.authenticationComponent ??= [];
+        serverConfig.types.authenticationComponent.push({
+            type: AuthenticationComponentType.EntityStorage,
+            options: {
+                config: {
+                    signingKeyName: envVars.authSigningKeyId
+                }
+            }
+        });
+        serverConfig.types.restRouteProcessor.push({
+            type: RestRouteProcessorType.AuthHeader,
+            options: {
+                config: {
+                    signingKeyName: envVars.authSigningKeyId
+                }
+            }
+        });
+        serverConfig.types.socketRouteProcessor.push({
+            type: SocketRouteProcessorType.AuthHeader,
+            options: {
+                config: {
+                    signingKeyName: envVars.authSigningKeyId
+                }
+            }
+        });
+    }
+    addDefaultRestPaths(serverConfig);
+    addDefaultSocketPaths(serverConfig);
+    return serverConfig;
+}
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/* eslint-disable no-console */
+/**
+ * Start the engine server.
+ * @param nodeOptions Optional run options for the engine server.
+ * @param engineServerConfig The configuration for the engine server.
  * @param envVars The environment variables.
- * @param openApiSpecFile Path to the OpenAPI spec file.
- * @param stateStorage The state storage.
- * @param extendConfig Extends the engine configuration with any additional custom configuration.
- * @param extendEngine Extends the engine with any additional options.
- * @param extendEngineServer Extends the engine server with any additional options.
  * @returns The engine server.
  */
-async function start(serverInfo, envVarsPrefix, envVars, openApiSpecFile, stateStorage, extendConfig, extendEngine, extendEngineServer) {
+async function start(nodeOptions, engineServerConfig, envVars) {
     envVars.storageFileRoot ??= "";
     if ((envVars.entityStorageConnectorType === EntityStorageConnectorType.File ||
         envVars.blobStorageConnectorType === BlobStorageConnectorType.File ||
-        Is.empty(stateStorage)) &&
+        Is.empty(nodeOptions?.stateStorage)) &&
         !Is.stringValue(envVars.storageFileRoot)) {
         throw new GeneralError("node", "storageFileRootNotSet", {
-            storageFileRoot: `${envVarsPrefix}_STORAGE_FILE_ROOT`
+            storageFileRoot: `${nodeOptions?.envPrefix ?? ""}_STORAGE_FILE_ROOT`
         });
     }
-    // Build the engine configuration from the environment variables.
-    const engineConfig = buildEngineConfiguration(envVars);
-    // Extend the engine configuration with a custom type.
-    if (Is.function(extendConfig)) {
-        await extendConfig(engineConfig);
-    }
-    // Build the server configuration from the environment variables.
-    const serverConfig = buildEngineServerConfiguration(envVars, engineConfig, serverInfo, openApiSpecFile);
     // Create the engine instance using file state storage and custom bootstrap.
     const engine = new Engine({
-        config: { ...engineConfig, ...serverConfig },
-        stateStorage: stateStorage ?? new FileStateStorage(envVars.stateFilename ?? ""),
+        config: engineServerConfig,
+        stateStorage: nodeOptions?.stateStorage ?? new FileStateStorage(envVars.stateFilename ?? ""),
         customBootstrap: async (core, engineContext) => bootstrap(core, engineContext, envVars)
     });
     // Extend the engine.
-    if (Is.function(extendEngine)) {
-        await extendEngine(engine);
+    if (Is.function(nodeOptions?.extendEngine)) {
+        console.info("Extending Engine");
+        await nodeOptions.extendEngine(engine);
     }
     // Construct the server with the engine.
     const server = new EngineServer({ engineCore: engine });
     // Extend the engine server.
-    if (Is.function(extendEngineServer)) {
-        await extendEngineServer(server);
+    if (Is.function(nodeOptions?.extendEngineServer)) {
+        console.info("Extending Engine Server");
+        await nodeOptions?.extendEngineServer(server);
     }
     // Need to register the engine with the factory so that background tasks
     // can clone it to spawn new instances.
@@ -540,44 +1570,39 @@ async function start(serverInfo, envVarsPrefix, envVars, openApiSpecFile, stateS
 /* eslint-disable no-console */
 /**
  * Run the TWIN Node server.
- * @param options Optional configuration options for running the server.
+ * @param nodeOptions Optional configuration options for running the server.
  * @returns A promise that resolves when the server is started.
  */
-async function run(options) {
+async function run(nodeOptions) {
     try {
+        nodeOptions ??= {};
         const serverInfo = {
-            name: options?.serverName ?? "TWIN Node Server",
-            version: options?.serverVersion ?? "0.0.1-next.8" // x-release-please-version
+            name: nodeOptions?.serverName ?? "TWIN Node Server",
+            version: nodeOptions?.serverVersion ?? "0.0.1-next.11" // x-release-please-version
         };
         console.log(`\u001B[4m🌩️  ${serverInfo.name} v${serverInfo.version}\u001B[24m\n`);
-        const executionDirectory = options?.executionDirectory ?? getExecutionDirectory();
-        console.info("Execution Directory:", process.cwd());
-        await initialiseLocales(options?.localesDirectory ?? path.resolve(path.join(executionDirectory, "dist", "locales")));
-        if (Is.empty(options?.openApiSpecFile)) {
-            const specFile = path.resolve(path.join(executionDirectory, "docs", "open-api", "spec.json"));
+        if (!Is.stringValue(nodeOptions?.executionDirectory)) {
+            nodeOptions.executionDirectory = getExecutionDirectory();
+        }
+        console.info("Execution Directory:", nodeOptions.executionDirectory);
+        nodeOptions.localesDirectory =
+            nodeOptions?.localesDirectory ??
+                path.resolve(path.join(nodeOptions.executionDirectory, "dist", "locales"));
+        console.info("Locales Directory:", nodeOptions.localesDirectory);
+        await initialiseLocales(nodeOptions.localesDirectory);
+        if (Is.empty(nodeOptions?.openApiSpecFile)) {
+            const specFile = path.resolve(path.join(nodeOptions.executionDirectory, "docs", "open-api", "spec.json"));
             console.info("Default OpenAPI Spec File:", specFile);
             if (await fileExists(specFile)) {
-                options ??= {};
-                options.openApiSpecFile = specFile;
+                nodeOptions ??= {};
+                nodeOptions.openApiSpecFile = specFile;
             }
         }
-        if (Is.empty(options?.envFilenames)) {
-            const envFile = path.resolve(path.join(executionDirectory, ".env"));
-            console.info("Default Environment File:", envFile);
-            options ??= {};
-            options.envFilenames = [envFile];
-        }
-        dotenv.config({
-            path: options?.envFilenames
-        });
-        const envPrefix = options?.envPrefix ?? "TWIN_NODE_";
-        console.info("Environment Prefix:", envPrefix);
-        const envVars = EnvHelper.envToJson(process.env, envPrefix);
-        if (Object.keys(envVars).length === 0) {
-            throw new GeneralError("node", "noEnvVars", { prefix: envPrefix });
-        }
+        nodeOptions.envPrefix ??= "TWIN_NODE_";
+        console.info("Environment Prefix:", nodeOptions.envPrefix);
+        const { engineServerConfig, nodeEnvVars: envVars } = await buildConfiguration(process.env, nodeOptions, serverInfo);
         console.info();
-        const startResult = await start(serverInfo, envPrefix, envVars, options?.openApiSpecFile, options.stateStorage, options.extendConfig, options.extendEngine, options.extendEngineServer);
+        const startResult = await start(nodeOptions, engineServerConfig, envVars);
         if (!Is.empty(startResult)) {
             for (const signal of ["SIGHUP", "SIGINT", "SIGTERM"]) {
                 process.on(signal, async () => {
@@ -592,5 +1617,75 @@ async function run(options) {
         process.exit(1);
     }
 }
+/**
+ * Build the configuration for the TWIN Node server.
+ * @param processEnv The environment variables from the process.
+ * @param options The options for running the server.
+ * @param serverInfo The server information.
+ * @returns A promise that resolves to the engine server configuration, environment prefix, environment variables,
+ * and options.
+ */
+async function buildConfiguration(processEnv, options, serverInfo) {
+    let defaultEnvOnly = false;
+    if (Is.empty(options?.envFilenames)) {
+        const envFile = path.resolve(path.join(options.executionDirectory ?? "", ".env"));
+        console.info("Default Environment File:", envFile);
+        options ??= {};
+        options.envFilenames = [envFile];
+        defaultEnvOnly = true;
+    }
+    if (Is.arrayValue(options?.envFilenames)) {
+        const output = dotenv.config({
+            path: options?.envFilenames
+        });
+        // We don't want to throw an error if the default environment file is not found.
+        // Only if we have custom environment files.
+        if (!defaultEnvOnly && output.error) {
+            throw output.error;
+        }
+        if (Is.objectValue(output.parsed)) {
+            Object.assign(processEnv, output.parsed);
+        }
+    }
+    const envVars = EnvHelper.envToJson(processEnv, options.envPrefix ?? "");
+    // Expand any environment variables that use the @file: syntax
+    const keys = Object.keys(envVars);
+    for (const key of keys) {
+        if (Is.stringValue(envVars[key]) && envVars[key].startsWith("@file:")) {
+            const filePath = envVars[key].slice(6).trim();
+            const embeddedFile = path.resolve(path.join(options.executionDirectory ?? "", filePath));
+            console.info(`Expanding Environment Variable: ${key} from file: ${embeddedFile}`);
+            const fileContent = await loadJsonFile(embeddedFile);
+            envVars[key] = fileContent;
+        }
+    }
+    // Extend the environment variables with any additional custom configuration.
+    if (Is.function(options?.extendEnvVars)) {
+        console.info("Extending Environment Variables");
+        await options.extendEnvVars(envVars);
+    }
+    // Build the engine configuration from the environment variables.
+    const coreConfig = buildEngineConfiguration(envVars);
+    const engineServerConfig = buildEngineServerConfiguration(envVars, coreConfig, serverInfo, options?.openApiSpecFile);
+    // Merge any custom configuration provided in the options.
+    if (Is.arrayValue(options?.configFilenames)) {
+        for (const configFile of options.configFilenames) {
+            console.info("Loading Configuration File:", configFile);
+            const configFilePath = path.resolve(path.join(options.executionDirectory ?? "", configFile));
+            const config = await loadJsonFile(configFilePath);
+            Object.assign(engineServerConfig, config);
+        }
+    }
+    if (Is.objectValue(options?.config)) {
+        console.info("Merging Custom Configuration");
+        Object.assign(engineServerConfig, options.config);
+    }
+    // Merge any custom configuration provided in the options.
+    if (Is.function(options?.extendConfig)) {
+        console.info("Extending Configuration");
+        await options.extendConfig(engineServerConfig);
+    }
+    return { engineServerConfig, nodeEnvVars: envVars };
+}
 
-export { NodeFeatures, bootstrap, bootstrapAttestationMethod, bootstrapAuth, bootstrapBlobEncryption, bootstrapImmutableProofMethod, bootstrapNodeIdentity, bootstrapNodeUser, fileExists, getExecutionDirectory, getFeatures, initialiseLocales, run, start };
+export { NodeFeatures, bootstrap, bootstrapAttestationMethod, bootstrapAuth, bootstrapBlobEncryption, bootstrapImmutableProofMethod, bootstrapNodeIdentity, bootstrapNodeUser, buildConfiguration, buildEngineConfiguration, fileExists, getExecutionDirectory, getFeatures, initialiseLocales, loadJsonFile, run, start };