terruvim-core-test 0.0.1

package/dist/src/factories/opensearchCollectionFactory.js

@@ -0,0 +1,109 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenSearchCollectionFactory = void 0;
+const aws = __importStar(require("@pulumi/aws"));
+const pulumi = __importStar(require("@pulumi/pulumi"));
+const resourceFactory_1 = require("./resourceFactory");
+class OpenSearchCollectionFactory extends resourceFactory_1.ResourceFactory {
+    async createResource(config, provider) {
+        const resourceName = `${config.meta.environment}-${config.id}`;
+        const collectionName = config.configuration.name;
+        let encryptionPolicy;
+        if (config.configuration.encryptionPolicy) {
+            encryptionPolicy = new aws.opensearch.ServerlessSecurityPolicy(`${resourceName}-encryption-policy`, {
+                name: config.configuration.encryptionPolicy.name,
+                type: config.configuration.encryptionPolicy.type,
+                description: config.configuration.encryptionPolicy.description,
+                policy: pulumi.output(config.configuration.encryptionPolicy.policy).apply(p => JSON.stringify(p)),
+            }, { provider });
+        }
+        let networkPolicy;
+        if (config.configuration.networkPolicy) {
+            networkPolicy = new aws.opensearch.ServerlessSecurityPolicy(`${resourceName}-network-policy`, {
+                name: config.configuration.networkPolicy.name,
+                type: config.configuration.networkPolicy.type,
+                description: config.configuration.networkPolicy.description,
+                policy: pulumi.output(config.configuration.networkPolicy.policy).apply(p => JSON.stringify(p)),
+            }, { provider, dependsOn: encryptionPolicy ? [encryptionPolicy] : [] });
+        }
+        const collection = new aws.opensearch.ServerlessCollection(resourceName, {
+            name: collectionName,
+            description: config.configuration.description,
+            type: config.configuration.type || "VECTORSEARCH",
+            standbyReplicas: config.configuration.standbyReplicas || "ENABLED",
+            tags: {
+                ...config.configuration.tags,
+                Name: collectionName,
+                Environment: config.meta.environment,
+            },
+        }, {
+            provider,
+            dependsOn: [
+                ...(encryptionPolicy ? [encryptionPolicy] : []),
+                ...(networkPolicy ? [networkPolicy] : []),
+            ],
+        });
+        if (config.configuration.accessPolicy) {
+            new aws.opensearch.ServerlessAccessPolicy(`${resourceName}-access-policy`, {
+                name: config.configuration.accessPolicy.name,
+                type: config.configuration.accessPolicy.type,
+                description: config.configuration.accessPolicy.description,
+                policy: pulumi.output(config.configuration.accessPolicy.policy).apply(p => JSON.stringify(p)),
+            }, { provider, dependsOn: [collection] });
+        }
+        return collection;
+    }
+    generateOutputs(resource) {
+        return {
+            arn: resource.arn,
+            id: resource.id,
+            collectionEndpoint: resource.collectionEndpoint,
+            dashboardEndpoint: resource.dashboardEndpoint,
+        };
+    }
+    validateConfig(config) {
+        if (!config.id) {
+            throw new Error("OpenSearch Collection configuration must have an 'id' field");
+        }
+        if (!config.configuration?.name) {
+            throw new Error("OpenSearch Collection configuration must have a 'name' field");
+        }
+    }
+    getOutputs(resource) {
+        return this.generateOutputs(resource);
+    }
+}
+exports.OpenSearchCollectionFactory = OpenSearchCollectionFactory;

package/dist/src/factories/organizationFactory.js

