@twin.org/node-core 0.9.2-next.1 → 0.9.2-next.10

package/dist/es/builders/engineEnvBuilder.js

@@ -1,12 +1,14 @@
 // Copyright 2024 IOTA Stiftung.
 // SPDX-License-Identifier: Apache-2.0.
 import path from "node:path";
-import { Coerce, Is, Mutex } from "@twin.org/core";
-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, TrustComponentType, TrustVerifierComponentType, VaultConnectorType, WalletConnectorType } from "@twin.org/engine-types";
+import { Is, Mutex } from "@twin.org/core";
+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, 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.
@@ -19,12 +21,12 @@ export async function buildEngineConfiguration(envVars) {
         envVars.stateFilename = path.join(envVars.storageFileRoot, envVars.stateFilename);
     }
     const coreConfig = {
-        debug: Coerce.boolean(envVars.debug) ?? false,
-        silent: Coerce.boolean(envVars.silent) ?? false,
+        debug: envBoolean(envVars, "debug", false),
+        silent: envBoolean(envVars, "silent", false),
         silentLoggers: commaSeparatedListToArray(envVars.loggingSilentComponents),
         types: {}
     };
-    const mutexTimeoutMs = Coerce.integer(envVars.mutexTimeoutMsDefault);
+    const mutexTimeoutMs = envMs(envVars, "mutexTimeoutDefault");
     if (!Is.empty(mutexTimeoutMs)) {
         Mutex.setDefaultTimeoutMs(mutexTimeoutMs);
     }
@@ -42,6 +44,7 @@ export async function buildEngineConfiguration(envVars) {
     await configureEventBus(coreConfig, envVars);
     await configureTelemetry(coreConfig, envVars);
     await configureMetricsCollector(coreConfig, envVars);
+    await configureTracing(coreConfig, envVars);
     await configureMessaging(coreConfig, envVars);
     await configureAutomation(coreConfig, envVars);
     await configureHealth(coreConfig, envVars);
@@ -79,7 +82,7 @@ async function configureEntityStorage(coreConfig, envVars) {
             type: EntityStorageConnectorType.Memory,
             options: {
                 config: {
-                    mutexTimeoutMs: Coerce.integer(envVars.entityStorageMemoryMutexTimeout)
+                    mutexTimeoutMs: envMs(envVars, "entityStorageMutexTimeout")
                 }
             }
         });
@@ -90,7 +93,7 @@ async function configureEntityStorage(coreConfig, envVars) {
             options: {
                 config: {
                     directory: envVars.storageFileRoot ?? "",
-                    mutexTimeoutMs: Coerce.integer(envVars.entityStorageFileMutexTimeout)
+                    mutexTimeoutMs: envMs(envVars, "entityStorageMutexTimeout")
                 },
                 folderPrefix: envVars.entityStorageTablePrefix
             }
@@ -106,7 +109,8 @@ async function configureEntityStorage(coreConfig, envVars) {
                     accessKeyId: envVars.awsDynamodbAccessKeyId,
                     secretAccessKey: envVars.awsDynamodbSecretAccessKey,
                     endpoint: envVars.awsDynamodbEndpoint,
-                    connectionTimeoutMs: Coerce.integer(envVars.awsDynamodbConnectionTimeout)
+                    connectionTimeoutMs: envMs(envVars, "awsDynamodbConnectionTimeout"),
+                    mutexTimeoutMs: envMs(envVars, "entityStorageMutexTimeout")
                 },
                 tablePrefix: envVars.entityStorageTablePrefix
             }
@@ -120,7 +124,8 @@ async function configureEntityStorage(coreConfig, envVars) {
                     endpoint: envVars.azureCosmosdbEndpoint ?? "",
                     key: envVars.azureCosmosdbKey ?? "",
                     databaseId: envVars.azureCosmosdbDatabaseId ?? "",
-                    containerId: envVars.azureCosmosdbContainerId ?? ""
+                    containerId: envVars.azureCosmosdbContainerId ?? "",
+                    mutexTimeoutMs: envMs(envVars, "entityStorageMutexTimeout")
                 },
                 tablePrefix: envVars.entityStorageTablePrefix
             }
@@ -135,7 +140,8 @@ async function configureEntityStorage(coreConfig, envVars) {
                     credentials: envVars.gcpFirestoreCredentials ?? "",
                     databaseId: envVars.gcpFirestoreDatabaseId ?? "",
                     collectionName: envVars.gcpFirestoreCollectionName ?? "",
-                    endpoint: envVars.gcpFirestoreEndpoint ?? ""
+                    endpoint: envVars.gcpFirestoreEndpoint ?? "",
+                    mutexTimeoutMs: envMs(envVars, "entityStorageMutexTimeout")
                 },
                 tablePrefix: envVars.entityStorageTablePrefix
             }
