terruvim-core-test 0.0.1

package/dist/src/factories/validateBedrockConfig.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateBedrockConfig = validateBedrockConfig;
+function validateBedrockConfig(config) {
+    if (!config.id) {
+        throw new Error("Bedrock config must include an id");
+    }
+    if (!config.configuration) {
+        throw new Error("Bedrock config must include configuration");
+    }
+    const { configuration } = config;
+    if (!configuration.foundationModel) {
+        throw new Error("Bedrock config must include foundationModel");
+    }
+    if (!configuration.foundationModel.modelId) {
+        throw new Error("Foundation model must have a modelId");
+    }
+    if (!configuration.foundationModel.region) {
+        throw new Error("Foundation model must have a region");
+    }
+    const supportedModels = [
+        'eu.anthropic.claude-3-7-sonnet-20250219-v1:0',
+        'anthropic.claude-3-sonnet-20240229-v1:0',
+        'anthropic.claude-3-haiku-20240307-v1:0',
+        'anthropic.claude-3-opus-20240229-v1:0',
+        'anthropic.claude-v2:1',
+        'anthropic.claude-v2',
+        'amazon.titan-text-express-v1',
+        'amazon.titan-text-lite-v1',
+        'amazon.titan-embed-text-v1',
+        'cohere.command-text-v14',
+        'cohere.command-light-text-v14',
+        'ai21.j2-ultra-v1',
+        'ai21.j2-mid-v1',
+        'meta.llama2-13b-chat-v1',
+        'meta.llama2-70b-chat-v1'
+    ];
+    if (!supportedModels.some(model => configuration.foundationModel.modelId.includes(model.split(':')[0]))) {
+        console.warn(`Model ID ${configuration.foundationModel.modelId} may not be supported. Supported models: ${supportedModels.join(', ')}`);
+    }
+    if (configuration.knowledgeBases) {
+        configuration.knowledgeBases.forEach((kb, index) => {
+            if (!kb.name) {
+                throw new Error(`Knowledge base at index ${index} must have a name`);
+            }
+            if (!kb.description) {
+                throw new Error(`Knowledge base '${kb.name}' must have a description`);
+            }
+            if (!kb.vectorDatabase.type) {
+                throw new Error(`Knowledge base '${kb.name}' must specify vector database type`);
+            }
+            if (kb.vectorDatabase.type === 'opensearch' && !kb.vectorDatabase.opensearchConfiguration) {
+                throw new Error(`Knowledge base '${kb.name}' with OpenSearch type must have opensearchConfiguration`);
+            }
+            if (!kb.embeddingModel.modelArn) {
+                throw new Error(`Knowledge base '${kb.name}' must have an embedding model ARN`);
+            }
+            if (kb.dataSource) {
+                if (kb.dataSource.type === 's3' && !kb.dataSource.s3Configuration?.bucketArn) {
+                    throw new Error(`Knowledge base '${kb.name}' with S3 data source must have bucketArn`);
+                }
+            }
+        });
+    }
+    if (configuration.agents) {
+        configuration.agents.forEach((agent, index) => {
+            if (!agent.name) {
+                throw new Error(`Agent at index ${index} must have a name`);
+            }
+            if (!agent.description) {
+                throw new Error(`Agent '${agent.name}' must have a description`);
+            }
+            if (!agent.foundationModel) {
+                throw new Error(`Agent '${agent.name}' must specify a foundation model`);
+            }
+            if (!agent.instruction) {
+                throw new Error(`Agent '${agent.name}' must have instructions`);
+            }
+            if (agent.actionGroups) {
+                agent.actionGroups.forEach((actionGroup, agIndex) => {
+                    if (!actionGroup.actionGroupName) {
+                        throw new Error(`Action group at index ${agIndex} for agent '${agent.name}' must have a name`);
+                    }
+                    if (!actionGroup.actionGroupExecutor.lambda) {
+                        throw new Error(`Action group '${actionGroup.actionGroupName}' for agent '${agent.name}' must have a lambda executor`);
+                    }
+                });
+            }
+        });
+    }
+    if (configuration.guardrails) {
+        configuration.guardrails.forEach((guardrail, index) => {
+            if (!guardrail.name) {
+                throw new Error(`Guardrail at index ${index} must have a name`);
+            }
+            if (!guardrail.description) {
+                throw new Error(`Guardrail '${guardrail.name}' must have a description`);
+            }
+            if (!guardrail.blockedInputMessaging) {
+                throw new Error(`Guardrail '${guardrail.name}' must have blockedInputMessaging`);
+            }
+            if (!guardrail.blockedOutputsMessaging) {
+                throw new Error(`Guardrail '${guardrail.name}' must have blockedOutputsMessaging`);
+            }
+        });
+    }
+    if (configuration.security?.enableVpcEndpoint && !configuration.security.vpcEndpointConfig) {
+        throw new Error("VPC endpoint configuration is required when enableVpcEndpoint is true");
+    }
+    if (configuration.security?.vpcEndpointConfig) {
+        if (!configuration.security.vpcEndpointConfig.subnetIds ||
+            configuration.security.vpcEndpointConfig.subnetIds.length === 0) {
+            throw new Error("VPC endpoint configuration must include subnet IDs");
+        }
+        if (!configuration.security.vpcEndpointConfig.securityGroupIds ||
+            configuration.security.vpcEndpointConfig.securityGroupIds.length === 0) {
+            throw new Error("VPC endpoint configuration must include security group IDs");
+        }
+    }
+    if (configuration.costOptimization?.enableProvisionedThroughput &&
+        !configuration.costOptimization.provisionedModelUnits) {
+        throw new Error("Provisioned model units must be specified when enabling provisioned throughput");
+    }
+}

