@twin.org/engine 0.0.1-next.14

package/dist/cjs/index.cjs

@@ -0,0 +1,591 @@
+'use strict';
+
+var engineCore = require('@twin.org/engine-core');
+var path = require('node:path');
+var core = require('@twin.org/core');
+var engineTypes = require('@twin.org/engine-types');
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * The engine with built in types.
+ */
+class Engine extends engineCore.EngineCore {
+    /**
+     * Runtime name for the class.
+     */
+    CLASS_NAME = "Engine";
+    /**
+     * Create a new instance of Engine.
+     * @param options The options for the engine.
+     */
+    constructor(options) {
+        super(options);
+        this.addCoreTypeInitialisers(this, this._context);
+    }
+    /**
+     * Add the core type initializers.
+     * @internal
+     */
+    addCoreTypeInitialisers(engineCore, context) {
+        this.addTypeInitialiser("loggingConnector", context.config.types.loggingConnector, "@twin.org/engine-types", "initialiseLoggingConnector");
+        this.addTypeInitialiser("loggingComponent", context.config.types.loggingComponent, "@twin.org/engine-types", "initialiseLoggingComponent");
+        this.addTypeInitialiser("backgroundTaskConnector", context.config.types.backgroundTaskConnector, "@twin.org/engine-types", "initialiseBackgroundTaskConnector");
+        this.addTypeInitialiser("telemetryConnector", context.config.types.telemetryConnector, "@twin.org/engine-types", "initialiseTelemetryConnector");
+        this.addTypeInitialiser("telemetryComponent", context.config.types.telemetryComponent, "@twin.org/engine-types", "initialiseTelemetryComponent");
+        this.addTypeInitialiser("entityStorageComponent", context.config.types.entityStorageComponent, "@twin.org/engine-types", "initialiseEntityStorageComponent");
+        this.addTypeInitialiser("vaultConnector", context.config.types.vaultConnector, "@twin.org/engine-types", "initialiseVaultConnector");
+        this.addTypeInitialiser("blobStorageConnector", context.config.types.blobStorageConnector, "@twin.org/engine-types", "initialiseBlobStorageConnector");
+        this.addTypeInitialiser("blobStorageComponent", context.config.types.blobStorageComponent, "@twin.org/engine-types", "initialiseBlobStorageComponent");
+        this.addTypeInitialiser("immutableStorageConnector", context.config.types.immutableStorageConnector, "@twin.org/engine-types", "initialiseImmutableStorageConnector");
+        this.addTypeInitialiser("walletConnector", context.config.types.walletConnector, "@twin.org/engine-types", "initialiseWalletStorage");
+        this.addTypeInitialiser("faucetConnector", context.config.types.faucetConnector, "@twin.org/engine-types", "initialiseFaucetConnector");
+        this.addTypeInitialiser("walletConnector", context.config.types.walletConnector, "@twin.org/engine-types", "initialiseWalletConnector");
+        this.addTypeInitialiser("identityConnector", context.config.types.identityConnector, "@twin.org/engine-types", "initialiseIdentityConnector");
+        this.addTypeInitialiser("identityComponent", context.config.types.identityComponent, "@twin.org/engine-types", "initialiseIdentityComponent");
+        this.addTypeInitialiser("identityProfileConnector", context.config.types.identityProfileConnector, "@twin.org/engine-types", "initialiseIdentityProfileConnector");
+        this.addTypeInitialiser("identityProfileComponent", context.config.types.identityProfileComponent, "@twin.org/engine-types", "initialiseIdentityProfileComponent");
+        this.addTypeInitialiser("nftConnector", context.config.types.nftConnector, "@twin.org/engine-types", "initialiseNftConnector");
+        this.addTypeInitialiser("nftComponent", context.config.types.nftComponent, "@twin.org/engine-types", "initialiseNftComponent");
+        this.addTypeInitialiser("immutableProofComponent", context.config.types.immutableProofComponent, "@twin.org/engine-types", "initialiseImmutableProofComponent");
+        this.addTypeInitialiser("attestationConnector", context.config.types.attestationConnector, "@twin.org/engine-types", "initialiseAttestationConnector");
+        this.addTypeInitialiser("attestationComponent", context.config.types.attestationComponent, "@twin.org/engine-types", "initialiseAttestationComponent");
+        this.addTypeInitialiser("auditableItemGraphComponent", context.config.types.auditableItemGraphComponent, "@twin.org/engine-types", "initialiseAuditableItemGraphComponent");
+        this.addTypeInitialiser("auditableItemStreamComponent", context.config.types.auditableItemStreamComponent, "@twin.org/engine-types", "initialiseAuditableItemStreamComponent");
+    }
+}
+
+// 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 buildEngineConfiguration(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,
+        types: {
+            loggingConnector: [],
+            loggingComponent: [{ type: engineTypes.LoggingComponentType.Service }],
+            entityStorageConnector: [],
+            blobStorageConnector: [],
+            blobStorageComponent: [
+                {
+                    type: engineTypes.BlobStorageComponentType.Service,
+                    options: {
+                        config: {
+                            vaultKeyId: envVars.blobStorageEncryptionKey
+                        }
+                    }
+                }
+            ],
+            backgroundTaskConnector: [],
+            telemetryConnector: [],
+            telemetryComponent: [{ type: engineTypes.TelemetryComponentType.Service }],
+            vaultConnector: [],
+            walletConnector: [],
+            faucetConnector: [],
+            immutableStorageConnector: [],
+            nftConnector: [],
+            nftComponent: [{ type: engineTypes.NftComponentType.Service }],
+            identityConnector: [],
+            identityComponent: [{ type: engineTypes.IdentityComponentType.Service }],
+            identityProfileConnector: [],
+            identityProfileComponent: [{ type: engineTypes.IdentityProfileComponentType.Service }],
+            immutableProofComponent: [
+                {
+                    type: engineTypes.ImmutableProofComponentType.Service,
+                    options: {
+                        config: {
+                            assertionMethodId: envVars.immutableProofAssertionMethodId,
+                            proofHashKeyId: envVars.immutableProofHashKeyId
+                        }
+                    }
+                }
+            ],
+            attestationConnector: [],
+            attestationComponent: [
+                {
+                    type: engineTypes.AttestationComponentType.Service
+                }
+            ],
+            auditableItemGraphComponent: [{ type: engineTypes.AuditableItemGraphComponentType.Service }],
+            auditableItemStreamComponent: [{ type: engineTypes.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.types ??= {};
+    coreConfig.types.entityStorageConnector ??= [];
+    if ((core.Coerce.boolean(envVars.entityMemoryEnable) ?? false) ||
+        envVars.blobStorageConnectorType === engineTypes.EntityStorageConnectorType.Memory) {
+        coreConfig.types.entityStorageConnector.push({
+            type: engineTypes.EntityStorageConnectorType.Memory
+        });
+    }
+    if ((core.Coerce.boolean(envVars.entityFileEnable) ?? false) ||
+        envVars.entityStorageConnectorType === engineTypes.EntityStorageConnectorType.File) {
+        coreConfig.types.entityStorageConnector.push({
+            type: engineTypes.EntityStorageConnectorType.File,
+            options: {
+                config: { directory: envVars.storageFileRoot },
+                folderPrefix: envVars.entityStorageTablePrefix
+            }
+        });
+    }
+    if (core.Is.stringValue(envVars.awsDynamodbAccessKeyId)) {
+        coreConfig.types.entityStorageConnector.push({
+            type: engineTypes.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.types.entityStorageConnector.push({
+            type: engineTypes.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.types.entityStorageConnector.push({
+            type: engineTypes.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.types.entityStorageConnector.push({
+            type: engineTypes.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.types.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.types.blobStorageConnector ??= [];
+    if ((core.Coerce.boolean(envVars.blobMemoryEnable) ?? false) ||
+        envVars.blobStorageConnectorType === engineTypes.BlobStorageConnectorType.Memory) {
+        coreConfig.types.blobStorageConnector.push({
+            type: engineTypes.BlobStorageConnectorType.Memory
+        });
+    }
+    if ((core.Coerce.boolean(envVars.blobFileEnable) ?? false) ||
+        envVars.blobStorageConnectorType === engineTypes.BlobStorageConnectorType.File) {
+        coreConfig.types.blobStorageConnector.push({
+            type: engineTypes.BlobStorageConnectorType.File,
+            options: {
+                config: { directory: path.join(envVars.storageFileRoot, "blob-storage") },
+                storagePrefix: envVars.blobStoragePrefix
+            }
+        });
+    }
+    if (core.Is.stringValue(envVars.ipfsApiUrl)) {
+        coreConfig.types.blobStorageConnector.push({
+            type: engineTypes.BlobStorageConnectorType.Ipfs,
+            options: {
+                config: {
+                    apiUrl: envVars.ipfsApiUrl,
+                    bearerToken: envVars.ipfsBearerToken
+                }
+            }
+        });
+    }
+    if (core.Is.stringValue(envVars.awsS3AccessKeyId)) {
+        coreConfig.types.blobStorageConnector.push({
+            type: engineTypes.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.types.blobStorageConnector.push({
+            type: engineTypes.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.types.blobStorageConnector.push({
+            type: engineTypes.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.types.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 === engineTypes.LoggingConnectorType.Console) {
+            coreConfig.types.loggingConnector?.push({
+                type: engineTypes.LoggingConnectorType.Console,
+                options: {
+                    config: {
+                        translateMessages: true,
+                        hideGroups: true
+                    }
+                }
+            });
+        }
+        else if (loggingConnector === engineTypes.LoggingConnectorType.EntityStorage) {
+            coreConfig.types.loggingConnector?.push({
+                type: engineTypes.LoggingConnectorType.EntityStorage
+            });
+        }
+    }
+    if (loggingConnectors.length > 1) {
+        coreConfig.types.loggingConnector?.push({
+            type: engineTypes.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.types.vaultConnector ??= [];
+    if (envVars.vaultConnector === engineTypes.VaultConnectorType.EntityStorage) {
+        coreConfig.types.vaultConnector.push({
+            type: engineTypes.VaultConnectorType.EntityStorage
+        });
+    }
+    else if (envVars.vaultConnector === engineTypes.VaultConnectorType.Hashicorp) {
+        coreConfig.types.vaultConnector.push({
+            type: engineTypes.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.types.backgroundTaskConnector ??= [];
+    if (envVars.backgroundTaskConnector === engineTypes.BackgroundTaskConnectorType.EntityStorage) {
+        coreConfig.types.backgroundTaskConnector.push({
+            type: engineTypes.BackgroundTaskConnectorType.EntityStorage
+        });
+    }
+}
+/**
+ * Configures the telemetry connectors for the core.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ */
+function configureTelemetryConnectors(coreConfig, envVars) {
+    coreConfig.types.telemetryConnector ??= [];
+    if (envVars.telemetryConnector === engineTypes.TelemetryConnectorType.EntityStorage) {
+        coreConfig.types.telemetryConnector.push({
+            type: engineTypes.TelemetryConnectorType.EntityStorage
+        });
+    }
+}
+/**
+ * Configures the faucet connectors for the core.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ */
+function configureFaucetConnectors(coreConfig, envVars) {
+    coreConfig.types.faucetConnector ??= [];
+    if (envVars.faucetConnector === engineTypes.FaucetConnectorType.EntityStorage) {
+        coreConfig.types.faucetConnector.push({
+            type: engineTypes.FaucetConnectorType.EntityStorage
+        });
+    }
+    else if (envVars.faucetConnector === engineTypes.FaucetConnectorType.Iota) {
+        coreConfig.types.faucetConnector.push({
+            type: engineTypes.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.types.walletConnector ??= [];
+    if (envVars.walletConnector === engineTypes.WalletConnectorType.EntityStorage) {
+        coreConfig.types.walletConnector.push({
+            type: engineTypes.WalletConnectorType.EntityStorage
+        });
+    }
+    else if (envVars.walletConnector === engineTypes.WalletConnectorType.Iota) {
+        coreConfig.types.walletConnector.push({
+            type: engineTypes.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.types.nftConnector ??= [];
+    if (envVars.nftConnector === engineTypes.NftConnectorType.EntityStorage) {
+        coreConfig.types.nftConnector.push({
+            type: engineTypes.NftConnectorType.EntityStorage
+        });
+    }
+    else if (envVars.nftConnector === engineTypes.NftConnectorType.Iota) {
+        coreConfig.types.nftConnector.push({
+            type: engineTypes.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.types.immutableStorageConnector ??= [];
+    if (envVars.immutableStorageConnector === engineTypes.ImmutableStorageConnectorType.EntityStorage) {
+        coreConfig.types.immutableStorageConnector.push({
+            type: engineTypes.ImmutableStorageConnectorType.EntityStorage
+        });
+    }
+    else if (envVars.immutableStorageConnector === engineTypes.ImmutableStorageConnectorType.Iota) {
+        coreConfig.types.immutableStorageConnector.push({
+            type: engineTypes.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.types.identityConnector ??= [];
+    if (envVars.identityConnector === engineTypes.IdentityConnectorType.EntityStorage) {
+        coreConfig.types.identityConnector.push({
+            type: engineTypes.IdentityConnectorType.EntityStorage
+        });
+    }
+    else if (envVars.identityConnector === engineTypes.IdentityConnectorType.Iota) {
+        coreConfig.types.identityConnector.push({
+            type: engineTypes.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.types.identityProfileConnector ??= [];
+    if (envVars.identityProfileConnector === engineTypes.IdentityConnectorType.EntityStorage) {
+        coreConfig.types.identityProfileConnector.push({
+            type: engineTypes.IdentityProfileConnectorType.EntityStorage
+        });
+    }
+}
+/**
+ * Configures the attestation connectors for the core.
+ * @param coreConfig The core config.
+ * @param envVars The environment variables.
+ */
+function configureAttestationConnectors(coreConfig, envVars) {
+    coreConfig.types.attestationConnector ??= [];
+    if (envVars.attestationConnector === engineTypes.AttestationConnectorType.EntityStorage) {
+        coreConfig.types.attestationConnector.push({
+            type: engineTypes.AttestationConnectorType.EntityStorage
+        });
+    }
+    else if (envVars.attestationConnector === engineTypes.AttestationConnectorType.Iota) {
+        coreConfig.types.attestationConnector.push({
+            type: engineTypes.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.Engine = Engine;
+exports.EnvHelper = EnvHelper;
+exports.buildEngineConfiguration = buildEngineConfiguration;