@twin.org/node-core 0.0.3-next.4 → 0.0.3-next.40

package/dist/es/builders/engineEnvBuilder.js

@@ -2,9 +2,10 @@
 // SPDX-License-Identifier: Apache-2.0.
 import path from "node:path";
 import { Coerce, Is } from "@twin.org/core";
-import { AttestationComponentType, AttestationConnectorType, AuditableItemGraphComponentType, AuditableItemStreamComponentType, AuthenticationGeneratorComponentType, BackgroundTaskConnectorType, BlobStorageComponentType, BlobStorageConnectorType, ContextIdHandlerComponentType, DataConverterConnectorType, DataExtractorConnectorType, DataProcessingComponentType, DataSpaceConnectorComponentType, DltConfigType, DocumentManagementComponentType, EngineTypeHelper, EntityStorageConnectorType, EventBusComponentType, EventBusConnectorType, FaucetConnectorType, FederatedCatalogueComponentType, IdentityComponentType, IdentityConnectorType, IdentityProfileComponentType, IdentityProfileConnectorType, IdentityResolverComponentType, IdentityResolverConnectorType, ImmutableProofComponentType, LoggingComponentType, LoggingConnectorType, MessagingAdminComponentType, MessagingComponentType, MessagingEmailConnectorType, MessagingPushNotificationConnectorType, MessagingSmsConnectorType, NftComponentType, NftConnectorType, RightsManagementDapComponentType, RightsManagementDarpComponentType, RightsManagementPapComponentType, RightsManagementPdpComponentType, RightsManagementPepComponentType, RightsManagementPipComponentType, RightsManagementPmpComponentType, RightsManagementPnapComponentType, RightsManagementPnpComponentType, RightsManagementPxpComponentType, SynchronisedStorageComponentType, TaskSchedulerComponentType, TelemetryComponentType, TelemetryConnectorType, TenantAdminComponentType, VaultConnectorType, VerifiableStorageComponentType, VerifiableStorageConnectorType, WalletConnectorType } from "@twin.org/engine-types";
-import { DataAccessPointRestClient, PolicyNegotiationPointRestClient } from "@twin.org/rights-management-rest-client";
-import { ATTESTATION_VERIFICATION_METHOD_ID, BLOB_STORAGE_ENCRYPTION_KEY_ID, CONTEXT_ID_HANDLER_FEATURE_DID, CONTEXT_ID_HANDLER_FEATURE_TENANT, IMMUTABLE_PROOF_VERIFICATION_METHOD_ID, SYNCHRONISED_STORAGE_BLOB_STORAGE_ENCRYPTION_KEY_ID, VC_AUTHENTICATION_VERIFICATION_METHOD_ID } from "../defaults.js";
+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, RightsManagementPapComponentType, RightsManagementPdpComponentType, RightsManagementPepComponentType, RightsManagementPipComponentType, RightsManagementPmpComponentType, RightsManagementPnapComponentType, RightsManagementPnpComponentType, RightsManagementPxpComponentType, SynchronisedStorageComponentType, TaskSchedulerComponentType, TelemetryComponentType, TelemetryConnectorType, TenantAdminComponentType, TrustComponentType, UrlTransformerComponentType, VaultConnectorType, VerifiableStorageComponentType, VerifiableStorageConnectorType, WalletConnectorType } from "@twin.org/engine-types";
+import { OpenTelemetryReaderTypes } from "@twin.org/telemetry-connector-opentelemetry";
+import { CONTEXT_ID_HANDLER_FEATURE_DID, CONTEXT_ID_HANDLER_FEATURE_TENANT } from "../defaults.js";
+import { isAuthEntityStorageRequired } from "./engineServerEnvBuilder.js";
 /**
  * Build the engine core configuration from environment variables.
  * @param envVars The environment variables.
@@ -19,6 +20,7 @@ export async function buildEngineConfiguration(envVars, contextIdKeys) {
     }
     const coreConfig = {
         debug: Coerce.boolean(envVars.debug) ?? false,
+        silent: Coerce.boolean(envVars.silent) ?? false,
         types: {}
     };
     await configureTenant(coreConfig, envVars);
@@ -32,11 +34,17 @@ export async function buildEngineConfiguration(envVars, contextIdKeys) {
     await configureTaskScheduler(coreConfig, envVars);
     await configureEventBus(coreConfig, envVars);
     await configureTelemetry(coreConfig, envVars);
+    await configureMetricsCollector(coreConfig, envVars);
     await configureMessaging(coreConfig, envVars);
+    await configureAutomation(coreConfig, envVars);
+    await configureHealth(coreConfig, envVars);
+    await configureUrlTransformer(coreConfig, envVars);
     await configureFaucet(coreConfig, envVars);
     await configureWallet(coreConfig, envVars);
     await configureNft(coreConfig, envVars);
+    await configureNotarization(coreConfig, envVars);
     await configureVerifiableStorage(coreConfig, envVars);
+    await configureImmutableProof(coreConfig, envVars);
     await configureIdentity(coreConfig, envVars);
     await configureIdentityResolver(coreConfig, envVars);
     await configureIdentityProfile(coreConfig, envVars);
@@ -45,11 +53,11 @@ export async function buildEngineConfiguration(envVars, contextIdKeys) {
     await configureAuditableItemGraph(coreConfig, envVars);
     await configureAuditableItemStream(coreConfig, envVars);
     await configureDocumentManagement(coreConfig, envVars);
-    await configureVerifiableCredentialAuthentication(coreConfig, envVars);
+    await configureTrust(coreConfig, envVars);
     await configureRightsManagement(coreConfig, envVars);
     await configureSynchronisedStorage(coreConfig, envVars);
     await configureFederatedCatalogue(coreConfig, envVars);
-    await configureDataSpaceConnector(coreConfig, envVars);
+    await configureDataspace(coreConfig, envVars);
     return coreConfig;
 }
 /**
@@ -60,7 +68,7 @@ export async function buildEngineConfiguration(envVars, contextIdKeys) {
 async function configureEntityStorage(coreConfig, envVars) {
     coreConfig.types ??= {};
     coreConfig.types.entityStorageConnector ??= [];
-    const entityStorageConnectorTypes = envVars.entityStorageConnectorType?.split(",") ?? [];
+    const entityStorageConnectorTypes = commaSeparatedListToArray(envVars.entityStorageConnectorType);
     if (entityStorageConnectorTypes.includes(EntityStorageConnectorType.Memory)) {
         coreConfig.types.entityStorageConnector.push({
             type: EntityStorageConnectorType.Memory
@@ -84,7 +92,8 @@ async function configureEntityStorage(coreConfig, envVars) {
                     authMode: envVars.awsDynamodbAuthMode,
                     accessKeyId: envVars.awsDynamodbAccessKeyId,
                     secretAccessKey: envVars.awsDynamodbSecretAccessKey,
-                    endpoint: envVars.awsDynamodbEndpoint
+                    endpoint: envVars.awsDynamodbEndpoint,
+                    connectionTimeoutMs: Coerce.integer(envVars.awsDynamodbConnectionTimeoutMs)
                 },
                 tablePrefix: envVars.entityStorageTablePrefix
             }
@@ -124,7 +133,7 @@ async function configureEntityStorage(coreConfig, envVars) {
             type: EntityStorageConnectorType.ScyllaDb,
             options: {
                 config: {
-                    hosts: envVars.scylladbHosts?.split(",") ?? [],
+                    hosts: commaSeparatedListToArray(envVars.scylladbHosts),
                     localDataCenter: envVars.scylladbLocalDataCenter ?? "",
                     keyspace: envVars.scylladbKeyspace ?? "",
                     port: Coerce.integer(envVars.scylladbPort)
@@ -179,15 +188,6 @@ async function configureEntityStorage(coreConfig, envVars) {
         });
     }
     const defaultEntityStorageConnectorType = envVars.entityStorageConnectorDefault ?? entityStorageConnectorTypes[0];
-    if (entityStorageConnectorTypes.includes(EntityStorageConnectorType.Synchronised)) {
-        // For synchronised storage we use the default connector as the one we wrap for real DB operations
-        coreConfig.types.entityStorageConnector.push({
-            type: EntityStorageConnectorType.Synchronised,
-            options: {
-                entityStorageConnectorType: defaultEntityStorageConnectorType
-            }
-        });
-    }
     if (Is.arrayValue(entityStorageConnectorTypes)) {
         for (const config of coreConfig.types.entityStorageConnector) {
             if (config.type === defaultEntityStorageConnectorType) {
@@ -204,7 +204,7 @@ async function configureEntityStorage(coreConfig, envVars) {
  */
 async function configureBlobStorage(coreConfig, envVars) {
     coreConfig.types.blobStorageConnector ??= [];
-    const blobStorageConnectorTypes = envVars.blobStorageConnectorType?.split(",") ?? [];
+    const blobStorageConnectorTypes = commaSeparatedListToArray(envVars.blobStorageConnectorType);
     if (blobStorageConnectorTypes.includes(BlobStorageConnectorType.Memory)) {
         coreConfig.types.blobStorageConnector.push({
             type: BlobStorageConnectorType.Memory
@@ -301,7 +301,7 @@ async function configureBlobStorage(coreConfig, envVars) {
             options: {
                 config: {
                     vaultKeyId: (envVars.blobStorageEnableEncryption ?? false)
-                        ? (envVars.blobStorageEncryptionKeyId ?? BLOB_STORAGE_ENCRYPTION_KEY_ID)
+                        ? envVars.blobStorageEncryptionKeyId
                         : undefined
                 }
             }
@@ -315,7 +315,7 @@ async function configureBlobStorage(coreConfig, envVars) {
  */
 async function configureLogging(coreConfig, envVars) {
     coreConfig.types.loggingConnector ??= [];
-    const loggingConnectorTypes = (envVars.loggingConnector ?? "").split(",");
+    const loggingConnectorTypes = commaSeparatedListToArray(envVars.loggingConnector);
     let additionalConnectorCount = 0;
     for (const loggingConnector of loggingConnectorTypes) {
         if (loggingConnector === LoggingConnectorType.Console) {
@@ -369,7 +369,12 @@ async function configureVault(coreConfig, envVars) {
     coreConfig.types.vaultConnector ??= [];
     if (envVars.vaultConnector === VaultConnectorType.EntityStorage) {
         coreConfig.types.vaultConnector.push({
-            type: VaultConnectorType.EntityStorage
+            type: VaultConnectorType.EntityStorage,
+            options: {
+                config: {
+                    prefix: envVars.vaultPrefix
+                }
+            }
         });
     }
     else if (envVars.vaultConnector === VaultConnectorType.Hashicorp) {
@@ -378,7 +383,8 @@ async function configureVault(coreConfig, envVars) {
             options: {
                 config: {
                     endpoint: envVars.hashicorpVaultEndpoint ?? "",
-                    token: envVars.hashicorpVaultToken ?? ""
+                    token: envVars.hashicorpVaultToken ?? "",
+                    prefix: envVars.vaultPrefix
                 }
             }
         });
@@ -390,10 +396,10 @@ async function configureVault(coreConfig, envVars) {
  * @param envVars The environment variables.
  */
 async function configureBackgroundTask(coreConfig, envVars) {
-    coreConfig.types.backgroundTaskConnector ??= [];
-    if (envVars.backgroundTaskConnector === BackgroundTaskConnectorType.EntityStorage) {
-        coreConfig.types.backgroundTaskConnector.push({
-            type: BackgroundTaskConnectorType.EntityStorage
+    coreConfig.types.backgroundTaskComponent ??= [];
+    if (isBackgroundTasksRequired(envVars)) {
+        coreConfig.types.backgroundTaskComponent.push({
+            type: BackgroundTaskComponentType.Service
         });
     }
 }
@@ -426,11 +432,120 @@ async function configureTelemetry(coreConfig, envVars) {
             type: TelemetryConnectorType.EntityStorage
         });
     }
+    else if (envVars.telemetryConnector === TelemetryConnectorType.OpenTelemetry) {
+        let readers;
+        if (envVars.openTelemetryReader === "prometheus") {
+            readers = {
+                prometheus: {
+                    type: OpenTelemetryReaderTypes.Prometheus,
+                    port: Coerce.integer(envVars.openTelemetryPrometheusPort)
+                }
+            };
+        }
+        coreConfig.types.telemetryConnector.push({
+            type: TelemetryConnectorType.OpenTelemetry,
+            options: {
+                config: {
+                    meterName: envVars.openTelemetryMeterName,
+                    meterVersion: envVars.openTelemetryMeterVersion,
+                    readers
+                }
+            }
+        });
+    }
     if (coreConfig.types.telemetryConnector.length > 0) {
         coreConfig.types.telemetryComponent ??= [];
         coreConfig.types.telemetryComponent.push({ type: TelemetryComponentType.Service });
     }
 }
+/**
+ * Configures the metrics producers and orchestrator service.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ */
+async function configureMetricsCollector(coreConfig, envVars) {
+    if (isTelemetryRequired(envVars)) {
+        const intervalSec = Coerce.integer(envVars.telemetryMetricsCollectorIntervalSeconds) ?? 60;
+        coreConfig.types.metricsCollectorComponent ??= [];
+        coreConfig.types.metricsCollectorComponent.push({
+            type: MetricsCollectorComponentType.Service,
+            options: { config: { intervalMs: intervalSec * 1000 } }
+        });
+        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 }
+            });
+        }
+    }
+}
+/**
+ * Configures the automation.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ */
+async function configureAutomation(coreConfig, envVars) {
+    coreConfig.types.automationComponent ??= [];
+    if (isAutomationRequired(envVars)) {
+        coreConfig.types.automationComponent.push({
+            type: AutomationComponentType.Service
+        });
+        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
+                });
+            }
+        }
+    }
+}
+/**
+ * Configures the health.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ */
+async function configureHealth(coreConfig, envVars) {
+    coreConfig.types.healthComponent ??= [];
+    if (Coerce.boolean(envVars.healthEnabled) ?? false) {
+        coreConfig.types.healthComponent.push({
+            type: HealthComponentType.Service,
+            options: {
+                config: {
+                    healthCheckInterval: (Coerce.integer(envVars.healthIntervalSeconds) ?? 60) * 1000,
+                    initialInterval: (Coerce.integer(envVars.healthStartupIntervalSeconds) ?? 2) * 1000
+                }
+            }
+        });
+    }
+}
+/**
+ * Configures the url transformer.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ */
+async function configureUrlTransformer(coreConfig, envVars) {
+    coreConfig.types.urlTransformerComponent ??= [];
+    if (isUrlTransformerRequired(envVars) ?? false) {
+        coreConfig.types.urlTransformerComponent.push({
+            type: UrlTransformerComponentType.Service,
+            options: {
+                config: {
+                    paramEncryptionKeyName: envVars.urlTransformerEncryptionKeyId,
+                    queryParamNames: {
+                        tenant: "tenant-token"
+                    }
+                }
+            }
+        });
+    }
+}
 /**
  * Configures the tenant.
  * @param coreConfig The core config.
@@ -528,7 +643,7 @@ async function configureMessaging(coreConfig, envVars) {
                         accessKeyId: envVars.awsSesAccessKeyId,
                         secretAccessKey: envVars.awsSesSecretAccessKey,
                         endpoint: envVars.awsSesEndpoint,
-                        applicationsSettings: Is.json(envVars.awsMessagingPushNotificationApplications)
+                        applicationsSettings: Is.array(envVars.awsMessagingPushNotificationApplications)
                             ? JSON.parse(envVars.awsMessagingPushNotificationApplications)
                             : []
                     }
@@ -617,6 +732,32 @@ async function configureNft(coreConfig, envVars) {
         coreConfig.types.nftComponent.push({ type: NftComponentType.Service });
     }
 }
+/**
+ * Configures the notarization.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ */
+async function configureNotarization(coreConfig, envVars) {
+    coreConfig.types.notarizationConnector ??= [];
+    if (envVars.notarizationConnector === NotarizationConnectorType.EntityStorage) {
+        coreConfig.types.notarizationConnector.push({
+            type: NotarizationConnectorType.EntityStorage
+        });
+    }
+    else if (envVars.notarizationConnector === NotarizationConnectorType.Iota) {
+        const dltConfig = EngineTypeHelper.getConfigOfType(coreConfig, "dltConfig", DltConfigType.Iota);
+        coreConfig.types.notarizationConnector.push({
+            type: NotarizationConnectorType.Iota,
+            options: {
+                config: dltConfig?.options?.config ?? {}
+            }
+        });
+    }
+    if (coreConfig.types.notarizationConnector.length > 0) {
+        coreConfig.types.notarizationComponent ??= [];
+        coreConfig.types.notarizationComponent.push({ type: NotarizationComponentType.Service });
+    }
+}
 /**
  * Configures the verifiable storage.
  * @param coreConfig The core config.
@@ -643,12 +784,21 @@ async function configureVerifiableStorage(coreConfig, envVars) {
         coreConfig.types.verifiableStorageComponent.push({
             type: VerifiableStorageComponentType.Service
         });
+    }
+}
+/**
+ * Configures the immutable proof.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ */
+async function configureImmutableProof(coreConfig, envVars) {
+    if (isImmutableProofRequired(envVars)) {
         coreConfig.types.immutableProofComponent ??= [];
         coreConfig.types.immutableProofComponent.push({
             type: ImmutableProofComponentType.Service,
             options: {
                 config: {
-                    verificationMethodId: envVars.immutableProofVerificationMethodId ?? IMMUTABLE_PROOF_VERIFICATION_METHOD_ID
+                    verificationMethodId: envVars.immutableProofVerificationMethodId
                 }
             }
         });
@@ -671,7 +821,10 @@ async function configureIdentity(coreConfig, envVars) {
         coreConfig.types.identityConnector.push({
             type: IdentityConnectorType.Iota,
             options: {
-                config: dltConfig?.options?.config ?? {}
+                config: {
+                    ...(dltConfig?.options?.config ?? {}),
+                    walletAddressIndex: Coerce.integer(envVars.identityWalletAddressIndex) ?? 0
+                }
             }
         });
     }
@@ -753,7 +906,7 @@ async function configureAttestation(coreConfig, envVars) {
             type: AttestationComponentType.Service,
             options: {
                 config: {
-                    verificationMethodId: envVars.attestationVerificationMethodId ?? ATTESTATION_VERIFICATION_METHOD_ID
+                    verificationMethodId: envVars.attestationVerificationMethodId
                 }
             }
         });
@@ -795,27 +948,18 @@ async function configureDataProcessing(coreConfig, envVars) {
         coreConfig.types.dataProcessingComponent ??= [];
         coreConfig.types.dataProcessingComponent.push({ type: DataProcessingComponentType.Service });
         coreConfig.types.dataConverterConnector ??= [];
-        const converterConnectors = envVars.dataConverterConnectors?.split(",") ?? [];
+        const converterConnectors = commaSeparatedListToArray(envVars.dataConverterConnectors);
         for (const converterConnector of converterConnectors) {
-            if (converterConnector === DataConverterConnectorType.Json) {
-                coreConfig.types.dataConverterConnector.push({
-                    type: DataConverterConnectorType.Json
-                });
-            }
-            else if (converterConnector === DataConverterConnectorType.Xml) {
-                coreConfig.types.dataConverterConnector.push({
-                    type: DataConverterConnectorType.Xml
-                });
-            }
+            coreConfig.types.dataConverterConnector.push({
+                type: converterConnector
+            });
         }
         coreConfig.types.dataExtractorConnector ??= [];
-        const extractorConnectors = envVars.dataExtractorConnectors?.split(",") ?? [];
+        const extractorConnectors = commaSeparatedListToArray(envVars.dataExtractorConnectors);
         for (const extractorConnector of extractorConnectors) {
-            if (extractorConnector === DataExtractorConnectorType.JsonPath) {
-                coreConfig.types.dataExtractorConnector.push({
-                    type: DataExtractorConnectorType.JsonPath
-                });
-            }
+            coreConfig.types.dataExtractorConnector.push({
+                type: extractorConnector
+            });
         }
     }
 }
@@ -833,23 +977,36 @@ async function configureDocumentManagement(coreConfig, envVars) {
     }
 }
 /**
- * Configures the verifiable credential authentication.
+ * Configures the trust components.
  * @param coreConfig The core config.
  * @param envVars The environment variables.
  */
-async function configureVerifiableCredentialAuthentication(coreConfig, envVars) {
-    if (Coerce.boolean(envVars.vcAuthenticationEnabled) ?? false) {
-        // Can only perform VC authentication if identity component is available
-        coreConfig.types.authenticationGeneratorComponent ??= [];
-        coreConfig.types.authenticationGeneratorComponent.push({
-            type: AuthenticationGeneratorComponentType.VerifiableCredential,
-            options: {
-                config: {
-                    verificationMethodId: envVars.vcAuthenticationVerificationMethodId ?? VC_AUTHENTICATION_VERIFICATION_METHOD_ID
+async function configureTrust(coreConfig, envVars) {
+    if (isTrustRequired(envVars)) {
+        coreConfig.types.trustComponent ??= [];
+        coreConfig.types.trustComponent.push({
+            type: TrustComponentType.Service
+        });
+        coreConfig.types.trustGeneratorComponent ??= [];
+        const trustGeneratorTypes = commaSeparatedListToArray(envVars.trustGenerators);
+        for (const trustGeneratorType of trustGeneratorTypes) {
+            coreConfig.types.trustGeneratorComponent.push({
+                type: trustGeneratorType,
+                options: {
+                    config: {
+                        verificationMethodId: envVars.trustVerificationMethodId ?? "",
+                        tokenTtlInSeconds: Coerce.integer(envVars.trustJwtTtlSeconds)
+                    }
                 }
-            },
-            features: ["verifiable-credential"]
-        });
+            });
+        }
+        coreConfig.types.trustVerifierComponent ??= [];
+        const trustVerifierTypes = commaSeparatedListToArray(envVars.trustVerifiers);
+        for (const trustVerifierType of trustVerifierTypes) {
+            coreConfig.types.trustVerifierComponent.push({
+                type: trustVerifierType
+            });
+        }
     }
 }
 /**
@@ -858,7 +1015,7 @@ async function configureVerifiableCredentialAuthentication(coreConfig, envVars)
  * @param envVars The environment variables.
  */
 async function configureRightsManagement(coreConfig, envVars) {
-    if (Coerce.boolean(envVars.rightsManagementEnabled) ?? false) {
+    if (isRightsManagementRequired(envVars)) {
         coreConfig.types.rightsManagementPapComponent ??= [];
         coreConfig.types.rightsManagementPapComponent.push({
             type: RightsManagementPapComponentType.Service
@@ -869,76 +1026,100 @@ async function configureRightsManagement(coreConfig, envVars) {
         });
         coreConfig.types.rightsManagementPipComponent ??= [];
         coreConfig.types.rightsManagementPipComponent.push({
-            type: RightsManagementPipComponentType.Service,
-            options: {
-                informationModulesConfig: Is.arrayValue(envVars.rightsManagementInformationSources)
-                    ? envVars.rightsManagementInformationSources
-                    : undefined
-            }
+            type: RightsManagementPipComponentType.Service
         });
         coreConfig.types.rightsManagementPxpComponent ??= [];
         coreConfig.types.rightsManagementPxpComponent.push({
-            type: RightsManagementPxpComponentType.Service,
-            options: {
-                actionModulesConfig: Is.arrayValue(envVars.rightsManagementExecutionActions)
-                    ? envVars.rightsManagementExecutionActions
-                    : undefined
-            }
+            type: RightsManagementPxpComponentType.Service
         });
         coreConfig.types.rightsManagementPdpComponent ??= [];
         coreConfig.types.rightsManagementPdpComponent.push({
-            type: RightsManagementPdpComponentType.Service,
-            options: {
-                arbiterModulesConfig: Is.arrayValue(envVars.rightsManagementArbiters)
-                    ? envVars.rightsManagementArbiters
-                    : undefined
-            }
+            type: RightsManagementPdpComponentType.Service
         });
         coreConfig.types.rightsManagementPepComponent ??= [];
         coreConfig.types.rightsManagementPepComponent.push({
-            type: RightsManagementPepComponentType.Service,
-            options: {
-                processorModulesConfig: Is.arrayValue(envVars.rightsManagementEnforcementProcessors)
-                    ? envVars.rightsManagementEnforcementProcessors
-                    : undefined
-            }
+            type: RightsManagementPepComponentType.Service
         });
         coreConfig.types.rightsManagementPnpComponent ??= [];
+        // Single source of truth for the rights-management mount path.
+        const rightsManagementPath = envVars.rightsManagementCallbackPath ?? "rights-management";
+        // We add a multi instance REST client for the remote negotiations
+        // use a dummy endpoint for now as the actual endpoint will be provided in the config
+        // of the policy negotiator when it is used for remote negotiations
+        // We must add it before the service as the service needs to be able to request
+        // the REST client type from the engine core to be able to support remote negotiations
+        coreConfig.types.rightsManagementPnpComponent.push({
+            type: RightsManagementPnpComponentType.RestClient,
+            options: {
+                endpoint: "http://localhost",
+                pathPrefix: rightsManagementPath
+            },
+            isMultiInstance: true,
+            features: ["remote"]
+        });
         coreConfig.types.rightsManagementPnpComponent.push({
             type: RightsManagementPnpComponentType.Service,
             options: {
-                negotiatorModulesConfig: Is.arrayValue(envVars.rightsManagementNegotiators)
-                    ? envVars.rightsManagementNegotiators
-                    : undefined,
-                requesterModulesConfig: Is.arrayValue(envVars.rightsManagementRequesters)
-                    ? envVars.rightsManagementRequesters
-                    : undefined,
                 config: {
-                    baseCallbackUrl: envVars.rightsManagementBaseCallbackUrl ?? "",
-                    offers: Is.arrayValue(envVars.rightsManagementOffers)
-                        ? envVars.rightsManagementOffers
-                        : [],
-                    negotiationComponentCreator: async (url) => new PolicyNegotiationPointRestClient({ endpoint: url })
+                    callbackPath: rightsManagementPath,
+                    includeErrorDetails: coreConfig.debug ?? false
                 }
-            }
+            },
+            isDefault: true
         });
         coreConfig.types.rightsManagementPnapComponent ??= [];
         coreConfig.types.rightsManagementPnapComponent.push({
             type: RightsManagementPnapComponentType.Service
         });
-        coreConfig.types.rightsManagementDapComponent ??= [];
-        coreConfig.types.rightsManagementDapComponent.push({
-            type: RightsManagementDapComponentType.Service
-        });
-        coreConfig.types.rightsManagementDarpComponent ??= [];
-        coreConfig.types.rightsManagementDarpComponent.push({
-            type: RightsManagementDarpComponentType.Service,
-            options: {
-                config: {
-                    dataAccessComponentCreator: async (url) => new DataAccessPointRestClient({ endpoint: url })
-                }
-            }
-        });
+        coreConfig.types.rightsManagementPolicyArbiterComponent ??= [];
+        const policyArbiterTypes = commaSeparatedListToArray(envVars.rightsManagementPolicyArbiters);
+        for (const policyArbiterType of policyArbiterTypes) {
+            coreConfig.types.rightsManagementPolicyArbiterComponent.push({
+                type: policyArbiterType
+            });
+        }
+        coreConfig.types.rightsManagementPolicyObligationEnforcerComponent ??= [];
+        const policyObligationEnforcerTypes = commaSeparatedListToArray(envVars.rightsManagementPolicyObligationEnforcers);
+        for (const policyObligationEnforcerType of policyObligationEnforcerTypes) {
+            coreConfig.types.rightsManagementPolicyObligationEnforcerComponent.push({
+                type: policyObligationEnforcerType
+            });
+        }
+        coreConfig.types.rightsManagementPolicyEnforcementProcessorComponent ??= [];
+        const policyEnforcementProcessTypes = commaSeparatedListToArray(envVars.rightsManagementPolicyEnforcementProcessors);
+        for (const policyEnforcementProcessorType of policyEnforcementProcessTypes) {
+            coreConfig.types.rightsManagementPolicyEnforcementProcessorComponent.push({
+                type: policyEnforcementProcessorType
+            });
+        }
+        coreConfig.types.rightsManagementPolicyExecutionActionComponent ??= [];
+        const policyExecutionActionTypes = commaSeparatedListToArray(envVars.rightsManagementPolicyExecutionActions);
+        for (const policyExecutionActionType of policyExecutionActionTypes) {
+            coreConfig.types.rightsManagementPolicyExecutionActionComponent.push({
+                type: policyExecutionActionType
+            });
+        }
+        coreConfig.types.rightsManagementPolicyInformationSourceComponent ??= [];
+        const policyInformationSourceTypes = commaSeparatedListToArray(envVars.rightsManagementPolicyInformationSources);
+        for (const policyInformationSourceType of policyInformationSourceTypes) {
+            coreConfig.types.rightsManagementPolicyInformationSourceComponent.push({
+                type: policyInformationSourceType
+            });
+        }
+        coreConfig.types.rightsManagementPolicyRequesterComponent ??= [];
+        const policyRequesterTypes = commaSeparatedListToArray(envVars.rightsManagementPolicyRequesters);
+        for (const policyRequesterType of policyRequesterTypes) {
+            coreConfig.types.rightsManagementPolicyRequesterComponent.push({
+                type: policyRequesterType
+            });
+        }
+        coreConfig.types.rightsManagementPolicyNegotiatorComponent ??= [];
+        const policyNegotiatorTypes = commaSeparatedListToArray(envVars.rightsManagementPolicyNegotiators);
+        for (const policyNegotiatorType of policyNegotiatorTypes) {
+            coreConfig.types.rightsManagementPolicyNegotiatorComponent.push({
+                type: policyNegotiatorType
+            });
+        }
     }
 }
 /**
@@ -947,7 +1128,7 @@ async function configureRightsManagement(coreConfig, envVars) {
  * @param envVars The environment variables.
  */
 async function configureTaskScheduler(coreConfig, envVars) {
-    if (Coerce.boolean(envVars.taskSchedulerEnabled) ?? false) {
+    if (isTaskSchedulerRequired(envVars)) {
         coreConfig.types.taskSchedulerComponent ??= [];
         coreConfig.types.taskSchedulerComponent.push({
             type: TaskSchedulerComponentType.Service
@@ -974,8 +1155,7 @@ async function configureSynchronisedStorage(coreConfig, envVars) {
             options: {
                 config: {
                     verifiableStorageKeyId: verifiableStorageKeyId ?? "",
-                    blobStorageEncryptionKeyId: envVars.synchronisedStorageBlobStorageEncryptionKeyId ??
-                        SYNCHRONISED_STORAGE_BLOB_STORAGE_ENCRYPTION_KEY_ID,
+                    blobStorageEncryptionKeyId: envVars.synchronisedStorageBlobStorageEncryptionKeyId,
                     entityUpdateIntervalMinutes: Coerce.number(envVars.synchronisedStorageEntityUpdateIntervalMinutes),
                     consolidationIntervalMinutes: Coerce.number(envVars.synchronisedStorageConsolidationIntervalMinutes),
                     consolidationBatchSize: Coerce.number(envVars.synchronisedStorageConsolidationBatchSize),
@@ -1003,33 +1183,68 @@ async function configureSynchronisedStorage(coreConfig, envVars) {
  * @param envVars The environment variables.
  */
 async function configureFederatedCatalogue(coreConfig, envVars) {
-    if (Coerce.boolean(envVars.federatedCatalogueEnabled) ?? false) {
+    if (isFederatedCatalogueRequired(envVars)) {
+        // If synchronised storage is enabled, then we need to add an entity storage connector
+        // using synchronised storage for the federated catalogue component
+        // as it relies on the synchronised storage to sync the data between the different instances of the federated catalogue
+        let overrideEntityStorageType;
+        if ((Coerce.boolean(envVars.synchronisedStorageEnabled) ?? false) &&
+            Is.arrayValue(coreConfig.types.entityStorageConnector)) {
+            let defaultConnector = coreConfig.types.entityStorageConnector.find(connector => connector.isDefault);
+            if (Is.empty(defaultConnector)) {
+                // If there is no default connector, we set the first one as the default one
+                defaultConnector = coreConfig.types.entityStorageConnector[0];
+            }
+            overrideEntityStorageType = "federated-catalogue-dataset";
+            coreConfig.types.entityStorageConnector ??= [];
+            coreConfig.types.entityStorageConnector.push({
+                type: EntityStorageConnectorType.Synchronised,
+                overrideInstanceType: overrideEntityStorageType,
+                options: {
+                    entityStorageConnectorType: defaultConnector.type
+                }
+            });
+        }
         coreConfig.types.federatedCatalogueComponent ??= [];
         coreConfig.types.federatedCatalogueComponent.push({
             type: FederatedCatalogueComponentType.Service,
             options: {
-                config: {
-                    subResourceCacheTtlMs: Coerce.number(envVars.federatedCatalogueCacheTtlMs),
-                    clearingHouseApproverList: Coerce.object(envVars.federatedCatalogueClearingHouseApproverList) ?? []
-                }
+                datasetEntityStorageType: overrideEntityStorageType
             }
         });
+        coreConfig.types.federatedCatalogueFilterComponent ??= [];
+        const filters = commaSeparatedListToArray(envVars.federatedCatalogueFilters);
+        for (const filter of filters) {
+            coreConfig.types.federatedCatalogueFilterComponent.push({
+                type: filter,
+                options: {}
+            });
+        }
     }
 }
 /**
- * Configures the data space connector.
+ * Configures the dataspace control plane and data plane.
  * @param coreConfig The core config.
  * @param envVars The environment variables.
  */
-async function configureDataSpaceConnector(coreConfig, envVars) {
-    if (Coerce.boolean(envVars.dataSpaceConnectorEnabled) ?? false) {
-        coreConfig.types.dataSpaceConnectorComponent ??= [];
-        coreConfig.types.dataSpaceConnectorComponent.push({
-            type: DataSpaceConnectorComponentType.Service,
+async function configureDataspace(coreConfig, envVars) {
+    if (Coerce.boolean(envVars.dataspaceEnabled) ?? false) {
+        coreConfig.types.dataspaceControlPlaneComponent ??= [];
+        coreConfig.types.dataspaceControlPlaneComponent.push({
+            type: DataspaceControlPlaneComponentType.Service,
+            options: {
+                config: {
+                    dataPlanePath: envVars.dataspaceDataPlanePath
+                }
+            }
+        });
+        coreConfig.types.dataspaceDataPlaneComponent ??= [];
+        coreConfig.types.dataspaceDataPlaneComponent.push({
+            type: DataspaceDataPlaneComponentType.Service,
             options: {
                 config: {
-                    retainActivityLogsFor: Coerce.number(envVars.dataSpaceConnectorRetainActivityLogsFor),
-                    activityLogsCleanUpInterval: Coerce.number(envVars.dataSpaceConnectorActivityLogsCleanUpInterval)
+                    retainActivityLogsFor: Coerce.number(envVars.dataspaceRetainActivityLogsFor),
+                    activityLogsCleanUpInterval: Coerce.number(envVars.dataspaceActivityLogsCleanUpInterval)
                 }
             }
         });
@@ -1067,4 +1282,106 @@ async function configureDlt(coreConfig, envVars) {
         });
     }
 }
+/**
+ * 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.
+ * @param envVars The environment variables.
+ * @returns True if rights-management, synchronised-storage, or dataspace is enabled.
+ */
+export function isTrustRequired(envVars) {
+    return (isRightsManagementRequired(envVars) ||
+        (Coerce.boolean(envVars.dataspaceEnabled) ?? false) ||
+        (Coerce.boolean(envVars.synchronisedStorageEnabled) ?? false));
+}
+/**
+ * Checks if the URL transformer subsystem is required.
+ * Returns true when any component that depends on the URL transformer subsystem is enabled.
+ * @param envVars The environment variables.
+ * @returns True if rights-management, dataspace, federated-catalogue, or tenant is enabled.
+ */
+export function isUrlTransformerRequired(envVars) {
+    return (isRightsManagementRequired(envVars) ||
+        (Coerce.boolean(envVars.dataspaceEnabled) ?? false) ||
+        (Coerce.boolean(envVars.tenantEnabled) ?? false) ||
+        isFederatedCatalogueRequired(envVars));
+}
+/**
+ * Checks if the background tasks subsystem is required.
+ * Returns true when any component that depends on the background tasks subsystem is enabled.
+ * @param envVars The environment variables.
+ * @returns True if dataspace or verifiable storage is enabled.
+ */
+export function isBackgroundTasksRequired(envVars) {
+    return (Coerce.boolean(envVars.dataspaceEnabled) ?? false) || isImmutableProofRequired(envVars);
+}
+/**
+ * Checks if the immutable proof subsystem is required.
+ * Returns true when any component that depends on the immutable proof subsystem is enabled.
+ * @param envVars The environment variables.
+ * @returns True if verifiable storage is enabled.
+ */
+export function isImmutableProofRequired(envVars) {
+    return (envVars.verifiableStorageConnector === VerifiableStorageConnectorType.EntityStorage ||
+        envVars.verifiableStorageConnector === VerifiableStorageConnectorType.Iota);
+}
+/**
+ * Checks if the immutable proof subsystem is required.
+ * Returns true when any component that depends on the immutable proof subsystem is enabled.
+ * @param envVars The environment variables.
+ * @returns True if verifiable storage is enabled.
+ */
+export function isFederatedCatalogueRequired(envVars) {
+    return Coerce.boolean(envVars.dataspaceEnabled) ?? false;
+}
+/**
+ * Checks if the rights management subsystem is required.
+ * Returns true when any component that depends on the rights management subsystem is enabled.
+ * @param envVars The environment variables.
+ * @returns True if rights management is enabled.
+ */
+export function isRightsManagementRequired(envVars) {
+    return Coerce.boolean(envVars.dataspaceEnabled) ?? false;
+}
+/**
+ * Checks if the task scheduler subsystem is required.
+ * Returns true when any component that depends on the task scheduler subsystem is enabled.
+ * @param envVars The environment variables.
+ * @returns True if task scheduler is enabled.
+ */
+export function isTaskSchedulerRequired(envVars) {
+    return ((Coerce.boolean(envVars.dataspaceEnabled) ?? false) ||
+        (Coerce.boolean(envVars.synchronisedStorageEnabled) ?? false) ||
+        isRightsManagementRequired(envVars) ||
+        isAuthEntityStorageRequired(envVars));
+}
+/**
+ * Checks if the automation subsystem is required.
+ * Returns true when any component that depends on the automation subsystem is enabled.
+ * @param envVars The environment variables.
+ * @returns True if automation is enabled.
+ */
+export function isAutomationRequired(envVars) {
+    return isRightsManagementRequired(envVars);
+}
+/**
+ * Checks if the telemetry subsystem is required.
+ * Returns true when any component that depends on the telemetry subsystem is enabled.
+ * @param envVars The environment variables.
+ * @returns True if telemetry is enabled.
+ */
+export function isTelemetryRequired(envVars) {
+    return (envVars.telemetryConnector === TelemetryConnectorType.EntityStorage ||
+        envVars.telemetryConnector === TelemetryConnectorType.OpenTelemetry);
+}
 //# sourceMappingURL=engineEnvBuilder.js.map