@twin.org/engine-core 0.0.1-next.5 → 0.0.1-next.7

package/dist/cjs/index.cjs

@@ -1659,7 +1659,534 @@ class MemoryStateStorage {
     }
 }
 
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Build the engine core configuration from environment variables.
+ * @param envVars The environment variables.
+ * @returns The config for the core.
+ */
+function buildEngineCoreConfiguration(envVars) {
+    envVars.stateFilename ??= "engine-state.json";
+    envVars.storageFileRoot = path.resolve(envVars.storageFileRoot);
+    envVars.stateFilename = path.join(envVars.storageFileRoot, envVars.stateFilename);
+    envVars.attestationAssertionMethodId ??= "attestation-assertion";
+    envVars.immutableProofHashKeyId ??= "immutable-proof-hash";
+    envVars.immutableProofAssertionMethodId ??= "immutable-proof-assertion";
+    envVars.blobStorageEnableEncryption ??= "false";
+    envVars.blobStorageEncryptionKey ??= "blob-encryption";
+    const coreConfig = {
+        debug: core.Coerce.boolean(envVars.debug) ?? false,
+        loggingConnector: [],
+        loggingComponent: [{ type: engineModels.LoggingComponentType.Service }],
+        entityStorageConnector: [],
+        blobStorageConnector: [],
+        blobStorageComponent: [
+            {
+                type: engineModels.BlobStorageComponentType.Service,
+                options: {
+                    config: {
+                        vaultKeyId: envVars.blobStorageEncryptionKey
+                    }
+                }
+            }
+        ],
+        backgroundTaskConnector: [],
+        telemetryConnector: [],
+        telemetryComponent: [{ type: engineModels.TelemetryComponentType.Service }],
+        vaultConnector: [],
+        walletConnector: [],
+        faucetConnector: [],
+        immutableStorageConnector: [],
+        nftConnector: [],
+        nftComponent: [{ type: engineModels.NftComponentType.Service }],
+        identityConnector: [],
+        identityComponent: [{ type: engineModels.IdentityComponentType.Service }],
+        identityProfileConnector: [],
+        identityProfileComponent: [{ type: engineModels.IdentityProfileComponentType.Service }],
+        immutableProofComponent: [
+            {
+                type: engineModels.ImmutableProofComponentType.Service,
+                options: {
+                    config: {
+                        assertionMethodId: envVars.immutableProofAssertionMethodId,
+                        proofHashKeyId: envVars.immutableProofHashKeyId
+                    }
+                }
+            }
+        ],
+        attestationConnector: [],
+        attestationComponent: [
+            {
+                type: engineModels.AttestationComponentType.Service
+            }
+        ],
+        auditableItemGraphComponent: [{ type: engineModels.AuditableItemGraphComponentType.Service }],
+        auditableItemStreamComponent: [{ type: engineModels.AuditableItemStreamComponentType.Service }]
+    };
+    configureEntityStorageConnectors(coreConfig, envVars);
+    configureBlobStorageConnectors(coreConfig, envVars);
+    configureVaultConnectors(coreConfig, envVars);
+    configureLogging(coreConfig, envVars);
+    configureBackgroundTaskConnectors(coreConfig, envVars);
+    configureTelemetryConnectors(coreConfig, envVars);
+    configureFaucetConnectors(coreConfig, envVars);
+    configureWalletConnectors(coreConfig, envVars);
+    configureNftConnectors(coreConfig, envVars);
+    configureImmutableStorageConnectors(coreConfig, envVars);
+    configureIdentityConnectors(coreConfig, envVars);
+    configureIdentityProfileConnectors(coreConfig, envVars);
+    configureAttestationConnectors(coreConfig, envVars);
+    return coreConfig;
+}
+/**
+ * Configures the entity storage connectors for the core.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ */
+function configureEntityStorageConnectors(coreConfig, envVars) {
+    coreConfig.entityStorageConnector ??= [];
+    if ((core.Coerce.boolean(envVars.entityMemoryEnable) ?? false) ||
+        envVars.blobStorageConnectorType === engineModels.EntityStorageConnectorType.Memory) {
+        coreConfig.entityStorageConnector.push({
+            type: engineModels.EntityStorageConnectorType.Memory
+        });
+    }
+    if ((core.Coerce.boolean(envVars.entityFileEnable) ?? false) ||
+        envVars.entityStorageConnectorType === engineModels.EntityStorageConnectorType.File) {
+        coreConfig.entityStorageConnector.push({
+            type: engineModels.EntityStorageConnectorType.File,
+            options: { config: { directory: envVars.storageFileRoot } }
+        });
+    }
+    if (core.Is.stringValue(envVars.awsDynamodbAccessKeyId)) {
+        coreConfig.entityStorageConnector.push({
+            type: engineModels.EntityStorageConnectorType.AwsDynamoDb,
+            options: {
+                config: {
+                    region: envVars.awsDynamodbRegion,
+                    accessKeyId: envVars.awsDynamodbAccessKeyId,
+                    secretAccessKey: envVars.awsDynamodbSecretAccessKey,
+                    endpoint: envVars.awsDynamodbEndpoint
+                },
+                tablePrefix: envVars.entityStorageTablePrefix
+            }
+        });
+    }
+    if (core.Is.stringValue(envVars.azureCosmosdbKey)) {
+        coreConfig.entityStorageConnector.push({
+            type: engineModels.EntityStorageConnectorType.AzureCosmosDb,
+            options: {
+                config: {
+                    endpoint: envVars.azureCosmosdbEndpoint,
+                    key: envVars.azureCosmosdbKey,
+                    databaseId: envVars.azureCosmosdbDatabaseId,
+                    containerId: envVars.azureCosmosdbContainerId
+                },
+                tablePrefix: envVars.entityStorageTablePrefix
+            }
+        });
+    }
+    if (core.Is.stringValue(envVars.gcpFirestoreCredentials)) {
+        coreConfig.entityStorageConnector.push({
+            type: engineModels.EntityStorageConnectorType.GcpFirestoreDb,
+            options: {
+                config: {
+                    projectId: envVars.gcpFirestoreProjectId,
+                    credentials: envVars.gcpFirestoreCredentials,
+                    databaseId: envVars.gcpFirestoreDatabaseId,
+                    collectionName: envVars.gcpFirestoreCollectionName,
+                    endpoint: envVars.gcpFirestoreApiEndpoint
+                },
+                tablePrefix: envVars.entityStorageTablePrefix
+            }
+        });
+    }
+    if (core.Is.stringValue(envVars.scylladbHosts)) {
+        coreConfig.entityStorageConnector.push({
+            type: engineModels.EntityStorageConnectorType.ScyllaDb,
+            options: {
+                config: {
+                    hosts: envVars.scylladbHosts.split(","),
+                    localDataCenter: envVars.scylladbLocalDataCenter,
+                    keyspace: envVars.scylladbKeyspace
+                },
+                tablePrefix: envVars.entityStorageTablePrefix
+            }
+        });
+    }
+    const defaultStorageConnector = envVars.entityStorageConnectorType;
+    if (core.Is.stringValue(defaultStorageConnector)) {
+        for (const config of coreConfig.entityStorageConnector) {
+            if (config.type === defaultStorageConnector) {
+                config.isDefault = true;
+            }
+        }
+    }
+}
+/**
+ * Configures the blob storage connectors for the core.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ */
+function configureBlobStorageConnectors(coreConfig, envVars) {
+    coreConfig.blobStorageConnector ??= [];
+    if ((core.Coerce.boolean(envVars.blobMemoryEnable) ?? false) ||
+        envVars.blobStorageConnectorType === engineModels.BlobStorageConnectorType.Memory) {
+        coreConfig.blobStorageConnector.push({
+            type: engineModels.BlobStorageConnectorType.Memory
+        });
+    }
+    if ((core.Coerce.boolean(envVars.blobFileEnable) ?? false) ||
+        envVars.blobStorageConnectorType === engineModels.BlobStorageConnectorType.File) {
+        coreConfig.blobStorageConnector.push({
+            type: engineModels.BlobStorageConnectorType.File,
+            options: {
+                config: { directory: envVars.storageFileRoot },
+                storagePrefix: envVars.blobStoragePrefix
+            }
+        });
+    }
+    if (core.Is.stringValue(envVars.ipfsApiUrl)) {
+        coreConfig.blobStorageConnector.push({
+            type: engineModels.BlobStorageConnectorType.Ipfs,
+            options: {
+                config: {
+                    apiUrl: envVars.ipfsApiUrl,
+                    bearerToken: envVars.ipfsBearerToken
+                }
+            }
+        });
+    }
+    if (core.Is.stringValue(envVars.awsS3AccessKeyId)) {
+        coreConfig.blobStorageConnector.push({
+            type: engineModels.BlobStorageConnectorType.AwsS3,
+            options: {
+                config: {
+                    region: envVars.awsS3Region,
+                    bucketName: envVars.awsS3BucketName,
+                    accessKeyId: envVars.awsS3AccessKeyId,
+                    secretAccessKey: envVars.awsS3SecretAccessKey,
+                    endpoint: envVars.awsS3Endpoint
+                },
+                storagePrefix: envVars.blobStoragePrefix
+            }
+        });
+    }
+    if (core.Is.stringValue(envVars.azureStorageAccountKey)) {
+        coreConfig.blobStorageConnector.push({
+            type: engineModels.BlobStorageConnectorType.AzureStorage,
+            options: {
+                config: {
+                    accountName: envVars.azureStorageAccountName,
+                    accountKey: envVars.azureStorageAccountKey,
+                    containerName: envVars.azureStorageContainerName,
+                    endpoint: envVars.azureStorageEndpoint
+                },
+                storagePrefix: envVars.blobStoragePrefix
+            }
+        });
+    }
+    if (core.Is.stringValue(envVars.gcpStorageCredentials)) {
+        coreConfig.blobStorageConnector.push({
+            type: engineModels.BlobStorageConnectorType.GcpStorage,
+            options: {
+                config: {
+                    projectId: envVars.gcpStorageProjectId,
+                    credentials: envVars.gcpStorageCredentials,
+                    bucketName: envVars.gcpStorageBucketName,
+                    apiEndpoint: envVars.gcpFirestoreApiEndpoint
+                },
+                storagePrefix: envVars.blobStoragePrefix
+            }
+        });
+    }
+    const defaultStorageConnectorType = envVars.blobStorageConnectorType;
+    if (core.Is.stringValue(defaultStorageConnectorType)) {
+        for (const config of coreConfig.blobStorageConnector) {
+            if (config.type === defaultStorageConnectorType) {
+                config.isDefault = true;
+            }
+        }
+    }
+}
+/**
+ * Configures the logging connectors for the core.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ */
+function configureLogging(coreConfig, envVars) {
+    const loggingConnectors = (envVars.loggingConnector ?? "").split(",");
+    for (const loggingConnector of loggingConnectors) {
+        if (loggingConnector === engineModels.LoggingConnectorType.Console) {
+            coreConfig.loggingConnector?.push({
+                type: engineModels.LoggingConnectorType.Console,
+                options: {
+                    config: {
+                        translateMessages: true,
+                        hideGroups: true
+                    }
+                }
+            });
+        }
+        else if (loggingConnector === engineModels.LoggingConnectorType.EntityStorage) {
+            coreConfig.loggingConnector?.push({
+                type: engineModels.LoggingConnectorType.EntityStorage
+            });
+        }
+    }
+    if (loggingConnectors.length > 1) {
+        coreConfig.loggingConnector?.push({
+            type: engineModels.LoggingConnectorType.Multi,
+            isDefault: true,
+            options: {
+                loggingConnectorTypes: loggingConnectors
+            }
+        });
+    }
+}
+/**
+ * Configures the vault connectors for the core.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ */
+function configureVaultConnectors(coreConfig, envVars) {
+    coreConfig.vaultConnector ??= [];
+    if (envVars.vaultConnector === engineModels.VaultConnectorType.EntityStorage) {
+        coreConfig.vaultConnector.push({
+            type: engineModels.VaultConnectorType.EntityStorage
+        });
+    }
+    else if (envVars.vaultConnector === engineModels.VaultConnectorType.Hashicorp) {
+        coreConfig.vaultConnector.push({
+            type: engineModels.VaultConnectorType.Hashicorp,
+            options: {
+                config: { endpoint: envVars.hashicorpVaultEndpoint, token: envVars.hashicorpVaultToken }
+            }
+        });
+    }
+}
+/**
+ * Configures the background task connectors for the core.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ */
+function configureBackgroundTaskConnectors(coreConfig, envVars) {
+    coreConfig.backgroundTaskConnector ??= [];
+    if (envVars.backgroundTaskConnector === engineModels.BackgroundTaskConnectorType.EntityStorage) {
+        coreConfig.backgroundTaskConnector.push({
+            type: engineModels.BackgroundTaskConnectorType.EntityStorage
+        });
+    }
+}
+/**
+ * Configures the telemetry connectors for the core.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ */
+function configureTelemetryConnectors(coreConfig, envVars) {
+    coreConfig.telemetryConnector ??= [];
+    if (envVars.telemetryConnector === engineModels.TelemetryConnectorType.EntityStorage) {
+        coreConfig.telemetryConnector.push({
+            type: engineModels.TelemetryConnectorType.EntityStorage
+        });
+    }
+}
+/**
+ * Configures the faucet connectors for the core.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ */
+function configureFaucetConnectors(coreConfig, envVars) {
+    coreConfig.faucetConnector ??= [];
+    if (envVars.faucetConnector === engineModels.FaucetConnectorType.EntityStorage) {
+        coreConfig.faucetConnector.push({
+            type: engineModels.FaucetConnectorType.EntityStorage
+        });
+    }
+    else if (envVars.faucetConnector === engineModels.FaucetConnectorType.Iota) {
+        coreConfig.faucetConnector.push({
+            type: engineModels.FaucetConnectorType.Iota,
+            options: {
+                config: {
+                    endpoint: envVars.iotaFaucetEndpoint,
+                    clientOptions: {
+                        nodes: [envVars.iotaNodeEndpoint]
+                    },
+                    bech32Hrp: envVars.iotaBech32Hrp,
+                    coinType: core.Coerce.number(envVars.iotaCoinType)
+                }
+            }
+        });
+    }
+}
+/**
+ * Configures the wallet connectors for the core.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ */
+function configureWalletConnectors(coreConfig, envVars) {
+    coreConfig.walletConnector ??= [];
+    if (envVars.walletConnector === engineModels.WalletConnectorType.EntityStorage) {
+        coreConfig.walletConnector.push({
+            type: engineModels.WalletConnectorType.EntityStorage
+        });
+    }
+    else if (envVars.walletConnector === engineModels.WalletConnectorType.Iota) {
+        coreConfig.walletConnector.push({
+            type: engineModels.WalletConnectorType.Iota,
+            options: {
+                config: {
+                    clientOptions: {
+                        nodes: [envVars.iotaNodeEndpoint]
+                    },
+                    bech32Hrp: envVars.iotaBech32Hrp,
+                    coinType: core.Coerce.number(envVars.iotaCoinType)
+                }
+            }
+        });
+    }
+}
+/**
+ * Configures the NFT connectors for the core.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ */
+function configureNftConnectors(coreConfig, envVars) {
+    coreConfig.nftConnector ??= [];
+    if (envVars.nftConnector === engineModels.NftConnectorType.EntityStorage) {
+        coreConfig.nftConnector.push({
+            type: engineModels.NftConnectorType.EntityStorage
+        });
+    }
+    else if (envVars.nftConnector === engineModels.NftConnectorType.Iota) {
+        coreConfig.nftConnector.push({
+            type: engineModels.NftConnectorType.Iota,
+            options: {
+                config: {
+                    clientOptions: {
+                        nodes: [envVars.iotaNodeEndpoint]
+                    },
+                    bech32Hrp: envVars.iotaBech32Hrp,
+                    coinType: core.Coerce.number(envVars.iotaCoinType)
+                }
+            }
+        });
+    }
+}
+/**
+ * Configures the immutable storage connectors for the core.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ */
+function configureImmutableStorageConnectors(coreConfig, envVars) {
+    coreConfig.immutableStorageConnector ??= [];
+    if (envVars.immutableStorageConnector === engineModels.ImmutableStorageConnectorType.EntityStorage) {
+        coreConfig.immutableStorageConnector.push({
+            type: engineModels.ImmutableStorageConnectorType.EntityStorage
+        });
+    }
+    else if (envVars.immutableStorageConnector === engineModels.ImmutableStorageConnectorType.Iota) {
+        coreConfig.immutableStorageConnector.push({
+            type: engineModels.ImmutableStorageConnectorType.Iota,
+            options: {
+                config: {
+                    clientOptions: {
+                        nodes: [envVars.iotaNodeEndpoint]
+                    },
+                    bech32Hrp: envVars.iotaBech32Hrp,
+                    coinType: core.Coerce.number(envVars.iotaCoinType)
+                }
+            }
+        });
+    }
+}
+/**
+ * Configures the identity connectors for the core.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ */
+function configureIdentityConnectors(coreConfig, envVars) {
+    coreConfig.identityConnector ??= [];
+    if (envVars.identityConnector === engineModels.IdentityConnectorType.EntityStorage) {
+        coreConfig.identityConnector.push({
+            type: engineModels.IdentityConnectorType.EntityStorage
+        });
+    }
+    else if (envVars.identityConnector === engineModels.IdentityConnectorType.Iota) {
+        coreConfig.identityConnector.push({
+            type: engineModels.IdentityConnectorType.Iota,
+            options: {
+                config: {
+                    clientOptions: {
+                        nodes: [envVars.iotaNodeEndpoint]
+                    },
+                    bech32Hrp: envVars.iotaBech32Hrp,
+                    coinType: core.Coerce.number(envVars.iotaCoinType)
+                }
+            }
+        });
+    }
+}
+/**
+ * Configures the identity profile connectors for the core.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ */
+function configureIdentityProfileConnectors(coreConfig, envVars) {
+    coreConfig.identityProfileConnector ??= [];
+    if (envVars.identityProfileConnector === engineModels.IdentityConnectorType.EntityStorage) {
+        coreConfig.identityProfileConnector.push({
+            type: engineModels.IdentityProfileConnectorType.EntityStorage
+        });
+    }
+}
+/**
+ * Configures the attestation connectors for the core.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ */
+function configureAttestationConnectors(coreConfig, envVars) {
+    coreConfig.attestationConnector ??= [];
+    if (envVars.attestationConnector === engineModels.AttestationConnectorType.EntityStorage) {
+        coreConfig.attestationConnector.push({
+            type: engineModels.AttestationConnectorType.EntityStorage
+        });
+    }
+    else if (envVars.attestationConnector === engineModels.AttestationConnectorType.Iota) {
+        coreConfig.attestationConnector.push({
+            type: engineModels.AttestationConnectorType.Iota
+        });
+    }
+}
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Environment variable helper.
+ */
+class EnvHelper {
+    /**
+     * Get the environment variable as an object with camel cased names.
+     * @param envVars The environment variables.
+     * @param prefix The prefix of the environment variables.
+     * @returns The object with camel cased names.
+     */
+    static envToJson(envVars, prefix) {
+        const result = {};
+        for (const envVar in envVars) {
+            if (envVar.startsWith(prefix) && core.Is.stringValue(process.env[envVar])) {
+                const camelCaseName = core.StringHelper.camelCase(envVar.replace(prefix, "").toLowerCase());
+                core.ObjectHelper.propertySet(result, camelCaseName, process.env[envVar]);
+            }
+        }
+        return result;
+    }
+}
+
 exports.EngineCore = EngineCore;
+exports.EnvHelper = EnvHelper;
 exports.FileStateStorage = FileStateStorage;
 exports.MemoryStateStorage = MemoryStateStorage;
+exports.buildEngineCoreConfiguration = buildEngineCoreConfiguration;
 exports.initialiseEntityStorageConnector = initialiseEntityStorageConnector;