@@ -0,0 +1,221 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrganizationFactory = void 0;
+const aws = __importStar(require("@pulumi/aws"));
+const pulumi = __importStar(require("@pulumi/pulumi"));
+const resourceFactory_1 = require("./resourceFactory");
+const accountPermissions_1 = require("./accountPermissions");
+const backupPolicy_1 = require("./backupPolicy");
+const tagPolicies_1 = require("./tagPolicies");
+class OrganizationFactory extends resourceFactory_1.ResourceFactory {
+    organization;
+    orgUnits = {};
+    accounts = {};
+    iamGroups = {};
+    iamGroupPolicies = {};
+    iamUsers = {};
+    iamUserPolicies = {};
+    providers = {};
+    accountPermissions = {};
+    tagPolicies = {};
+    backupPolicies = {};
+    validateConfig(config) {
+        if (!config || typeof config !== "object")
+            throw new Error("Config must be an object");
+        const cfg = config.configuration ? config.configuration : config;
+        if (!cfg || typeof cfg !== "object")
+            throw new Error("Config.configuration must be an object");
+        if (!cfg.name || typeof cfg.name !== "string")
+            throw new Error("Config.name is required");
+        if (cfg.featureSet && cfg.featureSet !== "ALL" && cfg.featureSet !== "CONSOLIDATED_BILLING")
+            throw new Error("featureSet must be 'ALL' or 'CONSOLIDATED_BILLING'");
+        if (cfg.orgUnits && !Array.isArray(cfg.orgUnits))
+            throw new Error("orgUnits must be an array");
+    }
+    createResource(config) {
+        this.validateConfig(config);
+        const cfg = config.configuration ? config.configuration : config;
+        this.organization = this.createOrganization(cfg);
+        this.createStructure(cfg);
+        this.createIamGroups(cfg);
+        this.createIamUsers(cfg);
+        this.createProviders(cfg);
+        this.createAccountPermissions(cfg);
+        this.createTagPolicies(cfg);
+        this.createBackupPolicies(cfg);
+        return this.organization;
+    }
+    getOutputs(resource) {
+        return {
+            arn: resource.arn,
+            masterAccountArn: resource.masterAccountArn,
+            organization: resource,
+            orgUnits: this.orgUnits,
+            accounts: Object.values(this.accounts).map(acc => ({ id: acc.id, name: acc.name })),
+            iamGroups: this.iamGroups,
+            iamGroupPolicies: this.iamGroupPolicies,
+            iamUsers: this.iamUsers,
+            iamUserPolicies: this.iamUserPolicies,
+            providers: this.providers,
+            accountPermissions: this.accountPermissions,
+            tagPolicies: this.tagPolicies,
+            backupPolicies: this.backupPolicies,
+        };
+    }
+    createOrganization(cfg) {
+        return new aws.organizations.Organization(cfg.name, {
+            featureSet: cfg.featureSet || "ALL",
+        });
+    }
+    createStructure(cfg) {
+        if (cfg.orgUnits) {
+            for (const ouConfig of cfg.orgUnits) {
+                const ou = new aws.organizations.OrganizationalUnit(ouConfig.name, {
+                    parentId: this.organization.roots.apply(rs => rs[0].id),
+                    name: ouConfig.name,
+                });
+                this.orgUnits[ouConfig.name] = ou;
+                if (ouConfig.accounts) {
+                    for (const accConfig of ouConfig.accounts) {
+                        const acc = new aws.organizations.Account(accConfig.name, {
+                            name: accConfig.name,
+                            parentId: ou.id,
+                            email: accConfig.email,
+                            roleName: accConfig.roleName || "OrganizationalAccountAccessRole",
+                            closeOnDeletion: accConfig.closeOnDeletion ?? true,
+                        }, accConfig.protect ? { protect: true } : undefined);
+                        this.accounts[accConfig.name] = acc;
+                    }
+                }
+            }
+        }
+    }
+    createIamGroups(cfg) {
+        if (cfg.iamGroups) {
+            for (const group of cfg.iamGroups) {
+                const g = new aws.iam.Group(group.name, { name: group.name });
+                this.iamGroups[group.name] = g;
+                if (group.policyStatements) {
+                    const policy = new aws.iam.GroupPolicy(`${group.name}Policy`, {
+                        group: g.name,
+                        policy: JSON.stringify({
+                            Version: "2012-10-17",
+                            Statement: group.policyStatements,
+                        }),
+                    });
+                    this.iamGroupPolicies[group.name] = policy;
+                }
+            }
+        }
+    }
+    createIamUsers(cfg) {
+        if (cfg.iamUsers) {
+            for (const user of cfg.iamUsers) {
+                const u = new aws.iam.User(user.name, { name: user.name });
+                this.iamUsers[user.name] = u;
+                if (user.policyStatements) {
+                    const policy = new aws.iam.UserPolicy(`${user.name}Policy`, {
+                        user: u.name,
+                        policy: JSON.stringify({
+                            Version: "2012-10-17",
+                            Statement: user.policyStatements,
+                        }),
+                    });
+                    this.iamUserPolicies[user.name] = policy;
+                }
+            }
+        }
+    }
+    createProviders(cfg) {
+        if (cfg.providers) {
+            for (const providerConfig of cfg.providers) {
+                const accountId = providerConfig.accountId;
+                const roleName = providerConfig.roleName;
+                this.providers[providerConfig.name] = new aws.Provider(providerConfig.name, {
+                    allowedAccountIds: [accountId],
+                    assumeRole: {
+                        roleArn: pulumi.interpolate `arn:aws:iam::${accountId}:role/${roleName}`,
+                    },
+                });
+            }
+        }
+    }
+    createAccountPermissions(cfg) {
+        if (cfg.accountPermissions) {
+            for (const perm of cfg.accountPermissions) {
+                const automationUser = this.iamUsers[perm.automationUserName];
+                const provider = this.providers[perm.providerName];
+                const managementAccountId = pulumi.output(perm.managementAccountId);
+                this.accountPermissions[perm.name] = new accountPermissions_1.AccountPermissions(perm.name, {
+                    automationUser,
+                    managementAccountId,
+                    resourceNamesPrefix: perm.resourceNamesPrefix,
+                }, { provider });
+            }
+        }
+    }
+    createTagPolicies(cfg) {
+        if (cfg.tagPolicies) {
+            for (const tagPolicy of cfg.tagPolicies) {
+                const orgId = this.organization.id;
+                const costCenters = tagPolicy.costCenters.map(cc => ({
+                    allowedCostCenters: cc.allowedCostCenters,
+                    ou: this.orgUnits[cc.ouName],
+                }));
+                this.tagPolicies[tagPolicy.name] = new tagPolicies_1.TagPolicies(tagPolicy.name, {
+                    orgId,
+                    costCenters,
+                });
+            }
+        }
+    }
+    createBackupPolicies(cfg) {
+        if (cfg.backupPolicies) {
+            for (const backup of cfg.backupPolicies) {
+                const backupRegion = backup.backupRegion;
+                const primaryRegions = backup.primaryRegions.map(r => r);
+                this.backupPolicies[backup.name] = new backupPolicy_1.BackupPolicy(backup.name, {
+                    assumeRoleName: backup.assumeRoleName,
+                    accounts: Object.fromEntries(backup.accountNames.map(name => [name, this.accounts[name]])),
+                    backupRegion,
+                    primaryRegions,
+                    orgUnitId: this.orgUnits[backup.orgUnitName].id,
+                });
+            }
+        }
+    }
+}
+exports.OrganizationFactory = OrganizationFactory;

