@twin.org/engine-core 0.0.1-next.4 → 0.0.1-next.6

package/dist/cjs/index.cjs

@@ -1,5 +1,6 @@
 'use strict';
 
+var path = require('node:path');
 var core = require('@twin.org/core');
 var engineModels = require('@twin.org/engine-models');
 var entityStorageConnectorCosmosdb = require('@twin.org/entity-storage-connector-cosmosdb');
@@ -103,7 +104,11 @@ function initialiseEntityStorageConnector(engineCore, context, typeCustom, schem
     else if (type === engineModels.EntityStorageConnectorType.File) {
         entityStorageConnector = new entityStorageConnectorFile.FileEntityStorageConnector({
             entitySchema: schema,
-            ...entityStorageConfig.options
+            ...entityStorageConfig.options,
+            config: {
+                ...entityStorageConfig.options.config,
+                directory: path.join(entityStorageConfig.options.config.directory, instanceName)
+            }
         });
     }
     else if (type === engineModels.EntityStorageConnectorType.AwsDynamoDb) {
@@ -1449,7 +1454,7 @@ class EngineCore {
                 // First bootstrap the components.
                 for (const instance of this._context.componentInstances) {
                     if (core.Is.function(instance.component.bootstrap)) {
-                        const bootstrapName = `component-${instance.component.CLASS_NAME}-${instance.instanceType}`;
+                        const bootstrapName = `${instance.component.CLASS_NAME}-${instance.instanceType}`;
                         if (!this._context.state.bootstrappedComponents.includes(bootstrapName)) {
                             this.logInfo(core.I18n.formatMessage("engineCore.bootstrapping", {
                                 element: bootstrapName
@@ -1578,7 +1583,7 @@ class FileStateStorage {
                 engineCore.logInfo(core.I18n.formatMessage(`${core.StringHelper.camelCase(this.CLASS_NAME)}.saving`, {
                     filename: this._filename
                 }));
-                await promises.writeFile(this._filename, JSON.stringify(state, null, 2), "utf8");
+                await promises.writeFile(this._filename, JSON.stringify(state, undefined, "\t"), "utf8");
             }
             catch (err) {
                 throw new core.GeneralError(this.CLASS_NAME, "savingError", { filename: this._filename }, core.BaseError.fromError(err));
@@ -1654,7 +1659,518 @@ 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";
+    const coreConfig = {
+        debug: core.Coerce.boolean(envVars.debug) ?? false,
+        loggingConnector: [],
+        loggingComponent: [{ type: engineModels.LoggingComponentType.Service }],
+        entityStorageConnector: [],
+        blobStorageConnector: [],
+        blobStorageComponent: [{ type: engineModels.BlobStorageComponentType.Service }],
+        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 ??= [];
+    coreConfig.entityStorageConnector.push({
+        type: engineModels.EntityStorageConnectorType.Memory
+    });
+    if (core.Is.stringValue(envVars.storageFileRoot)) {
+        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) {
+    envVars.blobStorageEnableEncryption ??= "false";
+    envVars.blobStorageEncryptionKey ??= "blob-encryption";
+    coreConfig.blobStorageConnector ??= [];
+    coreConfig.blobStorageConnector.push({
+        type: engineModels.BlobStorageConnectorType.Memory
+    });
+    if (core.Is.stringValue(envVars.storageFileRoot)) {
+        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.
+// 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.
+     */
+    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;