package/dist/src/factories/validateDashboardConfig.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateDashboardConfig = validateDashboardConfig;
+function validateDashboardConfig(config) {
+    if (!config.id || !config.name || !Array.isArray(config.widgets)) {
+        throw new Error("Dashboard config must include id, name, and widgets (array)");
+    }
+    if (config.widgets.length === 0) {
+        throw new Error("Dashboard widgets array must not be empty");
+    }
+    for (const widget of config.widgets) {
+        if (!widget.type || !widget.properties) {
+            throw new Error("Each widget must have a type and properties");
+        }
+    }
+    if (config.tags && typeof config.tags !== 'object') {
+        throw new Error("tags must be an object");
+    }
+    if (config.description && typeof config.description !== 'string') {
+        throw new Error("description must be a string");
+    }
+    if (config.notes && typeof config.notes !== 'string') {
+        throw new Error("notes must be a string");
+    }
+    if (config.meta && typeof config.meta !== 'object') {
+        throw new Error("meta must be an object");
+    }
+}

package/dist/src/factories/validateEventBridgeConfig.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateEventBridgeConfig = validateEventBridgeConfig;
+function validateEventBridgeConfig(config) {
+    if (!config.configuration || !config.configuration.name) {
+        throw new Error("EventBridge config must include configuration with name");
+    }
+    if (config.configuration.tags && typeof config.configuration.tags !== "object") {
+        throw new Error("tags must be an object");
+    }
+    if (config.configuration.policy && typeof config.configuration.policy !== "object") {
+        throw new Error("policy must be an object");
+    }
+}

package/dist/src/factories/validateHostedZoneConfig.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateHostedZoneConfig = validateHostedZoneConfig;
+function validateHostedZoneConfig(config) {
+    if (!config.configuration || !config.configuration.name) {
+        throw new Error("HostedZone config must include configuration with name");
+    }
+    if (config.configuration.comment && typeof config.configuration.comment !== "string") {
+        throw new Error("comment must be a string");
+    }
+    if (config.configuration.tags && typeof config.configuration.tags !== "object") {
+        throw new Error("tags must be an object");
+    }
+    if (config.configuration.forceDestroy && typeof config.configuration.forceDestroy !== "boolean") {
+        throw new Error("forceDestroy must be a boolean");
+    }
+    if (config.configuration.vpc && typeof config.configuration.vpc !== "object") {
+        throw new Error("vpc must be an object");
+    }
+    if (config.configuration.delegationSetId && typeof config.configuration.delegationSetId !== "string") {
+        throw new Error("delegationSetId must be a string");
+    }
+    if (config.configuration.queryLoggingConfig && typeof config.configuration.queryLoggingConfig !== "object") {
+        throw new Error("queryLoggingConfig must be an object");
+    }
+}