package/dist/src/factories/processReservedInstances.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processReservedInstances = processReservedInstances;
+function processReservedInstances(reservedInstances = []) {
+    return reservedInstances;
+}

package/dist/src/factories/processSavingsPlans.js

@@ -0,0 +1,43 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processSavingsPlans = processSavingsPlans;
+const pulumi = __importStar(require("@pulumi/pulumi"));
+function processSavingsPlans(savingsPlans = []) {
+    if (!savingsPlans)
+        return [];
+    pulumi.log.warn("Pulumi AWS provider does not support creating SavingsPlan resources directly. No resources will be created.");
+    return [];
+}

package/dist/src/factories/rdsFactory.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RdsFactory = void 0;
+const resourceFactory_1 = require("./resourceFactory");
+const validateRdsConfig_1 = require("./validateRdsConfig");
+const createAwsRdsSubnetGroup_1 = require("./createAwsRdsSubnetGroup");
+const createAwsRdsInstance_1 = require("./createAwsRdsInstance");
+class RdsFactory extends resourceFactory_1.ResourceFactory {
+    async createResource(config, provider) {
+        (0, validateRdsConfig_1.validateRdsConfig)(config);
+        const opts = provider ? { provider } : undefined;
+        const subnetGroup = (0, createAwsRdsSubnetGroup_1.createAwsRdsSubnetGroup)(`${config.meta.environment}-${config.id}-subnet-group`, {
+            subnetIds: config.inputs.subnetIds || [],
+            description: `Subnet group for ${config.meta.environment}-${config.id}`,
+        }, opts);
+        const instance = (0, createAwsRdsInstance_1.createAwsRdsInstance)(`${config.meta.environment}-${config.id}`, {
+            ...config.configuration,
+            dbSubnetGroupName: config.configuration.dbSubnetGroupName || subnetGroup.name,
+            vpcSecurityGroupIds: config.configuration.vpcSecurityGroupIds || (config.inputs.sgId ? [config.inputs.sgId] : []),
+            skipFinalSnapshot: typeof config.configuration.skipFinalSnapshot === 'boolean' ? config.configuration.skipFinalSnapshot : false,
+            finalSnapshotIdentifier: config.configuration.finalSnapshotIdentifier,
+            tags: config.configuration.tags,
+        }, opts);
+        return { instance };
+    }
+    getOutputs(resource) {
+        return {
+            id: resource.instance.id,
+            endpoint: resource.instance.endpoint,
+            username: resource.instance.username,
+            arn: resource.instance.arn,
+            subnetGroupName: resource.instance.dbSubnetGroupName,
+            sgId: Array.isArray(resource.instance.vpcSecurityGroupIds) ? resource.instance.vpcSecurityGroupIds[0] : resource.instance.vpcSecurityGroupIds,
+        };
+    }
+    validateConfig(config) {
+        (0, validateRdsConfig_1.validateRdsConfig)(config);
+    }
+}
+exports.RdsFactory = RdsFactory;

