@twin.org/node-core 0.9.4-next.4 → 0.9.4

package/dist/es/builders/engineEnvBuilder.js

@@ -1,16 +1,15 @@
 // Copyright 2024 IOTA Stiftung.
 // SPDX-License-Identifier: Apache-2.0.
-import { cpus } from "node:os";
 import path from "node:path";
 import { Is, Mutex } from "@twin.org/core";
 import { EngineCloneMode } from "@twin.org/engine-models";
-import { AttestationComponentType, AttestationConnectorType, AuditableItemGraphComponentType, AuditableItemStreamComponentType, AutomationActionType, AutomationComponentType, BackgroundTaskComponentType, BlobStorageComponentType, BlobStorageConnectorType, ContextIdHandlerComponentType, DataConverterConnectorType, DataExtractorConnectorType, DataProcessingComponentType, DataspaceControlPlaneComponentType, DataspaceDataPlaneComponentType, DltConfigType, DocumentManagementComponentType, EmailProtocolConnectorType, EngineTypeHelper, EntityStorageConnectorType, EventBusComponentType, EventBusConnectorType, FaucetConnectorType, FederatedCatalogueComponentType, FederatedCatalogueFilterComponentType, HealthComponentType, IdentityComponentType, IdentityConnectorType, IdentityProfileComponentType, IdentityProfileConnectorType, IdentityResolverComponentType, IdentityResolverConnectorType, ImmutableProofComponentType, LoggingComponentType, LoggingConnectorType, MailboxComponentType, MailStorageComponentType, MessagingAdminComponentType, MessagingComponentType, MessagingEmailConnectorType, MessagingPushNotificationConnectorType, MessagingSmsConnectorType, MetricsCollectorComponentType, MetricsProducerComponentType, NftComponentType, NftConnectorType, NotarizationComponentType, NotarizationConnectorType, PlatformComponentType, RightsManagementPapComponentType, RightsManagementPdpComponentType, RightsManagementPepComponentType, RightsManagementPipComponentType, RightsManagementPmpComponentType, RightsManagementPnapComponentType, RightsManagementPnpComponentType, RightsManagementPolicyArbiterComponentType, RightsManagementPolicyEnforcementProcessorComponentType, RightsManagementPolicyExecutionActionComponentType, RightsManagementPolicyInformationSourceComponentType, RightsManagementPolicyNegotiatorComponentType, RightsManagementPolicyObligationEnforcerComponentType, RightsManagementPolicyRequesterComponentType, RightsManagementPxpComponentType, SchemaVersionMigrationComponentType, TaskSchedulerComponentType, TelemetryComponentType, TelemetryConnectorType, TenantAdminComponentType, TracingComponentType, TracingConnectorType, TrustComponentType, TrustGeneratorComponentType, TrustVerifierComponentType, VaultConnectorType, WalletConnectorType } from "@twin.org/engine-types";
+import { AttestationComponentType, AttestationConnectorType, AuditableItemGraphComponentType, AuditableItemStreamComponentType, AutomationComponentType, BackgroundTaskComponentType, BlobStorageComponentType, BlobStorageConnectorType, ContextIdHandlerComponentType, DataProcessingComponentType, DataspaceControlPlaneComponentType, DataspaceDataPlaneComponentType, DltConfigType, DocumentManagementComponentType, EngineTypeHelper, EntityStorageConnectorType, EventBusComponentType, EventBusConnectorType, FaucetConnectorType, FederatedCatalogueComponentType, HealthComponentType, IdentityComponentType, IdentityConnectorType, IdentityProfileComponentType, IdentityProfileConnectorType, IdentityResolverComponentType, IdentityResolverConnectorType, ImmutableProofComponentType, LoggingComponentType, LoggingConnectorType, MessagingAdminComponentType, MessagingComponentType, MessagingEmailConnectorType, MessagingPushNotificationConnectorType, MessagingSmsConnectorType, MetricsCollectorComponentType, MetricsProducerComponentType, NftComponentType, NftConnectorType, NotarizationComponentType, NotarizationConnectorType, PlatformComponentType, RightsManagementPapComponentType, RightsManagementPdpComponentType, RightsManagementPepComponentType, RightsManagementPipComponentType, RightsManagementPmpComponentType, RightsManagementPnapComponentType, RightsManagementPnpComponentType, RightsManagementPxpComponentType, SchemaVersionMigrationComponentType, TaskSchedulerComponentType, TelemetryComponentType, TelemetryConnectorType, TenantAdminComponentType, TracingComponentType, TracingConnectorType, TrustComponentType, TrustVerifierComponentType, VaultConnectorType, WalletConnectorType } from "@twin.org/engine-types";
 import { OpenTelemetryExporterTypes } from "@twin.org/logging-connector-opentelemetry";
 import { OpenTelemetryReaderTypes } from "@twin.org/telemetry-connector-opentelemetry";
 import { OpenTelemetryProcessorTypes } from "@twin.org/tracing-connector-opentelemetry";
 import { CONTEXT_ID_HANDLER_FEATURE_DID, CONTEXT_ID_HANDLER_FEATURE_TENANT } from "../defaults.js";
 import { isAuthEntityStorageRequired } from "./engineServerEnvBuilder.js";
