@twin.org/engine 0.0.1-next.14

package/dist/esm/index.mjs

@@ -0,0 +1,587 @@
+import { EngineCore } from '@twin.org/engine-core';
+import path from 'node:path';
+import { Coerce, Is, StringHelper, ObjectHelper } from '@twin.org/core';
+import { LoggingComponentType, BlobStorageComponentType, TelemetryComponentType, NftComponentType, IdentityComponentType, IdentityProfileComponentType, ImmutableProofComponentType, AttestationComponentType, AuditableItemGraphComponentType, AuditableItemStreamComponentType, EntityStorageConnectorType, BlobStorageConnectorType, LoggingConnectorType, VaultConnectorType, BackgroundTaskConnectorType, TelemetryConnectorType, FaucetConnectorType, WalletConnectorType, NftConnectorType, ImmutableStorageConnectorType, IdentityConnectorType, IdentityProfileConnectorType, AttestationConnectorType } from '@twin.org/engine-types';
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * The engine with built in types.
+ */
+class Engine extends 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: Coerce.boolean(envVars.debug) ?? false,
+        types: {
+            loggingConnector: [],
+            loggingComponent: [{ type: LoggingComponentType.Service }],
+            entityStorageConnector: [],
+            blobStorageConnector: [],
+            blobStorageComponent: [
+                {
+                    type: BlobStorageComponentType.Service,
+                    options: {
+                        config: {
+                            vaultKeyId: envVars.blobStorageEncryptionKey
+                        }
+                    }
+                }
+            ],
+            backgroundTaskConnector: [],
+            telemetryConnector: [],
+            telemetryComponent: [{ type: TelemetryComponentType.Service }],
+            vaultConnector: [],
+            walletConnector: [],
+            faucetConnector: [],
+            immutableStorageConnector: [],
+            nftConnector: [],
+            nftComponent: [{ type: NftComponentType.Service }],
+            identityConnector: [],
+            identityComponent: [{ type: IdentityComponentType.Service }],
+            identityProfileConnector: [],
+            identityProfileComponent: [{ type: IdentityProfileComponentType.Service }],
+            immutableProofComponent: [
+                {
+                    type: ImmutableProofComponentType.Service,
+                    options: {
+                        config: {
+                            assertionMethodId: envVars.immutableProofAssertionMethodId,
+                            proofHashKeyId: envVars.immutableProofHashKeyId
+                        }
+                    }
+                }
+            ],
+            attestationConnector: [],
+            attestationComponent: [
+                {
+                    type: AttestationComponentType.Service
+                }
+            ],
+            auditableItemGraphComponent: [{ type: AuditableItemGraphComponentType.Service }],
+            auditableItemStreamComponent: [{ type: 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 ((Coerce.boolean(envVars.entityMemoryEnable) ?? false) ||
+        envVars.blobStorageConnectorType === EntityStorageConnectorType.Memory) {
+        coreConfig.types.entityStorageConnector.push({
+            type: EntityStorageConnectorType.Memory
+        });
+    }
+    if ((Coerce.boolean(envVars.entityFileEnable) ?? false) ||
+        envVars.entityStorageConnectorType === EntityStorageConnectorType.File) {
+        coreConfig.types.entityStorageConnector.push({
+            type: EntityStorageConnectorType.File,
+            options: {
+                config: { directory: envVars.storageFileRoot },
+                folderPrefix: envVars.entityStorageTablePrefix
+            }
+        });
+    }
+    if (Is.stringValue(envVars.awsDynamodbAccessKeyId)) {
+        coreConfig.types.entityStorageConnector.push({
+            type: EntityStorageConnectorType.AwsDynamoDb,
+            options: {
+                config: {
+                    region: envVars.awsDynamodbRegion,
+                    accessKeyId: envVars.awsDynamodbAccessKeyId,
+                    secretAccessKey: envVars.awsDynamodbSecretAccessKey,
+                    endpoint: envVars.awsDynamodbEndpoint
+                },
+                tablePrefix: envVars.entityStorageTablePrefix
+            }
+        });
+    }
+    if (Is.stringValue(envVars.azureCosmosdbKey)) {
+        coreConfig.types.entityStorageConnector.push({
+            type: EntityStorageConnectorType.AzureCosmosDb,
+            options: {
+                config: {
+                    endpoint: envVars.azureCosmosdbEndpoint,
+                    key: envVars.azureCosmosdbKey,
+                    databaseId: envVars.azureCosmosdbDatabaseId,
+                    containerId: envVars.azureCosmosdbContainerId
+                },
+                tablePrefix: envVars.entityStorageTablePrefix
+            }
+        });
+    }
+    if (Is.stringValue(envVars.gcpFirestoreCredentials)) {
+        coreConfig.types.entityStorageConnector.push({
+            type: EntityStorageConnectorType.GcpFirestoreDb,
+            options: {
+                config: {
+                    projectId: envVars.gcpFirestoreProjectId,
+                    credentials: envVars.gcpFirestoreCredentials,
+                    databaseId: envVars.gcpFirestoreDatabaseId,
+                    collectionName: envVars.gcpFirestoreCollectionName,
+                    endpoint: envVars.gcpFirestoreApiEndpoint
+                },
+                tablePrefix: envVars.entityStorageTablePrefix
+            }
+        });
+    }
+    if (Is.stringValue(envVars.scylladbHosts)) {
+        coreConfig.types.entityStorageConnector.push({
+            type: EntityStorageConnectorType.ScyllaDb,
+            options: {
+                config: {
+                    hosts: envVars.scylladbHosts.split(","),
+                    localDataCenter: envVars.scylladbLocalDataCenter,
+                    keyspace: envVars.scylladbKeyspace
+                },
+                tablePrefix: envVars.entityStorageTablePrefix
+            }
+        });
+    }
+    const defaultStorageConnector = envVars.entityStorageConnectorType;
+    if (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 ((Coerce.boolean(envVars.blobMemoryEnable) ?? false) ||
+        envVars.blobStorageConnectorType === BlobStorageConnectorType.Memory) {
+        coreConfig.types.blobStorageConnector.push({
+            type: BlobStorageConnectorType.Memory
+        });
+    }
+    if ((Coerce.boolean(envVars.blobFileEnable) ?? false) ||
+        envVars.blobStorageConnectorType === BlobStorageConnectorType.File) {
+        coreConfig.types.blobStorageConnector.push({
+            type: BlobStorageConnectorType.File,
+            options: {
+                config: { directory: path.join(envVars.storageFileRoot, "blob-storage") },
+                storagePrefix: envVars.blobStoragePrefix
+            }
+        });
+    }
+    if (Is.stringValue(envVars.ipfsApiUrl)) {
+        coreConfig.types.blobStorageConnector.push({
+            type: BlobStorageConnectorType.Ipfs,
+            options: {
+                config: {
+                    apiUrl: envVars.ipfsApiUrl,
+                    bearerToken: envVars.ipfsBearerToken
+                }
+            }
+        });
+    }
+    if (Is.stringValue(envVars.awsS3AccessKeyId)) {
+        coreConfig.types.blobStorageConnector.push({
+            type: BlobStorageConnectorType.AwsS3,
+            options: {
+                config: {
+                    region: envVars.awsS3Region,
+                    bucketName: envVars.awsS3BucketName,
+                    accessKeyId: envVars.awsS3AccessKeyId,
+                    secretAccessKey: envVars.awsS3SecretAccessKey,
+                    endpoint: envVars.awsS3Endpoint
+                },
+                storagePrefix: envVars.blobStoragePrefix
+            }
+        });
+    }
+    if (Is.stringValue(envVars.azureStorageAccountKey)) {
+        coreConfig.types.blobStorageConnector.push({
+            type: BlobStorageConnectorType.AzureStorage,
+            options: {
+                config: {
+                    accountName: envVars.azureStorageAccountName,
+                    accountKey: envVars.azureStorageAccountKey,
+                    containerName: envVars.azureStorageContainerName,
+                    endpoint: envVars.azureStorageEndpoint
+                },
+                storagePrefix: envVars.blobStoragePrefix
+            }
+        });
+    }
+    if (Is.stringValue(envVars.gcpStorageCredentials)) {
+        coreConfig.types.blobStorageConnector.push({
+            type: BlobStorageConnectorType.GcpStorage,
+            options: {
+                config: {
+                    projectId: envVars.gcpStorageProjectId,
+                    credentials: envVars.gcpStorageCredentials,
+                    bucketName: envVars.gcpStorageBucketName,
+                    apiEndpoint: envVars.gcpFirestoreApiEndpoint
+                },
+                storagePrefix: envVars.blobStoragePrefix
+            }
+        });
+    }
+    const defaultStorageConnectorType = envVars.blobStorageConnectorType;
+    if (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 === LoggingConnectorType.Console) {
+            coreConfig.types.loggingConnector?.push({
+                type: LoggingConnectorType.Console,
+                options: {
+                    config: {
+                        translateMessages: true,
+                        hideGroups: true
+                    }
+                }
+            });
+        }
+        else if (loggingConnector === LoggingConnectorType.EntityStorage) {
+            coreConfig.types.loggingConnector?.push({
+                type: LoggingConnectorType.EntityStorage
+            });
+        }
+    }
+    if (loggingConnectors.length > 1) {
+        coreConfig.types.loggingConnector?.push({
+            type: 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 === VaultConnectorType.EntityStorage) {
+        coreConfig.types.vaultConnector.push({
+            type: VaultConnectorType.EntityStorage
+        });
+    }
+    else if (envVars.vaultConnector === VaultConnectorType.Hashicorp) {
+        coreConfig.types.vaultConnector.push({
+            type: 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 === BackgroundTaskConnectorType.EntityStorage) {
+        coreConfig.types.backgroundTaskConnector.push({
+            type: 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 === TelemetryConnectorType.EntityStorage) {
+        coreConfig.types.telemetryConnector.push({
+            type: 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 === FaucetConnectorType.EntityStorage) {
+        coreConfig.types.faucetConnector.push({
+            type: FaucetConnectorType.EntityStorage
+        });
+    }
+    else if (envVars.faucetConnector === FaucetConnectorType.Iota) {
+        coreConfig.types.faucetConnector.push({
+            type: FaucetConnectorType.Iota,
+            options: {
+                config: {
+                    endpoint: envVars.iotaFaucetEndpoint,
+                    clientOptions: {
+                        nodes: [envVars.iotaNodeEndpoint]
+                    },
+                    bech32Hrp: envVars.iotaBech32Hrp,
+                    coinType: 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 === WalletConnectorType.EntityStorage) {
+        coreConfig.types.walletConnector.push({
+            type: WalletConnectorType.EntityStorage
+        });
+    }
+    else if (envVars.walletConnector === WalletConnectorType.Iota) {
+        coreConfig.types.walletConnector.push({
+            type: WalletConnectorType.Iota,
+            options: {
+                config: {
+                    clientOptions: {
+                        nodes: [envVars.iotaNodeEndpoint]
+                    },
+                    bech32Hrp: envVars.iotaBech32Hrp,
+                    coinType: 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 === NftConnectorType.EntityStorage) {
+        coreConfig.types.nftConnector.push({
+            type: NftConnectorType.EntityStorage
+        });
+    }
+    else if (envVars.nftConnector === NftConnectorType.Iota) {
+        coreConfig.types.nftConnector.push({
+            type: NftConnectorType.Iota,
+            options: {
+                config: {
+                    clientOptions: {
+                        nodes: [envVars.iotaNodeEndpoint]
+                    },
+                    bech32Hrp: envVars.iotaBech32Hrp,
+                    coinType: 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 === ImmutableStorageConnectorType.EntityStorage) {
+        coreConfig.types.immutableStorageConnector.push({
+            type: ImmutableStorageConnectorType.EntityStorage
+        });
+    }
+    else if (envVars.immutableStorageConnector === ImmutableStorageConnectorType.Iota) {
+        coreConfig.types.immutableStorageConnector.push({
+            type: ImmutableStorageConnectorType.Iota,
+            options: {
+                config: {
+                    clientOptions: {
+                        nodes: [envVars.iotaNodeEndpoint]
+                    },
+                    bech32Hrp: envVars.iotaBech32Hrp,
+                    coinType: 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 === IdentityConnectorType.EntityStorage) {
+        coreConfig.types.identityConnector.push({
+            type: IdentityConnectorType.EntityStorage
+        });
+    }
+    else if (envVars.identityConnector === IdentityConnectorType.Iota) {
+        coreConfig.types.identityConnector.push({
+            type: IdentityConnectorType.Iota,
+            options: {
+                config: {
+                    clientOptions: {
+                        nodes: [envVars.iotaNodeEndpoint]
+                    },
+                    bech32Hrp: envVars.iotaBech32Hrp,
+                    coinType: 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 === IdentityConnectorType.EntityStorage) {
+        coreConfig.types.identityProfileConnector.push({
+            type: 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 === AttestationConnectorType.EntityStorage) {
+        coreConfig.types.attestationConnector.push({
+            type: AttestationConnectorType.EntityStorage
+        });
+    }
+    else if (envVars.attestationConnector === AttestationConnectorType.Iota) {
+        coreConfig.types.attestationConnector.push({
+            type: 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) && Is.stringValue(process.env[envVar])) {
+                const camelCaseName = StringHelper.camelCase(envVar.replace(prefix, "").toLowerCase());
+                ObjectHelper.propertySet(result, camelCaseName, process.env[envVar]);
+            }
+        }
+        return result;
+    }
+}
+
+export { Engine, EnvHelper, buildEngineConfiguration };

package/dist/types/engine.d.ts

@@ -0,0 +1,17 @@
+import { EngineCore, type IEngineCoreOptions } from "@twin.org/engine-core";
+import type { IEngineState } from "@twin.org/engine-models";
+import type { IEngineCoreTypesConfig } from "@twin.org/engine-types";
+/**
+ * The engine with built in types.
+ */
+export declare class Engine<C extends IEngineCoreTypesConfig = IEngineCoreTypesConfig, S extends IEngineState = IEngineState> extends EngineCore<C, S> {
+    /**
+     * Runtime name for the class.
+     */
+    readonly CLASS_NAME: string;
+    /**
+     * Create a new instance of Engine.
+     * @param options The options for the engine.
+     */
+    constructor(options?: IEngineCoreOptions<C, S>);
+}

package/dist/types/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./engine";
+export * from "./models/IEngineEnvironmentVariables";
+export * from "./utils/engineEnvBuilder";
+export * from "./utils/envHelper";