package/dist/src/factories/recordFactory.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RecordFactory = void 0;
+const resourceFactory_1 = require("./resourceFactory");
+const validateRoute53RecordConfig_1 = require("./validateRoute53RecordConfig");
+const createAwsRoute53Record_1 = require("./createAwsRoute53Record");
+class RecordFactory extends resourceFactory_1.ResourceFactory {
+    async createResource(config, provider) {
+        (0, validateRoute53RecordConfig_1.validateRoute53RecordConfig)(config);
+        return (0, createAwsRoute53Record_1.createAwsRoute53Record)(config.configuration.name, {
+            zoneId: config.configuration.zoneId,
+            name: config.configuration.name,
+            type: config.configuration.type,
+            ttl: config.configuration.ttl,
+            records: config.configuration.records,
+            aliases: config.configuration.alias ? [config.configuration.alias] : undefined,
+            setIdentifier: config.configuration.setIdentifier,
+            failover: config.configuration.failover,
+            healthCheckId: config.configuration.healthCheckId,
+            multivalueAnswer: config.configuration.multivalueAnswer,
+            geoLocation: config.configuration.geoLocation,
+            latencyRoutingRegion: config.configuration.latencyRoutingRegion,
+            cidrRoutingPolicy: config.configuration.cidrRoutingPolicy,
+            comment: config.configuration.comment,
+        }, provider);
+    }
+    getOutputs(resource) {
+        return {
+            fqdn: resource.fqdn,
+        };
+    }
+    validateConfig(config) {
+        (0, validateRoute53RecordConfig_1.validateRoute53RecordConfig)(config);
+    }
+}
+exports.RecordFactory = RecordFactory;

package/dist/src/factories/resolveEnvSecrets.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveEnvSecrets = resolveEnvSecrets;
+function resolveEnvSecrets(env, allSecrets) {
+    return env.map(envVar => {
+        if (typeof envVar.value === "string" && envVar.value.startsWith("${secret:")) {
+            const match = envVar.value.match(/^\$\{secret:([^:}]+):([^}]+)\}$/);
+            if (match && allSecrets[match[1]] && allSecrets[match[1]][match[2]]) {
+                return { name: envVar.name, value: allSecrets[match[1]][match[2]] };
+            }
+        }
+        return envVar;
+    });
+}

package/dist/src/factories/resourceFactory.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OutputsOnlyFactory = exports.ResourceFactory = void 0;
+class ResourceFactory {
+}
+exports.ResourceFactory = ResourceFactory;
+class OutputsOnlyFactory {
+    getOutputs(outputs) {
+        return outputs;
+    }
+}
+exports.OutputsOnlyFactory = OutputsOnlyFactory;