package/dist/src/factories/validateIamRoleConfig.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateIamRoleConfig = validateIamRoleConfig;
+function validateIamRoleConfig(config) {
+    if (!config.configuration || !config.configuration.name || !config.configuration.assumeRolePolicy) {
+        throw new Error("IAM Role config must include configuration with name and assumeRolePolicy");
+    }
+}

package/dist/src/factories/validateKmsKeyConfig.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateKmsKeyConfig = validateKmsKeyConfig;
+function validateKmsKeyConfig(config) {
+    if (!config.configuration || !config.configuration.description) {
+        throw new Error("KMS Key config must include configuration with description");
+    }
+}

package/dist/src/factories/validateRdsConfig.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateRdsConfig = validateRdsConfig;
+function validateRdsConfig(config) {
+    if (!config.configuration || !config.configuration.engine) {
+        throw new Error("RDS config must include configuration with engine");
+    }
+    if (config.configuration.storageEncrypted === false) {
+        console.warn("[WARN] RDS instance is not encrypted. This is not recommended for production.");
+    }
+    if (!config.configuration.deletionProtection) {
+        console.warn("[WARN] RDS instance does not have deletion protection enabled. This is not recommended for production.");
+    }
+    if (!config.inputs || !config.inputs.subnetIds || config.inputs.subnetIds.length === 0) {
+        throw new Error("RDS config must include at least one subnetId");
+    }
+}

package/dist/src/factories/validateRoute53RecordConfig.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateRoute53RecordConfig = validateRoute53RecordConfig;
+function validateRoute53RecordConfig(config) {
+    if (!config.configuration || !config.configuration.zoneId || !config.configuration.name || !config.configuration.type) {
+        throw new Error("Record config must include configuration with zoneId, name, type");
+    }
+    if (config.configuration.ttl && typeof config.configuration.ttl !== "number") {
+        throw new Error("ttl must be a number");
+    }
+    if (config.configuration.records && !Array.isArray(config.configuration.records)) {
+        throw new Error("records must be an array");
+    }
+    if (config.configuration.alias && typeof config.configuration.alias !== "object") {
+        throw new Error("alias must be an object");
+    }
+    if (config.configuration.setIdentifier && typeof config.configuration.setIdentifier !== "string") {
+        throw new Error("setIdentifier must be a string");
+    }
+    if (config.configuration.failover && typeof config.configuration.failover !== "string") {
+        throw new Error("failover must be a string");
+    }
+    if (config.configuration.healthCheckId && typeof config.configuration.healthCheckId !== "string") {
+        throw new Error("healthCheckId must be a string");
+    }
+    if (config.configuration.multivalueAnswer && typeof config.configuration.multivalueAnswer !== "boolean") {
+        throw new Error("multivalueAnswer must be a boolean");
+    }
+    if (config.configuration.geoLocation && typeof config.configuration.geoLocation !== "object") {
+        throw new Error("geoLocation must be an object");
+    }
+    if (config.configuration.latencyRoutingRegion && typeof config.configuration.latencyRoutingRegion !== "string") {
+        throw new Error("latencyRoutingRegion must be a string");
+    }
+    if (config.configuration.cidrRoutingPolicy && typeof config.configuration.cidrRoutingPolicy !== "object") {
+        throw new Error("cidrRoutingPolicy must be an object");
+    }
+    if (config.configuration.comment && typeof config.configuration.comment !== "string") {
+        throw new Error("comment must be a string");
+    }
+}

package/dist/src/factories/validateS3Config.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateS3Config = validateS3Config;
+function validateS3Config(config) {
+    if (!config.configuration || !config.configuration.bucket) {
+        throw new Error("S3 config must include configuration with bucket");
+    }
+}

package/dist/src/factories/validateSecretsManagerConfig.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateSecretsManagerConfig = validateSecretsManagerConfig;
+function validateSecretsManagerConfig(config) {
+    if (!config.configuration || !config.configuration.name) {
+        throw new Error("SecretsManager config must include configuration with name");
+    }
+}

package/dist/src/factories/validateSecurityGroupConfig.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateSecurityGroupConfig = validateSecurityGroupConfig;
+function validateSecurityGroupConfig(config) {
+    if (!(config.inputs.vpcId || config.configuration.vpcId)) {
+        throw new Error("SecurityGroup config must include vpcId");
+    }
+}