@@ -149,7 +155,12 @@ async function configureEntityStorage(coreConfig, envVars) {
                     hosts: commaSeparatedListToArray(envVars.scylladbHosts),
                     localDataCenter: envVars.scylladbLocalDataCenter ?? "",
                     keyspace: envVars.scylladbKeyspace ?? "",
-                    port: Coerce.integer(envVars.scylladbPort)
+                    port: envInteger(envVars, "scylladbPort"),
+                    mutexTimeoutMs: envMs(envVars, "entityStorageMutexTimeout"),
+                    pool: {
+                        coreConnectionsPerHost: envCount(envVars, "scylladbPoolCoreConnectionsPerHost"),
+                        maxRequestsPerConnection: envCount(envVars, "scylladbPoolMaxRequestsPerConnection")
+                    }
                 },
                 tablePrefix: envVars.entityStorageTablePrefix
             }
@@ -161,10 +172,19 @@ async function configureEntityStorage(coreConfig, envVars) {
             options: {
                 config: {
                     host: envVars.mySqlHost ?? "",
-                    port: Coerce.integer(envVars.mySqlPort),
+                    port: envInteger(envVars, "mySqlPort"),
                     user: envVars.mySqlUser ?? "",
                     password: envVars.mySqlPassword ?? "",
-                    database: envVars.mySqlDatabase ?? ""
+                    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
             }
@@ -176,10 +196,17 @@ async function configureEntityStorage(coreConfig, envVars) {
             options: {
                 config: {
                     host: envVars.mongoDbHost ?? "",
-                    port: Coerce.integer(envVars.mongoDbPort),
+                    port: envInteger(envVars, "mongoDbPort"),
                     user: envVars.mongoDbUser ?? "",
                     password: envVars.mongoDbPassword ?? "",
-                    database: envVars.mongoDbDatabase ?? ""
+                    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
             }
@@ -191,10 +218,17 @@ async function configureEntityStorage(coreConfig, envVars) {
             options: {
                 config: {
                     host: envVars.postgreSqlHost ?? "",
-                    port: Coerce.integer(envVars.postgreSqlPort),
+                    port: envInteger(envVars, "postgreSqlPort"),
                     user: envVars.postgreSqlUser ?? "",
                     password: envVars.postgreSqlPassword ?? "",
-                    database: envVars.postgreSqlDatabase ?? ""
+                    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
             }
@@ -342,19 +376,19 @@ async function configureLogging(coreConfig, envVars) {
                 type: LoggingConnectorType.EntityStorage,
                 options: {
                     config: {
-                        batchSize: Coerce.integer(envVars.loggingBatchSize),
-                        batchIntervalMs: (Coerce.integer(envVars.loggingBatchFlushInterval) ?? 5) * 1000,
-                        retainForMs: (Coerce.integer(envVars.loggingRetainFor) ?? 2880) * 60_000,
-                        maxEntries: Coerce.integer(envVars.loggingMaxEntries),
-                        retentionIntervalMs: (Coerce.integer(envVars.loggingRetentionInterval) ?? 5) * 60_000,
-                        retentionBatchSize: Coerce.integer(envVars.loggingRetentionBatchSize),
-                        mutexTimeoutMs: Coerce.integer(envVars.loggingMutexTimeout)
+                        batchSize: envCount(envVars, "loggingBatchSize"),
+                        batchIntervalMs: envSecToMs(envVars, "loggingBatchFlushInterval"),
+                        retainForMs: envMinToMs(envVars, "loggingRetainFor"),
+                        maxEntries: envCount(envVars, "loggingMaxEntries"),
+                        retentionIntervalMs: envMinToMs(envVars, "loggingRetentionInterval"),
+                        retentionBatchSize: envCount(envVars, "loggingRetentionBatchSize"),
+                        mutexTimeoutMs: envMs(envVars, "loggingMutexTimeout")
                     }
                 }
             });
             additionalConnectorCount++;
         }
-        else if (loggingConnector === LoggingConnectorType.Otel) {
+        else if (loggingConnector === LoggingConnectorType.OpenTelemetry) {
             const otelLoggingConfig = {
                 loggerName: envVars.openTelemetryLoggingLoggerName,
                 loggerVersion: envVars.openTelemetryLoggingLoggerVersion
@@ -370,7 +404,7 @@ async function configureLogging(coreConfig, envVars) {
                 };
             }
             coreConfig.types.loggingConnector.push({
-                type: LoggingConnectorType.Otel,
+                type: LoggingConnectorType.OpenTelemetry,
                 options: {
                     config: otelLoggingConfig
                 }
@@ -384,9 +418,9 @@ async function configureLogging(coreConfig, envVars) {
                     config: {
                         directory: envVars.loggingFileDirectory ?? envVars.storageFileRoot ?? "",
                         filename: envVars.loggingFileFilename,
-                        maxFileSizeBytes: Coerce.integer(envVars.loggingFileMaxFileSizeBytes),
-                        maxRetainedFiles: Coerce.integer(envVars.loggingFileMaxRetainedFiles),
-                        mutexTimeoutMs: Coerce.integer(envVars.loggingMutexTimeout)
+                        maxFileSizeBytes: envCount(envVars, "loggingFileMaxFileSizeBytes"),
+                        maxRetainedFiles: envCount(envVars, "loggingFileMaxRetainedFiles"),
+                        mutexTimeoutMs: envMs(envVars, "loggingMutexTimeout")
                     }
                 }
             });
@@ -489,16 +523,21 @@ async function configureTelemetry(coreConfig, envVars) {
     coreConfig.types.telemetryConnector ??= [];
     if (envVars.telemetryConnector === TelemetryConnectorType.EntityStorage) {
         coreConfig.types.telemetryConnector.push({
-            type: TelemetryConnectorType.EntityStorage
+            type: TelemetryConnectorType.EntityStorage,
+            options: {
+                config: {
+                    mutexTimeoutMs: envMs(envVars, "telemetryMutexTimeout")
+                }
+            }
         });
     }
     else if (envVars.telemetryConnector === TelemetryConnectorType.OpenTelemetry) {
         let readers;
-        if (envVars.openTelemetryReader === "prometheus") {
+        if (envVars.openTelemetryReader === OpenTelemetryReaderTypes.Prometheus) {
             readers = {
                 prometheus: {
                     type: OpenTelemetryReaderTypes.Prometheus,
-                    port: Coerce.integer(envVars.openTelemetryPrometheusPort)
+                    port: envCount(envVars, "openTelemetryPrometheusPort")
                 }
             };
         }
@@ -506,6 +545,7 @@ async function configureTelemetry(coreConfig, envVars) {
             type: TelemetryConnectorType.OpenTelemetry,
             options: {
                 config: {
+                    mutexTimeoutMs: envMs(envVars, "telemetryMutexTimeout"),
                     meterName: envVars.openTelemetryMeterName,
                     meterVersion: envVars.openTelemetryMeterVersion,
                     readers
@@ -526,26 +566,72 @@ async function configureTelemetry(coreConfig, envVars) {
  */
 async function configureMetricsCollector(coreConfig, envVars) {
     if (isTelemetryRequired(envVars)) {
-        const intervalSec = Coerce.integer(envVars.telemetryMetricsCollectorInterval) ?? 60;
         coreConfig.types.metricsCollectorComponent ??= [];
         coreConfig.types.metricsCollectorComponent.push({
             type: MetricsCollectorComponentType.Service,
-            options: { config: { intervalMs: intervalSec * 1000 } },
+            options: {
+                config: {
+                    intervalMs: envSecToMs(envVars, "telemetryMetricsCollectorInterval")
+                }
+            },
             isCloneable: false
         });
-        const maxHistory = Coerce.integer(envVars.telemetryMetricsProducerMaxHistory) ?? 1440;
         coreConfig.types.metricsProducerComponent ??= [];
         const metricsProducers = commaSeparatedListToArray(envVars.telemetryMetricsProducers ??
             [MetricsProducerComponentType.System, MetricsProducerComponentType.Process].join(","));
         for (const producerType of metricsProducers) {
             coreConfig.types.metricsProducerComponent.push({
                 type: producerType,
-                options: { maxHistory },
+                options: { maxHistory: envCount(envVars, "telemetryMetricsProducerMaxHistory") },
                 isCloneable: false
             });
         }
     }
 }
+/**
+ * Configures the tracing.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ * @returns A promise that resolves when the tracing configuration has been applied.
+ */
+async function configureTracing(coreConfig, envVars) {
+    coreConfig.types.tracingConnector ??= [];
+    if (envVars.tracingConnector === TracingConnectorType.EntityStorage) {
+        coreConfig.types.tracingConnector.push({
+            type: TracingConnectorType.EntityStorage,
+            options: {
+                config: {
+                    mutexTimeoutMs: envMs(envVars, "tracingMutexTimeout")
+                }
+            }
+        });
+    }
+    else if (envVars.tracingConnector === TracingConnectorType.OpenTelemetry) {
+        const otelTracingConfig = {
+            tracerName: envVars.openTelemetryTracingTracerName,
+            tracerVersion: envVars.openTelemetryTracingTracerVersion
+        };
+        if (Is.stringValue(envVars.openTelemetryTracingEndpoint)) {
+            otelTracingConfig.exporters = {
+                otlp: {
+                    endpoint: envVars.openTelemetryTracingEndpoint,
+                    processor: envVars.openTelemetryTracingProcessor ??
+                        OpenTelemetryProcessorTypes.Batch
+                }
+            };
+        }
+        coreConfig.types.tracingConnector.push({
+            type: TracingConnectorType.OpenTelemetry,
+            options: {
+                config: otelTracingConfig
+            }
+        });
+    }
+    if (coreConfig.types.tracingConnector.length > 0) {
+        coreConfig.types.tracingComponent ??= [];
+        coreConfig.types.tracingComponent.push({ type: TracingComponentType.Service });
+    }
+}
 /**
  * Configures the automation.
  * @param coreConfig The core config.
@@ -578,13 +664,14 @@ async function configureAutomation(coreConfig, envVars) {
  */
 async function configureHealth(coreConfig, envVars) {
     coreConfig.types.healthComponent ??= [];
-    if (Coerce.boolean(envVars.healthEnabled) ?? false) {
+    if (envBoolean(envVars, "healthEnabled", false)) {
         coreConfig.types.healthComponent.push({
             type: HealthComponentType.Service,
             options: {
                 config: {
-                    healthCheckInterval: (Coerce.integer(envVars.healthInterval) ?? 60) * 1000,
-                    initialInterval: (Coerce.integer(envVars.healthStartupInterval) ?? 2) * 1000
+                    healthCheckInterval: envSecToMs(envVars, "healthInterval"),
+                    healthCheckApplicationInterval: envSecToMs(envVars, "healthApplicationInterval"),
+                    initialInterval: envSecToMs(envVars, "healthStartupInterval")
                 }
             },
             isCloneable: false
@@ -598,7 +685,7 @@ async function configureHealth(coreConfig, envVars) {
  * @returns A promise that resolves when the schema migration configuration has been applied.
  */
 async function configureSchemaMigration(coreConfig, envVars) {
-    const isSchemaMigrationEnabled = Coerce.boolean(envVars.schemaMigrationEnabled) ?? true;
+    const isSchemaMigrationEnabled = envBoolean(envVars, "schemaMigrationEnabled", true);
     if (isSchemaMigrationEnabled) {
         coreConfig.types.schemaVersionMigrationComponent ??= [];
         coreConfig.types.schemaVersionMigrationComponent.push({
@@ -614,7 +701,7 @@ async function configureSchemaMigration(coreConfig, envVars) {
  * @returns A promise that resolves when the platform configuration has been applied.
  */
 async function configurePlatform(coreConfig, envVars) {
-    const isTenantEnabled = Coerce.boolean(envVars.tenantEnabled) ?? false;
+    const isTenantEnabled = envBoolean(envVars, "tenantEnabled", false);
     coreConfig.types.platformComponent ??= [];
     coreConfig.types.platformComponent.push({
         type: PlatformComponentType.Service,
@@ -632,7 +719,7 @@ async function configurePlatform(coreConfig, envVars) {
  * @returns A promise that resolves when the tenant configuration has been applied.
  */
 async function configureTenant(coreConfig, envVars) {
-    const isTenantEnabled = Coerce.boolean(envVars.tenantEnabled) ?? false;
+    const isTenantEnabled = envBoolean(envVars, "tenantEnabled", false);
     if (isTenantEnabled) {
         coreConfig.types.tenantAdminComponent ??= [];
         coreConfig.types.tenantAdminComponent.push({
@@ -652,7 +739,7 @@ async function configureContextIdHandlers(coreConfig, envVars) {
         type: ContextIdHandlerComponentType.Did,
         features: [CONTEXT_ID_HANDLER_FEATURE_DID]
     });
-    if (Coerce.boolean(envVars.tenantEnabled) ?? false) {
+    if (envBoolean(envVars, "tenantEnabled", false)) {
         coreConfig.types.contextIdHandlerComponent.push({
             type: ContextIdHandlerComponentType.Tenant,
             features: [CONTEXT_ID_HANDLER_FEATURE_TENANT]
@@ -666,7 +753,7 @@ async function configureContextIdHandlers(coreConfig, envVars) {
  * @returns A promise that resolves when the messaging configuration has been applied.
  */
 async function configureMessaging(coreConfig, envVars) {
-    if (Coerce.boolean(envVars.messagingEnabled) ?? false) {
+    if (envBoolean(envVars, "messagingEnabled", false)) {
         coreConfig.types.messagingEmailConnector ??= [];
         coreConfig.types.messagingSmsConnector ??= [];
         coreConfig.types.messagingPushNotificationConnector ??= [];
@@ -760,13 +847,14 @@ async function configureFaucet(coreConfig, envVars) {
             type: FaucetConnectorType.EntityStorage
         });
     }
-    else if (envVars.faucetConnector === FaucetConnectorType.Iota) {
+    else if (envVars.faucetConnector === FaucetConnectorType.Iota &&
+        Is.stringValue(envVars.iotaFaucetEndpoint)) {
         const dltConfig = EngineTypeHelper.getConfigOfType(coreConfig, "dltConfig", DltConfigType.Iota);
         coreConfig.types.faucetConnector.push({
             type: FaucetConnectorType.Iota,
             options: {
                 config: {
-                    endpoint: envVars.iotaFaucetEndpoint ?? "",
+                    endpoint: envVars.iotaFaucetEndpoint,
                     clientOptions: dltConfig?.options?.config?.clientOptions ?? { url: "" },
                     network: dltConfig?.options?.config?.network ?? ""
                 }
@@ -868,7 +956,16 @@ async function configureImmutableProof(coreConfig, envVars) {
             type: ImmutableProofComponentType.Service,
             options: {
                 config: {
-                    verificationMethodId: envVars.immutableProofVerificationMethodId
+                    verificationMethodId: envVars.immutableProofVerificationMethodId,
+                    taskRetryCount: envCount(envVars, "immutableProofTaskRetryCount"),
+                    taskRetryInterval: envSecToMs(envVars, "immutableProofTaskRetryInterval"),
+                    taskFailureRetainFor: envMinToMs(envVars, "immutableProofTaskFailureRetainFor"),
+                    sweepIntervalMinutes: envMinutes(envVars, "immutableProofSweepInterval"),
+                    sweepStaleThresholdMs: envMinToMs(envVars, "immutableProofSweepStaleThreshold"),
+                    sweepMaxAttempts: envCount(envVars, "immutableProofSweepMaxAttempts"),
+                    sweepBatchLimit: envCount(envVars, "immutableProofSweepBatchLimit"),
+                    sweepBackoffMs: envMinToMs(envVars, "immutableProofSweepBackoff"),
+                    sweepAssumeRetryableBefore: envDateTime(envVars, "immutableProofSweepAssumeRetryableBefore")
                 }
             }
         });
@@ -897,8 +994,10 @@ async function configureIdentity(coreConfig, envVars) {
                     identityPkgId: Is.stringValue(envVars.iotaIdentityPackageId)
                         ? envVars.iotaIdentityPackageId
                         : undefined,
-                    walletAddressIndex: Coerce.integer(envVars.identityWalletAddressIndex) ?? 0,
-                    didResolutionCacheTtlMs: Coerce.integer(envVars.identityDidResolutionCacheTtlMs)
+                    walletAddressIndex: envCount(envVars, "identityWalletAddressIndex") ?? 0,
+                    didResolutionCacheTtlMs: envMs(envVars, "identityDidResolutionCacheTtl"),
+                    didResolutionCacheCapacity: envCount(envVars, "identityDidResolutionCacheCapacity"),
+                    didResolutionCacheMutexTimeoutMs: envMs(envVars, "identityDidResolutionCacheMutexTimeout")
                 }
             }
         });
@@ -1002,13 +1101,13 @@ async function configureAttestation(coreConfig, envVars) {
  * @returns A promise that resolves when the auditable item graph configuration has been applied.
  */
 async function configureAuditableItemGraph(coreConfig, envVars) {
-    if (Coerce.boolean(envVars.auditableItemGraphEnabled) ?? false) {
+    if (envBoolean(envVars, "auditableItemGraphEnabled", false)) {
         coreConfig.types.auditableItemGraphComponent ??= [];
         coreConfig.types.auditableItemGraphComponent.push({
             type: AuditableItemGraphComponentType.Service,
             options: {
                 config: {
-                    mutexTimeoutMs: Coerce.integer(envVars.auditableItemGraphMutexTimeout)
+                    mutexTimeoutMs: envMs(envVars, "auditableItemGraphMutexTimeout")
                 }
             }
         });
@@ -1021,13 +1120,13 @@ async function configureAuditableItemGraph(coreConfig, envVars) {
  * @returns A promise that resolves when the auditable item stream configuration has been applied.
  */
 async function configureAuditableItemStream(coreConfig, envVars) {
-    if (Coerce.boolean(envVars.auditableItemStreamEnabled) ?? false) {
+    if (envBoolean(envVars, "auditableItemStreamEnabled", false)) {
         coreConfig.types.auditableItemStreamComponent ??= [];
         coreConfig.types.auditableItemStreamComponent.push({
             type: AuditableItemStreamComponentType.Service,
             options: {
                 config: {
-                    mutexTimeoutMs: Coerce.integer(envVars.auditableItemStreamMutexTimeout)
+                    mutexTimeoutMs: envMs(envVars, "auditableItemStreamMutexTimeout")
                 }
             }
         });
@@ -1040,7 +1139,7 @@ async function configureAuditableItemStream(coreConfig, envVars) {
  * @returns A promise that resolves when the data processing configuration has been applied.
  */
 async function configureDataProcessing(coreConfig, envVars) {
-    if (Coerce.boolean(envVars.dataProcessingEnabled) ?? false) {
+    if (envBoolean(envVars, "dataProcessingEnabled", false)) {
         coreConfig.types.dataProcessingComponent ??= [];
         coreConfig.types.dataProcessingComponent.push({ type: DataProcessingComponentType.Service });
         coreConfig.types.dataConverterConnector ??= [];
@@ -1066,13 +1165,13 @@ async function configureDataProcessing(coreConfig, envVars) {
  * @returns A promise that resolves when the document management configuration has been applied.
  */
 async function configureDocumentManagement(coreConfig, envVars) {
-    if (Coerce.boolean(envVars.documentManagementEnabled) ?? false) {
+    if (envBoolean(envVars, "documentManagementEnabled", false)) {
         coreConfig.types.documentManagementComponent ??= [];
         coreConfig.types.documentManagementComponent.push({
             type: DocumentManagementComponentType.Service,
             options: {
                 config: {
-                    mutexTimeoutMs: Coerce.integer(envVars.documentManagementMutexTimeout)
+                    mutexTimeoutMs: envMs(envVars, "documentManagementMutexTimeout")
                 }
             }
         });
@@ -1098,7 +1197,7 @@ async function configureTrust(coreConfig, envVars) {
                 options: {
                     config: {
                         verificationMethodId: envVars.trustVerificationMethodId ?? "",
-                        tokenTtlInSeconds: Coerce.integer(envVars.trustJwtTtl)
+                        tokenTtlInSeconds: envCount(envVars, "trustJwtTtl")
                     }
                 }
             });
@@ -1183,7 +1282,7 @@ async function configureRightsManagement(coreConfig, envVars) {
                 config: {
                     callbackPath: rightsManagementPath,
                     includeErrorDetails: coreConfig.debug ?? false,
-                    mutexTimeoutMs: Coerce.integer(envVars.rightsManagementMutexTimeout)
+                    mutexTimeoutMs: envMs(envVars, "rightsManagementMutexTimeout")
                 }
             },
             isDefault: true
@@ -1193,7 +1292,7 @@ async function configureRightsManagement(coreConfig, envVars) {
             type: RightsManagementPnapComponentType.Service,
             options: {
                 config: {
-                    mutexTimeoutMs: Coerce.integer(envVars.rightsManagementMutexTimeout)
+                    mutexTimeoutMs: envMs(envVars, "rightsManagementMutexTimeout")
                 }
             }
         });
@@ -1276,7 +1375,7 @@ async function configureFederatedCatalogue(coreConfig, envVars) {
                 type: FederatedCatalogueComponentType.RestClient,
                 options: {
                     endpoint: envVars.federatedCatalogueRemoteEndpoint,
-                    pathPrefix: envVars.federatedCatalogueRestClientPathPrefix ?? "federated-catalogue"
+                    pathPrefix: envVars.federatedCatalogueRestClientPathPrefix ?? "catalog"
                 }
             });
         }
@@ -1285,7 +1384,7 @@ async function configureFederatedCatalogue(coreConfig, envVars) {
                 type: FederatedCatalogueComponentType.Service,
                 options: {
                     config: {
-                        mutexTimeoutMs: Coerce.integer(envVars.federatedCatalogueMutexTimeout)
+                        mutexTimeoutMs: envMs(envVars, "federatedCatalogueMutexTimeout")
                     }
                 }
             });
@@ -1307,7 +1406,7 @@ async function configureFederatedCatalogue(coreConfig, envVars) {
  * @returns A promise that resolves when the dataspace configuration has been applied.
  */
 async function configureDataspace(coreConfig, envVars) {
-    if (Coerce.boolean(envVars.dataspaceEnabled) ?? false) {
+    if (envBoolean(envVars, "dataspaceEnabled", false)) {
         coreConfig.types.dataspaceControlPlaneComponent ??= [];
         // We add a multi instance REST client for remote/consumer-initiated transfers.
         coreConfig.types.dataspaceControlPlaneComponent.push({
@@ -1318,8 +1417,6 @@ async function configureDataspace(coreConfig, envVars) {
             isMultiInstance: true,
             features: ["remote"]
         });
-        const stalledNegotiationTimeout = Coerce.integer(envVars.dataspaceStalledNegotiationTimeout);
-        const stalledTransferTimeout = Coerce.integer(envVars.dataspaceStalledTransferTimeout);
         coreConfig.types.dataspaceControlPlaneComponent.push({
             type: DataspaceControlPlaneComponentType.Service,
             options: {
@@ -1330,30 +1427,29 @@ async function configureDataspace(coreConfig, envVars) {
                     // Base mount path of the data plane only; the transfer handlers append the
                     // sub-paths themselves (`/entities` for PULL, `/inbox` for PUSH).
                     dataPlanePath: envVars.dataspaceDataPlanePath,
-                    autoStartTransfers: Coerce.boolean(envVars.dataspaceAutoStartTransfers),
-                    stalledNegotiationTimeoutMs: !Is.empty(stalledNegotiationTimeout)
-                        ? stalledNegotiationTimeout * 1000
-                        : undefined,
-                    stalledTransferTimeoutMs: !Is.empty(stalledTransferTimeout)
-                        ? stalledTransferTimeout * 1000
-                        : undefined
+                    autoStartTransfers: envBoolean(envVars, "dataspaceAutoStartTransfers", false),
+                    stalledNegotiationTimeoutMs: envSecToMs(envVars, "dataspaceStalledNegotiationTimeout"),
+                    stalledTransferTimeoutMs: envSecToMs(envVars, "dataspaceStalledTransferTimeout"),
+                    providerTransferIdleTimeoutMs: envSecToMs(envVars, "dataspaceProviderTransferIdleTimeout"),
+                    providerTransferPolicySweepIntervalMs: envSecToMs(envVars, "dataspaceProviderTransferPolicySweepInterval")
                 }
             },
             isDefault: true
         });
-        const retainActivityLogsFor = Coerce.integer(envVars.dataspaceRetainActivityLogsFor);
-        const activityLogsCleanUpInterval = Coerce.integer(envVars.dataspaceActivityLogsCleanupInterval);
         coreConfig.types.dataspaceDataPlaneComponent ??= [];
         coreConfig.types.dataspaceDataPlaneComponent.push({
             type: DataspaceDataPlaneComponentType.Service,
             options: {
                 config: {
-                    retainActivityLogsForMs: !Is.empty(retainActivityLogsFor)
-                        ? retainActivityLogsFor * 1000
-                        : undefined,
-                    activityLogsCleanUpIntervalMs: !Is.empty(activityLogsCleanUpInterval)
-                        ? activityLogsCleanUpInterval * 1000
-                        : undefined
+                    retainActivityLogsForMs: envSecToMs(envVars, "dataspaceRetainActivityLogsFor"),
+                    activityLogsCleanUpIntervalMs: envSecToMs(envVars, "dataspaceActivityLogsCleanupInterval"),
+                    retryCount: envCount(envVars, "dataspaceRetryCount"),
+                    pushRetryCount: envCount(envVars, "dataspacePushRetryCount"),
+                    pushRetryBaseDelayMs: envMs(envVars, "dataspacePushRetryBaseDelay"),
+                    pushTimeoutMs: envMs(envVars, "dataspacePushTimeout"),
+                    pushSubscriptionCleanupIntervalMs: envMs(envVars, "dataspacePushSubscriptionCleanupInterval"),
+                    agreementCacheTtlMs: envMs(envVars, "dataspaceAgreementCacheTtl"),
+                    agreementCacheMutexTimeoutMs: envMs(envVars, "dataspaceAgreementCacheMutexTimeout")
                 }
             }
         });
@@ -1385,26 +1481,15 @@ async function configureDlt(coreConfig, envVars) {
                         url: envVars.iotaNodeEndpoint ?? ""
                     },
                     network: envVars.iotaNetwork ?? "",
-                    coinType: Coerce.integer(envVars.iotaCoinType),
+                    coinType: envCount(envVars, "iotaCoinType"),
                     gasStation: gasStationConfig,
-                    gasBudget: Coerce.integer(envVars.iotaGasBudget),
-                    gasReservationDuration: Coerce.integer(envVars.iotaGasReservationDuration)
+                    gasBudget: envCount(envVars, "iotaGasBudget"),
+                    gasReservationDuration: envSeconds(envVars, "iotaGasReservationDuration")
                 }
             }
         });
     }
 }
-/**
- * Converts a comma separated list to an array.
- * @param value The comma separated list.
- * @returns The array.
- */
-function commaSeparatedListToArray(value) {
-    return (value ?? "")
-        .split(",")
-        .map(item => item.trim())
-        .filter(item => item.length > 0);
-}
 /**
  * Checks if the trust subsystem is required.
  * Returns true when any component that depends on the trust subsystem is enabled.
@@ -1413,7 +1498,7 @@ function commaSeparatedListToArray(value) {
  */
 export function isTrustRequired(envVars) {
     return (isRightsManagementRequired(envVars) ||
-        (Coerce.boolean(envVars.dataspaceEnabled) ?? false) ||
+        envBoolean(envVars, "dataspaceEnabled", false) ||
         isFederatedCatalogueRequired(envVars));
 }
 /**
@@ -1423,7 +1508,7 @@ export function isTrustRequired(envVars) {
  * @returns True if dataspace or verifiable storage is enabled.
  */
 export function isBackgroundTasksRequired(envVars) {
-    return (Coerce.boolean(envVars.dataspaceEnabled) ?? false) || isImmutableProofRequired(envVars);
+    return envBoolean(envVars, "dataspaceEnabled", false) || isImmutableProofRequired(envVars);
 }
 /**
  * Checks if the immutable proof subsystem is required.
@@ -1432,9 +1517,9 @@ export function isBackgroundTasksRequired(envVars) {
  * @returns True if verifiable storage is enabled.
  */
 export function isImmutableProofRequired(envVars) {
-    return ((Coerce.boolean(envVars.auditableItemGraphEnabled) ?? false) ||
-        (Coerce.boolean(envVars.auditableItemStreamEnabled) ?? false) ||
-        (Coerce.boolean(envVars.documentManagementEnabled) ?? false));
+    return (envBoolean(envVars, "auditableItemGraphEnabled", false) ||
+        envBoolean(envVars, "auditableItemStreamEnabled", false) ||
+        envBoolean(envVars, "documentManagementEnabled", false));
 }
 /**
  * Checks if the federated catalogue subsystem is required.
@@ -1443,10 +1528,10 @@ export function isImmutableProofRequired(envVars) {
  * @returns True if the federated catalogue is required.
  */
 export function isFederatedCatalogueRequired(envVars) {
-    return ((Coerce.boolean(envVars.federatedCatalogueEnabled) ?? false) ||
+    return (envBoolean(envVars, "federatedCatalogueEnabled", false) ||
         Is.stringValue(envVars.federatedCatalogueRemoteEndpoint) ||
         Is.stringValue(envVars.federatedCatalogueFilters) ||
-        (Coerce.boolean(envVars.dataspaceEnabled) ?? false));
+        envBoolean(envVars, "dataspaceEnabled", false));
 }
 /**
  * Checks if the rights management subsystem is required.
@@ -1458,7 +1543,7 @@ export function isFederatedCatalogueRequired(envVars) {
  * @returns True if rights management is enabled.
  */
 export function isRightsManagementRequired(envVars) {
-    return Coerce.boolean(envVars.dataspaceEnabled) ?? false;
+    return envBoolean(envVars, "dataspaceEnabled", false);
 }
 /**
  * Checks if the task scheduler subsystem is required.
@@ -1467,10 +1552,11 @@ export function isRightsManagementRequired(envVars) {
  * @returns True if task scheduler is enabled.
  */
 export function isTaskSchedulerRequired(envVars) {
-    return ((Coerce.boolean(envVars.taskSchedulerEnabled) ?? false) ||
-        (Coerce.boolean(envVars.dataspaceEnabled) ?? false) ||
+    return (envBoolean(envVars, "taskSchedulerEnabled", false) ||
+        envBoolean(envVars, "dataspaceEnabled", false) ||
         isRightsManagementRequired(envVars) ||
-        isAuthEntityStorageRequired(envVars));
+        isAuthEntityStorageRequired(envVars) ||
+        isImmutableProofRequired(envVars));
 }
 /**
  * Checks if the automation subsystem is required.