-import { commaSeparatedListToArray, envArray, envBoolean, envChoice, envCount, envDateTime, envInteger, envListToArray, envMinToMs, envMinutes, envMs, envSecToMs, envSeconds } from "./helper/envHelpers.js";
+import { commaSeparatedListToArray, envArray, envBoolean, envCount, envDateTime, envInteger, envMinToMs, envMinutes, envMs, envSecToMs, envSeconds } from "./helper/envHelpers.js";
 /**
  * Build the engine core configuration from environment variables.
  * @param envVars The environment variables.
@@ -33,7 +32,7 @@ export async function buildEngineConfiguration(envVars) {
         types: {}
     };
     const mutexTimeoutMs = envMs(envVars, "mutexTimeoutDefault");
-    if (Is.notEmpty(mutexTimeoutMs)) {
+    if (!Is.empty(mutexTimeoutMs)) {
         Mutex.setDefaultTimeoutMs(mutexTimeoutMs);
     }
     await configureSchemaMigration(coreConfig, envVars);
@@ -52,7 +51,6 @@ export async function buildEngineConfiguration(envVars) {
     await configureMetricsCollector(coreConfig, envVars);
     await configureTracing(coreConfig, envVars);
     await configureMessaging(coreConfig, envVars);
-    await configureMailbox(coreConfig, envVars);
     await configureAutomation(coreConfig, envVars);
     await configureHealth(coreConfig, envVars);
     await configureFaucet(coreConfig, envVars);
@@ -83,165 +81,163 @@ export async function buildEngineConfiguration(envVars) {
 async function configureEntityStorage(coreConfig, envVars) {
     coreConfig.types ??= {};
     coreConfig.types.entityStorageConnector ??= [];
-    const entityStorageConnectorTypes = envListToArray(envVars, "entityStorageConnectorType", Object.values(EntityStorageConnectorType));
-    for (const entityStorageConnectorType of entityStorageConnectorTypes) {
-        if (entityStorageConnectorType === EntityStorageConnectorType.Memory) {
-            coreConfig.types.entityStorageConnector.push({
-                type: EntityStorageConnectorType.Memory,
-                options: {
-                    config: {
-                        mutexTimeoutMs: envMs(envVars, "entityStorageMutexTimeout")
-                    }
-                }
-            });
-        }
-        else if (entityStorageConnectorType === EntityStorageConnectorType.File) {
-            coreConfig.types.entityStorageConnector.push({
-                type: EntityStorageConnectorType.File,
-                options: {
-                    config: {
-                        directory: envVars.storageFileRoot ?? "",
-                        mutexTimeoutMs: envMs(envVars, "entityStorageMutexTimeout")
-                    },
-                    folderPrefix: envVars.entityStorageTablePrefix
-                }
-            });
-        }
-        else if (entityStorageConnectorType === EntityStorageConnectorType.AwsDynamoDb) {
-            coreConfig.types.entityStorageConnector.push({
-                type: EntityStorageConnectorType.AwsDynamoDb,
-                options: {
-                    config: {
-                        region: envVars.awsDynamodbRegion ?? "",
-                        authMode: envVars.awsDynamodbAuthMode,
-                        accessKeyId: envVars.awsDynamodbAccessKeyId,
-                        secretAccessKey: envVars.awsDynamodbSecretAccessKey,
-                        endpoint: envVars.awsDynamodbEndpoint,
-                        connectionTimeoutMs: envMs(envVars, "awsDynamodbConnectionTimeout"),
-                        mutexTimeoutMs: envMs(envVars, "entityStorageMutexTimeout")
-                    },
-                    tablePrefix: envVars.entityStorageTablePrefix
-                }
-            });
-        }
-        else if (entityStorageConnectorType === EntityStorageConnectorType.AzureCosmosDb) {
-            coreConfig.types.entityStorageConnector.push({
-                type: EntityStorageConnectorType.AzureCosmosDb,
-                options: {
-                    config: {
-                        endpoint: envVars.azureCosmosdbEndpoint ?? "",
-                        key: envVars.azureCosmosdbKey ?? "",
-                        databaseId: envVars.azureCosmosdbDatabaseId ?? "",
-                        containerId: envVars.azureCosmosdbContainerId ?? "",
-                        mutexTimeoutMs: envMs(envVars, "entityStorageMutexTimeout")
-                    },
-                    tablePrefix: envVars.entityStorageTablePrefix
-                }
-            });
-        }
-        else if (entityStorageConnectorType === EntityStorageConnectorType.GcpFirestoreDb) {
-            coreConfig.types.entityStorageConnector.push({
-                type: EntityStorageConnectorType.GcpFirestoreDb,
-                options: {
-                    config: {
-                        projectId: envVars.gcpFirestoreProjectId ?? "",
-                        credentials: envVars.gcpFirestoreCredentials ?? "",
-                        databaseId: envVars.gcpFirestoreDatabaseId ?? "",
-                        collectionName: envVars.gcpFirestoreCollectionName ?? "",
-                        endpoint: envVars.gcpFirestoreEndpoint ?? "",
-                        mutexTimeoutMs: envMs(envVars, "entityStorageMutexTimeout")
-                    },
-                    tablePrefix: envVars.entityStorageTablePrefix
-                }
-            });
-        }
-        else if (entityStorageConnectorType === EntityStorageConnectorType.ScyllaDb) {
-            coreConfig.types.entityStorageConnector.push({
-                type: EntityStorageConnectorType.ScyllaDb,
-                options: {
-                    config: {
-                        hosts: commaSeparatedListToArray(envVars.scylladbHosts),
-                        localDataCenter: envVars.scylladbLocalDataCenter ?? "",
-                        keyspace: envVars.scylladbKeyspace ?? "",
-                        port: envInteger(envVars, "scylladbPort"),
-                        mutexTimeoutMs: envMs(envVars, "entityStorageMutexTimeout"),
-                        pool: {
-                            coreConnectionsPerHost: envCount(envVars, "scylladbPoolCoreConnectionsPerHost"),
-                            maxRequestsPerConnection: envCount(envVars, "scylladbPoolMaxRequestsPerConnection")
-                        }
-                    },
-                    tablePrefix: envVars.entityStorageTablePrefix
-                }
-            });
-        }
-        else if (entityStorageConnectorType === EntityStorageConnectorType.MySqlDb) {
-            coreConfig.types.entityStorageConnector.push({
-                type: EntityStorageConnectorType.MySqlDb,
-                options: {
-                    config: {
-                        host: envVars.mySqlHost ?? "",
-                        port: envInteger(envVars, "mySqlPort"),
-                        user: envVars.mySqlUser ?? "",
-                        password: envVars.mySqlPassword ?? "",
-                        database: envVars.mySqlDatabase ?? "",
-                        mutexTimeoutMs: envMs(envVars, "entityStorageMutexTimeout"),
-                        pool: {
-                            connectionLimit: envCount(envVars, "mySqlPoolConnectionLimit"),
-                            maxIdle: envCount(envVars, "mySqlPoolMaxIdle"),
-                            idleTimeout: envMs(envVars, "mySqlPoolIdleTimeout"),
-                            enableKeepAlive: envBoolean(envVars, "mySqlPoolEnableKeepAlive"),
-                            waitForConnections: envBoolean(envVars, "mySqlPoolWaitForConnections"),
-                            queueLimit: envCount(envVars, "mySqlPoolQueueLimit")
-                        }
-                    },
-                    tablePrefix: envVars.entityStorageTablePrefix
-                }
-            });
-        }
-        else if (entityStorageConnectorType === EntityStorageConnectorType.MongoDb) {
-            coreConfig.types.entityStorageConnector.push({
-                type: EntityStorageConnectorType.MongoDb,
-                options: {
-                    config: {
-                        host: envVars.mongoDbHost ?? "",
-                        port: envInteger(envVars, "mongoDbPort"),
-                        user: envVars.mongoDbUser ?? "",
-                        password: envVars.mongoDbPassword ?? "",
-                        database: envVars.mongoDbDatabase ?? "",
-                        mutexTimeoutMs: envMs(envVars, "entityStorageMutexTimeout"),
-                        pool: {
-                            maxPoolSize: envCount(envVars, "mongoDbPoolMaxPoolSize"),
-                            minPoolSize: envCount(envVars, "mongoDbPoolMinPoolSize"),
-                            maxIdleTimeMs: envMs(envVars, "mongoDbPoolMaxIdleTime"),
-                            waitQueueTimeoutMs: envMs(envVars, "mongoDbPoolWaitQueueTimeout")
-                        }
-                    },
-                    tablePrefix: envVars.entityStorageTablePrefix
-                }
-            });
-        }
-        else if (entityStorageConnectorType === EntityStorageConnectorType.PostgreSql) {
-            coreConfig.types.entityStorageConnector.push({
-                type: EntityStorageConnectorType.PostgreSql,
-                options: {
-                    config: {
-                        host: envVars.postgreSqlHost ?? "",
-                        port: envInteger(envVars, "postgreSqlPort"),
-                        user: envVars.postgreSqlUser ?? "",
-                        password: envVars.postgreSqlPassword ?? "",
-                        database: envVars.postgreSqlDatabase ?? "",
-                        mutexTimeoutMs: envMs(envVars, "entityStorageMutexTimeout"),
-                        pool: {
-                            max: envCount(envVars, "postgreSqlPoolMax"),
-                            idleTimeout: envSeconds(envVars, "postgreSqlPoolIdleTimeout"),
-                            connectTimeout: envSeconds(envVars, "postgreSqlPoolConnectTimeout"),
-                            maxLifetime: envSeconds(envVars, "postgreSqlPoolMaxLifetime")
-                        }
-                    },
-                    tablePrefix: envVars.entityStorageTablePrefix
+    const entityStorageConnectorTypes = commaSeparatedListToArray(envVars.entityStorageConnectorType);
+    if (entityStorageConnectorTypes.includes(EntityStorageConnectorType.Memory)) {
+        coreConfig.types.entityStorageConnector.push({
+            type: EntityStorageConnectorType.Memory,
+            options: {
+                config: {
+                    mutexTimeoutMs: envMs(envVars, "entityStorageMutexTimeout")
                 }
-            });
-        }
+            }
+        });
+    }
+    if (entityStorageConnectorTypes.includes(EntityStorageConnectorType.File)) {
+        coreConfig.types.entityStorageConnector.push({
+            type: EntityStorageConnectorType.File,
+            options: {
+                config: {
+                    directory: envVars.storageFileRoot ?? "",
+                    mutexTimeoutMs: envMs(envVars, "entityStorageMutexTimeout")
+                },
+                folderPrefix: envVars.entityStorageTablePrefix
+            }
+        });
+    }
+    if (entityStorageConnectorTypes.includes(EntityStorageConnectorType.AwsDynamoDb)) {
+        coreConfig.types.entityStorageConnector.push({
+            type: EntityStorageConnectorType.AwsDynamoDb,
+            options: {
+                config: {
+                    region: envVars.awsDynamodbRegion ?? "",
+                    authMode: envVars.awsDynamodbAuthMode,
+                    accessKeyId: envVars.awsDynamodbAccessKeyId,
+                    secretAccessKey: envVars.awsDynamodbSecretAccessKey,
+                    endpoint: envVars.awsDynamodbEndpoint,
+                    connectionTimeoutMs: envMs(envVars, "awsDynamodbConnectionTimeout"),
+                    mutexTimeoutMs: envMs(envVars, "entityStorageMutexTimeout")
+                },
+                tablePrefix: envVars.entityStorageTablePrefix
+            }
+        });
+    }
+    if (entityStorageConnectorTypes.includes(EntityStorageConnectorType.AzureCosmosDb)) {
+        coreConfig.types.entityStorageConnector.push({
+            type: EntityStorageConnectorType.AzureCosmosDb,
+            options: {
+                config: {
+                    endpoint: envVars.azureCosmosdbEndpoint ?? "",
+                    key: envVars.azureCosmosdbKey ?? "",
+                    databaseId: envVars.azureCosmosdbDatabaseId ?? "",
+                    containerId: envVars.azureCosmosdbContainerId ?? "",
+                    mutexTimeoutMs: envMs(envVars, "entityStorageMutexTimeout")
+                },
+                tablePrefix: envVars.entityStorageTablePrefix
+            }
+        });
+    }
+    if (entityStorageConnectorTypes.includes(EntityStorageConnectorType.GcpFirestoreDb)) {
+        coreConfig.types.entityStorageConnector.push({
+            type: EntityStorageConnectorType.GcpFirestoreDb,
+            options: {
+                config: {
+                    projectId: envVars.gcpFirestoreProjectId ?? "",
+                    credentials: envVars.gcpFirestoreCredentials ?? "",
+                    databaseId: envVars.gcpFirestoreDatabaseId ?? "",
+                    collectionName: envVars.gcpFirestoreCollectionName ?? "",
+                    endpoint: envVars.gcpFirestoreEndpoint ?? "",
+                    mutexTimeoutMs: envMs(envVars, "entityStorageMutexTimeout")
+                },
+                tablePrefix: envVars.entityStorageTablePrefix
+            }
+        });
+    }
+    if (entityStorageConnectorTypes.includes(EntityStorageConnectorType.ScyllaDb)) {
+        coreConfig.types.entityStorageConnector.push({
+            type: EntityStorageConnectorType.ScyllaDb,
+            options: {
+                config: {
+                    hosts: commaSeparatedListToArray(envVars.scylladbHosts),
+                    localDataCenter: envVars.scylladbLocalDataCenter ?? "",
+                    keyspace: envVars.scylladbKeyspace ?? "",
+                    port: envInteger(envVars, "scylladbPort"),
+                    mutexTimeoutMs: envMs(envVars, "entityStorageMutexTimeout"),
+                    pool: {
+                        coreConnectionsPerHost: envCount(envVars, "scylladbPoolCoreConnectionsPerHost"),
+                        maxRequestsPerConnection: envCount(envVars, "scylladbPoolMaxRequestsPerConnection")
+                    }
+                },
+                tablePrefix: envVars.entityStorageTablePrefix
+            }
+        });
+    }
+    if (entityStorageConnectorTypes.includes(EntityStorageConnectorType.MySqlDb)) {
+        coreConfig.types.entityStorageConnector.push({
+            type: EntityStorageConnectorType.MySqlDb,
+            options: {
+                config: {
+                    host: envVars.mySqlHost ?? "",
+                    port: envInteger(envVars, "mySqlPort"),
+                    user: envVars.mySqlUser ?? "",
+                    password: envVars.mySqlPassword ?? "",
+                    database: envVars.mySqlDatabase ?? "",
+                    mutexTimeoutMs: envMs(envVars, "entityStorageMutexTimeout"),
+                    pool: {
+                        connectionLimit: envCount(envVars, "mySqlPoolConnectionLimit"),
+                        maxIdle: envCount(envVars, "mySqlPoolMaxIdle"),
+                        idleTimeout: envMs(envVars, "mySqlPoolIdleTimeout"),
+                        enableKeepAlive: envBoolean(envVars, "mySqlPoolEnableKeepAlive"),
+                        waitForConnections: envBoolean(envVars, "mySqlPoolWaitForConnections"),
+                        queueLimit: envCount(envVars, "mySqlPoolQueueLimit")
+                    }
+                },
+                tablePrefix: envVars.entityStorageTablePrefix
+            }
+        });
+    }
+    if (entityStorageConnectorTypes.includes(EntityStorageConnectorType.MongoDb)) {
+        coreConfig.types.entityStorageConnector.push({
+            type: EntityStorageConnectorType.MongoDb,
+            options: {
+                config: {
+                    host: envVars.mongoDbHost ?? "",
+                    port: envInteger(envVars, "mongoDbPort"),
+                    user: envVars.mongoDbUser ?? "",
+                    password: envVars.mongoDbPassword ?? "",
+                    database: envVars.mongoDbDatabase ?? "",
+                    mutexTimeoutMs: envMs(envVars, "entityStorageMutexTimeout"),
+                    pool: {
+                        maxPoolSize: envCount(envVars, "mongoDbPoolMaxPoolSize"),
+                        minPoolSize: envCount(envVars, "mongoDbPoolMinPoolSize"),
+                        maxIdleTimeMs: envMs(envVars, "mongoDbPoolMaxIdleTime"),
+                        waitQueueTimeoutMs: envMs(envVars, "mongoDbPoolWaitQueueTimeout")
+                    }
+                },
+                tablePrefix: envVars.entityStorageTablePrefix
+            }
+        });
+    }
+    if (entityStorageConnectorTypes.includes(EntityStorageConnectorType.PostgreSql)) {
+        coreConfig.types.entityStorageConnector.push({
+            type: EntityStorageConnectorType.PostgreSql,
+            options: {
+                config: {
+                    host: envVars.postgreSqlHost ?? "",
+                    port: envInteger(envVars, "postgreSqlPort"),
+                    user: envVars.postgreSqlUser ?? "",
+                    password: envVars.postgreSqlPassword ?? "",
+                    database: envVars.postgreSqlDatabase ?? "",
+                    mutexTimeoutMs: envMs(envVars, "entityStorageMutexTimeout"),
+                    pool: {
+                        max: envCount(envVars, "postgreSqlPoolMax"),
+                        idleTimeout: envSeconds(envVars, "postgreSqlPoolIdleTimeout"),
+                        connectTimeout: envSeconds(envVars, "postgreSqlPoolConnectTimeout"),
+                        maxLifetime: envSeconds(envVars, "postgreSqlPoolMaxLifetime")
+                    }
+                },
+                tablePrefix: envVars.entityStorageTablePrefix
+            }
+        });
     }
     const defaultEntityStorageConnectorType = envVars.entityStorageConnectorDefault ?? entityStorageConnectorTypes[0];
     if (Is.arrayValue(entityStorageConnectorTypes)) {
@@ -261,88 +257,85 @@ async function configureEntityStorage(coreConfig, envVars) {
  */
 async function configureBlobStorage(coreConfig, envVars) {
     coreConfig.types.blobStorageConnector ??= [];
-    const blobStorageConnectorTypes = envListToArray(envVars, "blobStorageConnectorType", Object.values(BlobStorageConnectorType));
-    for (const blobStorageConnectorType of blobStorageConnectorTypes) {
-        if (blobStorageConnectorType === BlobStorageConnectorType.Memory) {
-            coreConfig.types.blobStorageConnector.push({
-                type: BlobStorageConnectorType.Memory
-            });
-        }
-        else if (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
-                }
-            });
-        }
-        else if (blobStorageConnectorType === BlobStorageConnectorType.Ipfs) {
-            coreConfig.types.blobStorageConnector.push({
-                type: BlobStorageConnectorType.Ipfs,
-                options: {
-                    config: {
-                        apiUrl: envVars.ipfsApiUrl ?? "",
-                        bearerToken: envVars.ipfsBearerToken
-                    }
-                }
-            });
-        }
-        else if (blobStorageConnectorType === BlobStorageConnectorType.AwsS3) {
-            coreConfig.types.blobStorageConnector.push({
-                type: BlobStorageConnectorType.AwsS3,
-                options: {
-                    config: {
-                        region: envVars.awsS3Region ?? "",
-                        bucketName: envVars.awsS3BucketName ?? "",
-                        authMode: envVars.awsS3AuthMode,
-                        accessKeyId: envVars.awsS3AccessKeyId,
-                        secretAccessKey: envVars.awsS3SecretAccessKey,
-                        endpoint: envVars.awsS3Endpoint
-                    },
-                    storagePrefix: envVars.blobStoragePrefix
-                }
-            });
-        }
-        else if (blobStorageConnectorType === BlobStorageConnectorType.AzureStorage) {
-            coreConfig.types.blobStorageConnector.push({
-                type: BlobStorageConnectorType.AzureStorage,
-                options: {
-                    config: {
-                        accountName: envVars.azureStorageAccountName ?? "",
-                        accountKey: envVars.azureStorageAccountKey ?? "",
-                        containerName: envVars.azureStorageContainerName ?? "",
-                        endpoint: envVars.azureStorageEndpoint ?? ""
-                    },
-                    storagePrefix: envVars.blobStoragePrefix
-                }
-            });
-        }
-        else if (blobStorageConnectorType === BlobStorageConnectorType.GcpStorage) {
-            coreConfig.types.blobStorageConnector.push({
-                type: BlobStorageConnectorType.GcpStorage,
-                options: {
-                    config: {
-                        projectId: envVars.gcpStorageProjectId ?? "",
-                        credentials: envVars.gcpStorageCredentials ?? "",
-                        bucketName: envVars.gcpStorageBucketName ?? "",
-                        apiEndpoint: envVars.gcpFirestoreEndpoint
-                    },
-                    storagePrefix: envVars.blobStoragePrefix
+    const blobStorageConnectorTypes = commaSeparatedListToArray(envVars.blobStorageConnectorType);
+    if (blobStorageConnectorTypes.includes(BlobStorageConnectorType.Memory)) {
+        coreConfig.types.blobStorageConnector.push({
+            type: BlobStorageConnectorType.Memory
+        });
+    }
+    if (blobStorageConnectorTypes.includes(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 (blobStorageConnectorTypes.includes(BlobStorageConnectorType.Ipfs)) {
+        coreConfig.types.blobStorageConnector.push({
+            type: BlobStorageConnectorType.Ipfs,
+            options: {
+                config: {
+                    apiUrl: envVars.ipfsApiUrl ?? "",
+                    bearerToken: envVars.ipfsBearerToken
                 }
-            });
-        }
+            }
+        });
+    }
+    if (blobStorageConnectorTypes.includes(BlobStorageConnectorType.AwsS3)) {
+        coreConfig.types.blobStorageConnector.push({
+            type: BlobStorageConnectorType.AwsS3,
+            options: {
+                config: {
+                    region: envVars.awsS3Region ?? "",
+                    bucketName: envVars.awsS3BucketName ?? "",
+                    authMode: envVars.awsS3AuthMode,
+                    accessKeyId: envVars.awsS3AccessKeyId,
+                    secretAccessKey: envVars.awsS3SecretAccessKey,
+                    endpoint: envVars.awsS3Endpoint
+                },
+                storagePrefix: envVars.blobStoragePrefix
+            }
+        });
+    }
+    if (blobStorageConnectorTypes.includes(BlobStorageConnectorType.AzureStorage)) {
+        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 (blobStorageConnectorTypes.includes(BlobStorageConnectorType.GcpStorage)) {
+        coreConfig.types.blobStorageConnector.push({
+            type: BlobStorageConnectorType.GcpStorage,
+            options: {
+                config: {
+                    projectId: envVars.gcpStorageProjectId ?? "",
+                    credentials: envVars.gcpStorageCredentials ?? "",
+                    bucketName: envVars.gcpStorageBucketName ?? "",
+                    apiEndpoint: envVars.gcpFirestoreEndpoint
+                },
+                storagePrefix: envVars.blobStoragePrefix
+            }
+        });
     }
     if (Is.arrayValue(blobStorageConnectorTypes)) {
         const defaultStorageConnectorType = envVars.blobStorageConnectorDefault ?? blobStorageConnectorTypes[0];
         for (const config of coreConfig.types.blobStorageConnector) {
             if (config.type === defaultStorageConnectorType) {
                 config.isDefault = true;
-                break;
             }
         }
     }
@@ -368,7 +361,7 @@ async function configureBlobStorage(coreConfig, envVars) {
  */
 async function configureLogging(coreConfig, envVars) {
     coreConfig.types.loggingConnector ??= [];
-    const loggingConnectorTypes = envListToArray(envVars, "loggingConnector", Object.values(LoggingConnectorType));
+    const loggingConnectorTypes = commaSeparatedListToArray(envVars.loggingConnector);
     let additionalConnectorCount = 0;
     for (const loggingConnector of loggingConnectorTypes) {
         if (loggingConnector === LoggingConnectorType.Console) {
@@ -470,8 +463,7 @@ async function configureLogging(coreConfig, envVars) {
  */
 async function configureVault(coreConfig, envVars) {
     coreConfig.types.vaultConnector ??= [];
-    const vaultConnectorType = envChoice(envVars, "vaultConnector", Object.values(VaultConnectorType));
-    if (vaultConnectorType === VaultConnectorType.EntityStorage) {
+    if (envVars.vaultConnector === VaultConnectorType.EntityStorage) {
         coreConfig.types.vaultConnector.push({
             type: VaultConnectorType.EntityStorage,
             options: {
@@ -481,7 +473,7 @@ async function configureVault(coreConfig, envVars) {
             }
         });
     }
-    else if (vaultConnectorType === VaultConnectorType.Hashicorp) {
+    else if (envVars.vaultConnector === VaultConnectorType.Hashicorp) {
         coreConfig.types.vaultConnector.push({
             type: VaultConnectorType.Hashicorp,
             options: {
@@ -504,16 +496,7 @@ async function configureBackgroundTask(coreConfig, envVars) {
     coreConfig.types.backgroundTaskComponent ??= [];
     if (isBackgroundTasksRequired(envVars)) {
         coreConfig.types.backgroundTaskComponent.push({
-            type: BackgroundTaskComponentType.Service,
-            options: {
-                config: {
-                    maxSystemWorkerCount: envCount(envVars, "backgroundTaskMaxSystemWorkerCount", cpus().length * 2),
-                    taskInterval: envMs(envVars, "backgroundTaskInterval"),
-                    retryInterval: envMs(envVars, "backgroundTaskRetryInterval"),
-                    cleanupInterval: envMs(envVars, "backgroundTaskCleanupInterval"),
-                    workerShutdownTimeout: envMs(envVars, "backgroundTaskWorkerShutdownTimeout")
-                }
-            }
+            type: BackgroundTaskComponentType.Service
         });
     }
 }
@@ -525,8 +508,7 @@ async function configureBackgroundTask(coreConfig, envVars) {
  */
 async function configureEventBus(coreConfig, envVars) {
     coreConfig.types.eventBusConnector ??= [];
-    const eventBusConnectorType = envChoice(envVars, "eventBusConnector", Object.values(EventBusConnectorType));
-    if (eventBusConnectorType === EventBusConnectorType.Local) {
+    if (envVars.eventBusConnector === EventBusConnectorType.Local) {
         coreConfig.types.eventBusConnector.push({
             type: EventBusConnectorType.Local
         });
@@ -544,16 +526,16 @@ async function configureEventBus(coreConfig, envVars) {
  */
 async function configureTelemetry(coreConfig, envVars) {
     coreConfig.types.telemetryConnector ??= [];
-    const telemetryConnectorTypes = envListToArray(envVars, "telemetryConnector", Object.values(TelemetryConnectorType));
+    const telemetryConnectorTypes = commaSeparatedListToArray(envVars.telemetryConnector);
     let additionalConnectorCount = 0;
-    for (const telemetryConnectorType of telemetryConnectorTypes) {
-        if (telemetryConnectorType === TelemetryConnectorType.Silent) {
+    for (const telemetryConnector of telemetryConnectorTypes) {
+        if (telemetryConnector === TelemetryConnectorType.Silent) {
             coreConfig.types.telemetryConnector.push({
                 type: TelemetryConnectorType.Silent
             });
             additionalConnectorCount++;
         }
-        else if (telemetryConnectorType === TelemetryConnectorType.EntityStorage) {
+        else if (telemetryConnector === TelemetryConnectorType.EntityStorage) {
             coreConfig.types.telemetryConnector.push({
                 type: TelemetryConnectorType.EntityStorage,
                 options: {
@@ -569,7 +551,7 @@ async function configureTelemetry(coreConfig, envVars) {
             });
             additionalConnectorCount++;
         }
-        else if (telemetryConnectorType === TelemetryConnectorType.OpenTelemetry) {
+        else if (telemetryConnector === TelemetryConnectorType.OpenTelemetry) {
             let readers;
             if (envVars.openTelemetryReader === OpenTelemetryReaderTypes.Prometheus) {
                 readers = {
@@ -632,10 +614,8 @@ async function configureMetricsCollector(coreConfig, envVars) {
             cloneMode: EngineCloneMode.Never
         });
         coreConfig.types.metricsProducerComponent ??= [];
-        const metricsProducers = envListToArray(envVars, "telemetryMetricsProducers", Object.values(MetricsProducerComponentType), [
-            MetricsProducerComponentType.System,
-            MetricsProducerComponentType.Process
-        ]);
+        const metricsProducers = commaSeparatedListToArray(envVars.telemetryMetricsProducers ??
+            [MetricsProducerComponentType.System, MetricsProducerComponentType.Process].join(","));
         for (const producerType of metricsProducers) {
             coreConfig.types.metricsProducerComponent.push({
                 type: producerType,
@@ -653,16 +633,16 @@ async function configureMetricsCollector(coreConfig, envVars) {
  */
 async function configureTracing(coreConfig, envVars) {
     coreConfig.types.tracingConnector ??= [];
-    const tracingConnectorTypes = envListToArray(envVars, "tracingConnector", Object.values(TracingConnectorType));
+    const tracingConnectorTypes = commaSeparatedListToArray(envVars.tracingConnector);
     let additionalConnectorCount = 0;
-    for (const tracingConnectorType of tracingConnectorTypes) {
-        if (tracingConnectorType === TracingConnectorType.Silent) {
+    for (const tracingConnector of tracingConnectorTypes) {
+        if (tracingConnector === TracingConnectorType.Silent) {
             coreConfig.types.tracingConnector.push({
                 type: TracingConnectorType.Silent
             });
             additionalConnectorCount++;
         }
-        else if (tracingConnectorType === TracingConnectorType.EntityStorage) {
+        else if (tracingConnector === TracingConnectorType.EntityStorage) {
             coreConfig.types.tracingConnector.push({
                 type: TracingConnectorType.EntityStorage,
                 options: {
@@ -673,13 +653,7 @@ async function configureTracing(coreConfig, envVars) {
             });
             additionalConnectorCount++;
         }
-        else if (tracingConnectorType === TracingConnectorType.Console) {
-            coreConfig.types.tracingConnector.push({
-                type: TracingConnectorType.Console
-            });
-            additionalConnectorCount++;
-        }
-        else if (tracingConnectorType === TracingConnectorType.OpenTelemetry) {
+        else if (tracingConnector === TracingConnectorType.OpenTelemetry) {
             const otelTracingConfig = {
                 tracerName: envVars.openTelemetryTracingTracerName,
                 tracerVersion: envVars.openTelemetryTracingTracerVersion
@@ -735,13 +709,15 @@ async function configureAutomation(coreConfig, envVars) {
         coreConfig.types.automationComponent.push({
             type: AutomationComponentType.Service
         });
-        const automationActionTypes = envListToArray(envVars, "automationActionTypes", Object.values(AutomationActionType));
-        coreConfig.types.automationAction ??= [];
-        for (const actionType of automationActionTypes) {
-            coreConfig.types.automationAction.push({
-                type: actionType,
-                isMultiInstance: true
-            });
+        const automationActionTypes = commaSeparatedListToArray(envVars.automationActionTypes);
+        if (Is.arrayValue(automationActionTypes)) {
+            coreConfig.types.automationAction ??= [];
+            for (const actionType of automationActionTypes) {
+                coreConfig.types.automationAction.push({
+                    type: actionType,
+                    isMultiInstance: true
+                });
+            }
         }
     }
 }
@@ -844,89 +820,69 @@ async function configureContextIdHandlers(coreConfig, envVars) {
  * @returns A promise that resolves when the messaging configuration has been applied.
  */
 async function configureMessaging(coreConfig, envVars) {
-    coreConfig.types.messagingEmailConnector ??= [];
-    coreConfig.types.messagingSmsConnector ??= [];
-    coreConfig.types.messagingPushNotificationConnector ??= [];
-    const messagingEmailConnectorType = envChoice(envVars, "messagingEmailConnector", Object.values(MessagingEmailConnectorType));
-    if (messagingEmailConnectorType === MessagingEmailConnectorType.EntityStorage) {
-        coreConfig.types.messagingEmailConnector.push({
-            type: MessagingEmailConnectorType.EntityStorage
-        });
-    }
-    else if (messagingEmailConnectorType === MessagingEmailConnectorType.Aws) {
-        coreConfig.types.messagingEmailConnector.push({
-            type: MessagingEmailConnectorType.Aws,
-            options: {
-                config: {
-                    region: envVars.awsSesRegion ?? "",
-                    authMode: envVars.awsSesAuthMode,
-                    accessKeyId: envVars.awsSesAccessKeyId,
-                    secretAccessKey: envVars.awsSesSecretAccessKey,
-                    endpoint: envVars.awsSesEndpoint
-                }
-            }
-        });
-    }
-    else if (messagingEmailConnectorType === MessagingEmailConnectorType.Smtp) {
-        coreConfig.types.messagingEmailConnector.push({
-            type: MessagingEmailConnectorType.Smtp,
-            options: {
-                config: {
-                    host: envVars.smtpHost ?? "",
-                    port: envInteger(envVars, "smtpPort"),
-                    secure: envBoolean(envVars, "smtpSecure"),
-                    username: envVars.smtpUsername,
-                    password: envVars.smtpPassword
+    if (envBoolean(envVars, "messagingEnabled", false)) {
+        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.awsSesRegion ?? "",
+                        authMode: envVars.awsSesAuthMode,
+                        accessKeyId: envVars.awsSesAccessKeyId,
+                        secretAccessKey: envVars.awsSesSecretAccessKey,
+                        endpoint: envVars.awsSesEndpoint
+                    }
                 }
-            }
-        });
-    }
-    const messagingSmsConnectorType = envChoice(envVars, "messagingSmsConnector", Object.values(MessagingSmsConnectorType));
-    if (messagingSmsConnectorType === MessagingSmsConnectorType.EntityStorage) {
-        coreConfig.types.messagingSmsConnector.push({
-            type: MessagingSmsConnectorType.EntityStorage
-        });
-    }
-    else if (messagingSmsConnectorType === MessagingSmsConnectorType.Aws) {
-        coreConfig.types.messagingSmsConnector.push({
-            type: MessagingSmsConnectorType.Aws,
-            options: {
-                config: {
-                    region: envVars.awsSesRegion ?? "",
-                    authMode: envVars.awsSesAuthMode,
-                    accessKeyId: envVars.awsSesAccessKeyId,
-                    secretAccessKey: envVars.awsSesSecretAccessKey,
-                    endpoint: envVars.awsSesEndpoint
+            });
+        }
+        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.awsSesRegion ?? "",
+                        authMode: envVars.awsSesAuthMode,
+                        accessKeyId: envVars.awsSesAccessKeyId,
+                        secretAccessKey: envVars.awsSesSecretAccessKey,
+                        endpoint: envVars.awsSesEndpoint
+                    }
                 }
-            }
-        });
-    }
-    const messagingPushConnectorType = envChoice(envVars, "messagingPushNotificationConnector", Object.values(MessagingPushNotificationConnectorType));
-    if (messagingPushConnectorType === MessagingPushNotificationConnectorType.EntityStorage) {
-        coreConfig.types.messagingPushNotificationConnector.push({
-            type: MessagingPushNotificationConnectorType.EntityStorage
-        });
-    }
-    else if (messagingPushConnectorType === MessagingPushNotificationConnectorType.Aws) {
-        coreConfig.types.messagingPushNotificationConnector.push({
-            type: MessagingPushNotificationConnectorType.Aws,
-            options: {
-                config: {
-                    region: envVars.awsSesRegion ?? "",
-                    authMode: envVars.awsSesAuthMode,
-                    accessKeyId: envVars.awsSesAccessKeyId,
-                    secretAccessKey: envVars.awsSesSecretAccessKey,
-                    endpoint: envVars.awsSesEndpoint,
-                    applicationsSettings: envArray(envVars, "awsMessagingPushNotificationApplications", [])
+            });
+        }
+        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.awsSesRegion ?? "",
+                        authMode: envVars.awsSesAuthMode,
+                        accessKeyId: envVars.awsSesAccessKeyId,
+                        secretAccessKey: envVars.awsSesSecretAccessKey,
+                        endpoint: envVars.awsSesEndpoint,
+                        applicationsSettings: envArray(envVars, "awsMessagingPushNotificationApplications", [])
+                    }
                 }
-            }
-        });
-    }
-    // If any messaging connectors are configured, then we should configure the messaging admin and
-    // service components as well since they are required for the messaging connectors to work.
-    if (coreConfig.types.messagingEmailConnector.length > 0 ||
-        coreConfig.types.messagingSmsConnector.length > 0 ||
-        coreConfig.types.messagingPushNotificationConnector.length > 0) {
+            });
+        }
         coreConfig.types.messagingAdminComponent ??= [];
         coreConfig.types.messagingAdminComponent.push({
             type: MessagingAdminComponentType.Service
@@ -935,40 +891,6 @@ async function configureMessaging(coreConfig, envVars) {
         coreConfig.types.messagingComponent.push({ type: MessagingComponentType.Service });
     }
 }
-/**
- * Configures mailbox components, mail storage components, and email protocol connectors.
- * @param coreConfig The core config.
- * @param envVars The environment variables.
- * @returns A promise that resolves when the mailbox configuration has been applied.
- */
-async function configureMailbox(coreConfig, envVars) {
-    coreConfig.types.emailProtocolConnector ??= [];
-    const emailProtocolConnectorTypes = envListToArray(envVars, "emailProtocolConnector", Object.values(EmailProtocolConnectorType));
-    for (const emailProtocolConnectorType of emailProtocolConnectorTypes) {
-        coreConfig.types.emailProtocolConnector.push({
-            type: emailProtocolConnectorType,
-            options: {
-                config: {}
-            },
-            cloneMode: EngineCloneMode.Never,
-            isMultiInstance: true
-        });
-    }
-    // If email protocol connectors are configured, then we should configure the mailbox and mail store
-    // components as well, since they are required for the email protocol connectors to work.
-    if (coreConfig.types.emailProtocolConnector.length > 0) {
-        coreConfig.types.mailStorageComponent ??= [];
-        coreConfig.types.mailStorageComponent.push({
-            type: MailStorageComponentType.Service,
-            cloneMode: EngineCloneMode.Never
-        });
-        coreConfig.types.mailboxComponent ??= [];
-        coreConfig.types.mailboxComponent.push({
-            type: MailboxComponentType.Service,
-            cloneMode: EngineCloneMode.Never
-        });
-    }
-}
 /**
  * Configures the faucet.
  * @param coreConfig The core config.
@@ -977,13 +899,12 @@ async function configureMailbox(coreConfig, envVars) {
  */
 async function configureFaucet(coreConfig, envVars) {
     coreConfig.types.faucetConnector ??= [];
-    const faucetConnectorType = envChoice(envVars, "faucetConnector", Object.values(FaucetConnectorType));
-    if (faucetConnectorType === FaucetConnectorType.EntityStorage) {
+    if (envVars.faucetConnector === FaucetConnectorType.EntityStorage) {
         coreConfig.types.faucetConnector.push({
             type: FaucetConnectorType.EntityStorage
         });
     }
-    else if (faucetConnectorType === FaucetConnectorType.Iota &&
+    else if (envVars.faucetConnector === FaucetConnectorType.Iota &&
         Is.stringValue(envVars.iotaFaucetEndpoint)) {
         const dltConfig = EngineTypeHelper.getConfigOfType(coreConfig, "dltConfig", DltConfigType.Iota);
         coreConfig.types.faucetConnector.push({
@@ -1006,13 +927,12 @@ async function configureFaucet(coreConfig, envVars) {
  */
 async function configureWallet(coreConfig, envVars) {
     coreConfig.types.walletConnector ??= [];
-    const walletConnectorType = envChoice(envVars, "walletConnector", Object.values(WalletConnectorType));
-    if (walletConnectorType === WalletConnectorType.EntityStorage) {
+    if (envVars.walletConnector === WalletConnectorType.EntityStorage) {
         coreConfig.types.walletConnector.push({
             type: WalletConnectorType.EntityStorage
         });
     }
-    else if (walletConnectorType === WalletConnectorType.Iota) {
+    else if (envVars.walletConnector === WalletConnectorType.Iota) {
         const dltConfig = EngineTypeHelper.getConfigOfType(coreConfig, "dltConfig", DltConfigType.Iota);
         coreConfig.types.walletConnector.push({
             type: WalletConnectorType.Iota,
@@ -1030,13 +950,12 @@ async function configureWallet(coreConfig, envVars) {
  */
 async function configureNft(coreConfig, envVars) {
     coreConfig.types.nftConnector ??= [];
-    const nftConnectorType = envChoice(envVars, "nftConnector", Object.values(NftConnectorType));
-    if (nftConnectorType === NftConnectorType.EntityStorage) {
+    if (envVars.nftConnector === NftConnectorType.EntityStorage) {
         coreConfig.types.nftConnector.push({
             type: NftConnectorType.EntityStorage
         });
     }
-    else if (nftConnectorType === NftConnectorType.Iota) {
+    else if (envVars.nftConnector === NftConnectorType.Iota) {
         const dltConfig = EngineTypeHelper.getConfigOfType(coreConfig, "dltConfig", DltConfigType.Iota);
         const config = {
             ...dltConfig?.options?.config,
@@ -1062,13 +981,12 @@ async function configureNft(coreConfig, envVars) {
  */
 async function configureNotarization(coreConfig, envVars) {
     coreConfig.types.notarizationConnector ??= [];
-    const notarizationConnectorType = envChoice(envVars, "notarizationConnector", Object.values(NotarizationConnectorType));
-    if (notarizationConnectorType === NotarizationConnectorType.EntityStorage) {
+    if (envVars.notarizationConnector === NotarizationConnectorType.EntityStorage) {
         coreConfig.types.notarizationConnector.push({
             type: NotarizationConnectorType.EntityStorage
         });
     }
-    else if (notarizationConnectorType === NotarizationConnectorType.Iota) {
+    else if (envVars.notarizationConnector === NotarizationConnectorType.Iota) {
         const dltConfig = EngineTypeHelper.getConfigOfType(coreConfig, "dltConfig", DltConfigType.Iota);
         coreConfig.types.notarizationConnector.push({
             type: NotarizationConnectorType.Iota,
@@ -1118,13 +1036,12 @@ async function configureImmutableProof(coreConfig, envVars) {
  */
 async function configureIdentity(coreConfig, envVars) {
     coreConfig.types.identityConnector ??= [];
-    const identityConnectorType = envChoice(envVars, "identityConnector", Object.values(IdentityConnectorType));
-    if (identityConnectorType === IdentityConnectorType.EntityStorage) {
+    if (envVars.identityConnector === IdentityConnectorType.EntityStorage) {
         coreConfig.types.identityConnector.push({
             type: IdentityConnectorType.EntityStorage
         });
     }
-    else if (identityConnectorType === IdentityConnectorType.Iota) {
+    else if (envVars.identityConnector === IdentityConnectorType.Iota) {
         const dltConfig = EngineTypeHelper.getConfigOfType(coreConfig, "dltConfig", DltConfigType.Iota);
         coreConfig.types.identityConnector.push({
             type: IdentityConnectorType.Iota,
@@ -1157,13 +1074,12 @@ async function configureIdentity(coreConfig, envVars) {
  */
 async function configureIdentityResolver(coreConfig, envVars) {
     coreConfig.types.identityResolverConnector ??= [];
-    const identityResolverConnectorType = envChoice(envVars, "identityResolverConnector", Object.values(IdentityResolverConnectorType));
-    if (identityResolverConnectorType === IdentityResolverConnectorType.EntityStorage) {
+    if (envVars.identityResolverConnector === IdentityResolverConnectorType.EntityStorage) {
         coreConfig.types.identityResolverConnector.push({
             type: IdentityResolverConnectorType.EntityStorage
         });
     }
-    else if (identityResolverConnectorType === IdentityResolverConnectorType.Iota) {
+    else if (envVars.identityResolverConnector === IdentityResolverConnectorType.Iota) {
         const dltConfig = EngineTypeHelper.getConfigOfType(coreConfig, "dltConfig", DltConfigType.Iota);
         coreConfig.types.identityResolverConnector.push({
             type: IdentityResolverConnectorType.Iota,
@@ -1177,7 +1093,7 @@ async function configureIdentityResolver(coreConfig, envVars) {
             }
         });
     }
-    else if (identityResolverConnectorType === IdentityResolverConnectorType.Universal) {
+    else if (envVars.identityResolverConnector === IdentityResolverConnectorType.Universal) {
         coreConfig.types.identityResolverConnector.push({
             type: IdentityResolverConnectorType.Universal,
             options: {
@@ -1202,8 +1118,7 @@ async function configureIdentityResolver(coreConfig, envVars) {
  */
 async function configureIdentityProfile(coreConfig, envVars) {
     coreConfig.types.identityProfileConnector ??= [];
-    const identityProfileConnectorType = envChoice(envVars, "identityProfileConnector", Object.values(IdentityProfileConnectorType));
-    if (identityProfileConnectorType === IdentityProfileConnectorType.EntityStorage) {
+    if (envVars.identityProfileConnector === IdentityConnectorType.EntityStorage) {
         coreConfig.types.identityProfileConnector.push({
             type: IdentityProfileConnectorType.EntityStorage
         });
@@ -1221,8 +1136,7 @@ async function configureIdentityProfile(coreConfig, envVars) {
  */
 async function configureAttestation(coreConfig, envVars) {
     coreConfig.types.attestationConnector ??= [];
-    const attestationConnectorType = envChoice(envVars, "attestationConnector", Object.values(AttestationConnectorType));
-    if (attestationConnectorType === AttestationConnectorType.Nft) {
+    if (envVars.attestationConnector === AttestationConnectorType.Nft) {
         coreConfig.types.attestationConnector.push({
             type: AttestationConnectorType.Nft
         });
@@ -1284,24 +1198,23 @@ async function configureAuditableItemStream(coreConfig, envVars) {
  * @returns A promise that resolves when the data processing configuration has been applied.
  */
 async function configureDataProcessing(coreConfig, envVars) {
-    coreConfig.types.dataConverterConnector ??= [];
-    const converterConnectors = envListToArray(envVars, "dataConverterConnectors", Object.values(DataConverterConnectorType));
-    for (const converterConnector of converterConnectors) {
-        coreConfig.types.dataConverterConnector.push({
-            type: converterConnector
-        });
-    }
-    coreConfig.types.dataExtractorConnector ??= [];
-    const extractorConnectors = envListToArray(envVars, "dataExtractorConnectors", Object.values(DataExtractorConnectorType));
-    for (const extractorConnector of extractorConnectors) {
-        coreConfig.types.dataExtractorConnector.push({
-            type: extractorConnector
-        });
-    }
-    if (coreConfig.types.dataConverterConnector.length > 0 ||
-        coreConfig.types.dataExtractorConnector.length > 0) {
+    if (envBoolean(envVars, "dataProcessingEnabled", false)) {
         coreConfig.types.dataProcessingComponent ??= [];
         coreConfig.types.dataProcessingComponent.push({ type: DataProcessingComponentType.Service });
+        coreConfig.types.dataConverterConnector ??= [];
+        const converterConnectors = commaSeparatedListToArray(envVars.dataConverterConnectors);
+        for (const converterConnector of converterConnectors) {
+            coreConfig.types.dataConverterConnector.push({
+                type: converterConnector
+            });
+        }
+        coreConfig.types.dataExtractorConnector ??= [];
+        const extractorConnectors = commaSeparatedListToArray(envVars.dataExtractorConnectors);
+        for (const extractorConnector of extractorConnectors) {
+            coreConfig.types.dataExtractorConnector.push({
+                type: extractorConnector
+            });
+        }
     }
 }
 /**
@@ -1336,7 +1249,7 @@ async function configureTrust(coreConfig, envVars) {
             type: TrustComponentType.Service
         });
         coreConfig.types.trustGeneratorComponent ??= [];
-        const trustGeneratorTypes = envListToArray(envVars, "trustGenerators", Object.values(TrustGeneratorComponentType));
+        const trustGeneratorTypes = commaSeparatedListToArray(envVars.trustGenerators);
         for (const trustGeneratorType of trustGeneratorTypes) {
             coreConfig.types.trustGeneratorComponent.push({
                 type: trustGeneratorType,
@@ -1349,11 +1262,12 @@ async function configureTrust(coreConfig, envVars) {
             });
         }
         coreConfig.types.trustVerifierComponent ??= [];
-        const trustVerifierTypes = envListToArray(envVars, "trustVerifiers", Object.values(TrustVerifierComponentType));
+        const trustVerifierTypes = commaSeparatedListToArray(envVars.trustVerifiers);
         for (const trustVerifierType of trustVerifierTypes) {
-            if (trustVerifierType === TrustVerifierComponentType.IdentityAllowDeny) {
+            const type = trustVerifierType;
+            if (type === TrustVerifierComponentType.IdentityAllowDeny) {
                 coreConfig.types.trustVerifierComponent.push({
-                    type: TrustVerifierComponentType.IdentityAllowDeny,
+                    type,
                     options: {
                         config: {
                             allowIdentities: commaSeparatedListToArray(envVars.trustIdentitiesAllow),
@@ -1362,9 +1276,9 @@ async function configureTrust(coreConfig, envVars) {
                     }
                 });
             }
-            else if (trustVerifierType === TrustVerifierComponentType.JwtVerifiableCredential) {
+            else {
                 coreConfig.types.trustVerifierComponent.push({
-                    type: TrustVerifierComponentType.JwtVerifiableCredential
+                    type
                 });
             }
         }
@@ -1442,49 +1356,49 @@ async function configureRightsManagement(coreConfig, envVars) {
             }
         });
         coreConfig.types.rightsManagementPolicyArbiterComponent ??= [];
-        const policyArbiterTypes = envListToArray(envVars, "rightsManagementPolicyArbiters", Object.values(RightsManagementPolicyArbiterComponentType));
+        const policyArbiterTypes = commaSeparatedListToArray(envVars.rightsManagementPolicyArbiters);
         for (const policyArbiterType of policyArbiterTypes) {
             coreConfig.types.rightsManagementPolicyArbiterComponent.push({
                 type: policyArbiterType
             });
         }
         coreConfig.types.rightsManagementPolicyObligationEnforcerComponent ??= [];
-        const policyObligationEnforcerTypes = envListToArray(envVars, "rightsManagementPolicyObligationEnforcers", Object.values(RightsManagementPolicyObligationEnforcerComponentType));
+        const policyObligationEnforcerTypes = commaSeparatedListToArray(envVars.rightsManagementPolicyObligationEnforcers);
         for (const policyObligationEnforcerType of policyObligationEnforcerTypes) {
             coreConfig.types.rightsManagementPolicyObligationEnforcerComponent.push({
                 type: policyObligationEnforcerType
             });
         }
         coreConfig.types.rightsManagementPolicyEnforcementProcessorComponent ??= [];
-        const policyEnforcementProcessTypes = envListToArray(envVars, "rightsManagementPolicyEnforcementProcessors", Object.values(RightsManagementPolicyEnforcementProcessorComponentType));
+        const policyEnforcementProcessTypes = commaSeparatedListToArray(envVars.rightsManagementPolicyEnforcementProcessors);
         for (const policyEnforcementProcessorType of policyEnforcementProcessTypes) {
             coreConfig.types.rightsManagementPolicyEnforcementProcessorComponent.push({
                 type: policyEnforcementProcessorType
             });
         }
         coreConfig.types.rightsManagementPolicyExecutionActionComponent ??= [];
-        const policyExecutionActionTypes = envListToArray(envVars, "rightsManagementPolicyExecutionActions", Object.values(RightsManagementPolicyExecutionActionComponentType));
+        const policyExecutionActionTypes = commaSeparatedListToArray(envVars.rightsManagementPolicyExecutionActions);
         for (const policyExecutionActionType of policyExecutionActionTypes) {
             coreConfig.types.rightsManagementPolicyExecutionActionComponent.push({
                 type: policyExecutionActionType
             });
         }
         coreConfig.types.rightsManagementPolicyInformationSourceComponent ??= [];
-        const policyInformationSourceTypes = envListToArray(envVars, "rightsManagementPolicyInformationSources", Object.values(RightsManagementPolicyInformationSourceComponentType));
+        const policyInformationSourceTypes = commaSeparatedListToArray(envVars.rightsManagementPolicyInformationSources);
         for (const policyInformationSourceType of policyInformationSourceTypes) {
             coreConfig.types.rightsManagementPolicyInformationSourceComponent.push({
                 type: policyInformationSourceType
             });
         }
         coreConfig.types.rightsManagementPolicyRequesterComponent ??= [];
-        const policyRequesterTypes = envListToArray(envVars, "rightsManagementPolicyRequesters", Object.values(RightsManagementPolicyRequesterComponentType));
+        const policyRequesterTypes = commaSeparatedListToArray(envVars.rightsManagementPolicyRequesters);
         for (const policyRequesterType of policyRequesterTypes) {
             coreConfig.types.rightsManagementPolicyRequesterComponent.push({
                 type: policyRequesterType
             });
         }
         coreConfig.types.rightsManagementPolicyNegotiatorComponent ??= [];
-        const policyNegotiatorTypes = envListToArray(envVars, "rightsManagementPolicyNegotiators", Object.values(RightsManagementPolicyNegotiatorComponentType));
+        const policyNegotiatorTypes = commaSeparatedListToArray(envVars.rightsManagementPolicyNegotiators);
         for (const policyNegotiatorType of policyNegotiatorTypes) {
             coreConfig.types.rightsManagementPolicyNegotiatorComponent.push({
                 type: policyNegotiatorType
@@ -1534,7 +1448,7 @@ async function configureFederatedCatalogue(coreConfig, envVars) {
                 }
             });
             coreConfig.types.federatedCatalogueFilterComponent ??= [];
-            const filters = envListToArray(envVars, "federatedCatalogueFilters", Object.values(FederatedCatalogueFilterComponentType));
+            const filters = commaSeparatedListToArray(envVars.federatedCatalogueFilters);
             for (const filter of filters) {
                 coreConfig.types.federatedCatalogueFilterComponent.push({
                     type: filter,
@@ -1657,8 +1571,7 @@ export function isTrustRequired(envVars) {
 export function isBackgroundTasksRequired(envVars) {
     return (envBoolean(envVars, "dataspaceEnabled", false) ||
         isImmutableProofRequired(envVars) ||
-        envBoolean(envVars, "healthEnabled", false) ||
-        commaSeparatedListToArray(envVars.telemetryConnector).includes(TelemetryConnectorType.EntityStorage));
+        envBoolean(envVars, "healthEnabled", false));
 }
 /**
  * Checks if the immutable proof subsystem is required.
@@ -1706,8 +1619,7 @@ export function isTaskSchedulerRequired(envVars) {
         envBoolean(envVars, "dataspaceEnabled", false) ||
         isRightsManagementRequired(envVars) ||
         isAuthEntityStorageRequired(envVars) ||
-        isImmutableProofRequired(envVars) ||
-        isMailboxEnabled(envVars));
+        isImmutableProofRequired(envVars));
 }
 /**
  * Checks if the automation subsystem is required.
@@ -1734,19 +1646,6 @@ export function isTelemetryEnabled(envVars) {
  * @returns True if tracing is enabled.
  */
 export function isTracingEnabled(envVars) {
-    return commaSeparatedListToArray(envVars.tracingConnector).some(t => t === TracingConnectorType.EntityStorage ||
-        t === TracingConnectorType.OpenTelemetry ||
-        t === TracingConnectorType.Console);
-}
-/**
- * Checks if the mailbox subsystem is enabled.
- * Returns true when any component that depends on the mailbox subsystem is enabled.
- * @param envVars The environment variables.
- * @returns True if mailbox is enabled.
- */
-export function isMailboxEnabled(envVars) {
-    return commaSeparatedListToArray(envVars.emailProtocolConnector).some(t => t === EmailProtocolConnectorType.Imap ||
-        t === EmailProtocolConnectorType.Pop3 ||
-        t === EmailProtocolConnectorType.Gmail);
+    return commaSeparatedListToArray(envVars.tracingConnector).some(t => t === TracingConnectorType.EntityStorage || t === TracingConnectorType.OpenTelemetry);
 }
 //# sourceMappingURL=engineEnvBuilder.js.map