package/dist/src/factories/validateSecurityGroupRuleConfig.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateSecurityGroupRuleConfig = validateSecurityGroupRuleConfig;
+function validateSecurityGroupRuleConfig(config) {
+    if (!(config.inputs.securityGroupId || config.configuration.securityGroupId)) {
+        throw new Error("SecurityGroupRule config must include securityGroupId");
+    }
+}

package/dist/src/factories/validateSesDomainDkimConfig.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateSesDomainDkimConfig = validateSesDomainDkimConfig;
+function validateSesDomainDkimConfig(config) {
+    if (!config.configuration || !config.configuration.domain) {
+        throw new Error("SES DomainDkim config must include configuration with domain");
+    }
+}

package/dist/src/factories/validateSesDomainIdentityConfig.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateSesDomainIdentityConfig = validateSesDomainIdentityConfig;
+function validateSesDomainIdentityConfig(config) {
+    if (!config.configuration || !config.configuration.domain) {
+        throw new Error("SES config must include configuration with domain");
+    }
+}

package/dist/src/factories/validateSesIdentitiesConfig.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateSesIdentitiesConfig = validateSesIdentitiesConfig;
+function validateSesIdentitiesConfig(config) {
+    if (!config.configuration) {
+        throw new Error("SES Identities configuration is required");
+    }
+    const { domains, emails } = config.configuration;
+    if (!domains && !emails) {
+        throw new Error("At least one domain or email identity must be specified");
+    }
+    if (domains) {
+        if (!Array.isArray(domains)) {
+            throw new Error("Domains configuration must be an array");
+        }
+        domains.forEach((domain, index) => {
+            if (!domain.domain || typeof domain.domain !== 'string') {
+                throw new Error(`Domain at index ${index} must have a valid domain string`);
+            }
+            const domainRegex = /^[a-zA-Z0-9][a-zA-Z0-9-]{1,61}[a-zA-Z0-9]\.[a-zA-Z]{2,}$/;
+            if (!domainRegex.test(domain.domain)) {
+                throw new Error(`Domain at index ${index} has invalid format: ${domain.domain}`);
+            }
+        });
+    }
+    if (emails) {
+        if (!Array.isArray(emails)) {
+            throw new Error("Emails configuration must be an array");
+        }
+        emails.forEach((emailConfig, index) => {
+            if (!emailConfig.email || typeof emailConfig.email !== 'string') {
+                throw new Error(`Email at index ${index} must have a valid email string`);
+            }
+            const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+            if (!emailRegex.test(emailConfig.email)) {
+                throw new Error(`Email at index ${index} has invalid format: ${emailConfig.email}`);
+            }
+        });
+    }
+}

package/dist/src/factories/validateSnsConfig.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateSnsConfig = validateSnsConfig;
+function validateSnsConfig(config) {
+    if (!config.configuration || !config.configuration.name) {
+        throw new Error("SNS config must include configuration with name");
+    }
+    if (config.configuration.tags && typeof config.configuration.tags !== "object") {
+        throw new Error("tags must be an object");
+    }
+}

package/dist/src/factories/validateSqsConfig.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateSqsConfig = validateSqsConfig;
+function validateSqsConfig(config) {
+    if (!config.configuration || !config.configuration.name) {
+        throw new Error("SQS config must include configuration with name");
+    }
+    if (config.configuration.tags && typeof config.configuration.tags !== "object") {
+        throw new Error("tags must be an object");
+    }
+}

package/dist/src/factories/validateSsmParameterFactoryConfig.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateSsmParameterFactoryConfig = validateSsmParameterFactoryConfig;
+function validateSsmParameterFactoryConfig(config) {
+    if (!config.id)
+        throw new Error("SsmParameterFactoryConfig must include id");
+    if (!config.configuration || !config.configuration.parameters)
+        throw new Error("SsmParameterFactoryConfig must include parameters");
+}

package/dist/src/factories/validateStepFunctionsConfig.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateStepFunctionsConfig = validateStepFunctionsConfig;
+function validateStepFunctionsConfig(config) {
+    if (!config.configuration || !config.configuration.name || !config.configuration.definition) {
+        throw new Error("StepFunctions config must include configuration with name and definition");
+    }
+}

package/dist/src/factories/vpcEndpointFactory.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VpcEndpointFactory = void 0;
+const resourceFactory_1 = require("./resourceFactory");
+const createVpcEndpoint_1 = require("./createVpcEndpoint");
+class VpcEndpointFactory extends resourceFactory_1.ResourceFactory {
+    async createResource(config, provider) {
+        if (config.inputs?.hooks?.preCreate) {
+            for (const hook of config.inputs.hooks.preCreate) {
+                await this.runHook(hook, config);
+            }
+        }
+        const actualConfig = config.configuration || config;
+        if (actualConfig.vpcEndpointType === "Gateway") {
+            if (actualConfig.subnetIds)
+                throw new Error("subnetIds not allowed for Gateway endpoint");
+            if (actualConfig.securityGroupIds)
+                throw new Error("securityGroupIds not allowed for Gateway endpoint");
+            if (actualConfig.privateDnsEnabled)
+                throw new Error("privateDnsEnabled not allowed for Gateway endpoint");
+        }
+        if (actualConfig.vpcEndpointType === "Interface") {
+            if (actualConfig.routeTableIds)
+                throw new Error("routeTableIds not allowed for Interface endpoint");
+        }
+        const resource = (0, createVpcEndpoint_1.createVpcEndpoint)({
+            name: actualConfig.name,
+            vpcId: actualConfig.vpcId,
+            serviceName: actualConfig.serviceName,
+            vpcEndpointType: actualConfig.vpcEndpointType,
+            subnetIds: actualConfig.subnetIds,
+            routeTableIds: actualConfig.routeTableIds,
+            securityGroupIds: actualConfig.securityGroupIds,
+            privateDnsEnabled: actualConfig.privateDnsEnabled,
+            tags: actualConfig.tags,
+            provider: config.inputs?.provider || config.provider,
+            policy: actualConfig.policy,
+            ipAddressType: actualConfig.ipAddressType,
+            dnsOptions: actualConfig.dnsOptions,
+            connectionNotification: actualConfig.connectionNotification,
+            timeouts: actualConfig.timeouts,
+            dependsOn: actualConfig.dependsOn,
+        });
+        if (config.inputs?.hooks?.postCreate) {
+            for (const hook of config.inputs.hooks.postCreate) {
+                await this.runHook(hook, config, resource);
+            }
+        }
+        return resource;
+    }
+    getOutputs(resource, config) {
+        const allOutputs = {
+            id: resource.id,
+            dnsEntries: resource.dnsEntries,
+            vpcEndpointType: resource.vpcEndpointType,
+            serviceName: resource.serviceName,
+            arn: resource.arn,
+            networkInterfaceIds: resource.networkInterfaceIds,
+            state: resource.state,
+            tags: resource.tags,
+        };
+        if (config?.outputs) {
+            const filtered = {};
+            Object.keys(config.outputs).forEach(key => {
+                if (config.outputs && config.outputs[key] && allOutputs[key] !== undefined) {
+                    filtered[key] = allOutputs[key];
+                }
+            });
+            return filtered;
+        }
+        return allOutputs;
+    }
+    validateConfig(config) {
+        const actualConfig = config.configuration || config;
+        if (!actualConfig.serviceName || !actualConfig.vpcEndpointType || !actualConfig.vpcId) {
+            throw new Error("VpcEndpointConfig must include serviceName, vpcEndpointType, vpcId");
+        }
+        if (actualConfig.vpcEndpointType === "Gateway") {
+            if (actualConfig.subnetIds)
+                throw new Error("subnetIds not allowed for Gateway endpoint");
+            if (actualConfig.securityGroupIds)
+                throw new Error("securityGroupIds not allowed for Gateway endpoint");
+            if (actualConfig.privateDnsEnabled)
+                throw new Error("privateDnsEnabled not allowed for Gateway endpoint");
+        }
+        if (actualConfig.vpcEndpointType === "Interface") {
+            if (actualConfig.routeTableIds)
+                throw new Error("routeTableIds not allowed for Interface endpoint");
+        }
+    }
+    async runHook(hook, config, resource) {
+        if (hook.type === "lambda") {
+        }
+        else if (hook.type === "slack") {
+        }
+    }
+}
+exports.VpcEndpointFactory = VpcEndpointFactory;