terruvim-core-test 0.0.1

package/dist/src/factories/savingsPlanFactory.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SavingsPlanFactory = void 0;
+const resourceFactory_1 = require("./resourceFactory");
+const processSavingsPlans_1 = require("./processSavingsPlans");
+const processReservedInstances_1 = require("./processReservedInstances");
+class SavingsPlanFactory extends resourceFactory_1.ResourceFactory {
+    async createResource(config) {
+        if (config.hooks?.beforeCreateResources)
+            await config.hooks.beforeCreateResources(config);
+        const resources = {};
+        resources.savingsPlans = (0, processSavingsPlans_1.processSavingsPlans)(config.configuration.savingsPlans);
+        resources.reservedInstances = (0, processReservedInstances_1.processReservedInstances)(config.configuration.reservedInstances);
+        if (config.hooks?.afterCreateResources)
+            await config.hooks.afterCreateResources(resources, config);
+        return resources;
+    }
+    getOutputs(resource) {
+        return resource;
+    }
+    validateConfig(config) {
+        if (!config.configuration)
+            throw new Error("SavingsPlanFactoryConfig must include configuration block");
+    }
+}
+exports.SavingsPlanFactory = SavingsPlanFactory;

package/dist/src/factories/secretsManagerFactory.js

@@ -0,0 +1,107 @@
+"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.SecretsManagerFactory = void 0;
+const pulumi = __importStar(require("@pulumi/pulumi"));
+const resourceFactory_1 = require("./resourceFactory");
+const validateSecretsManagerConfig_1 = require("./validateSecretsManagerConfig");
+const createAwsSecret_1 = require("./createAwsSecret");
+const createAwsSecretRotation_1 = require("./createAwsSecretRotation");
+const createAwsSecretVersion_1 = require("./createAwsSecretVersion");
+class SecretsManagerFactory extends resourceFactory_1.ResourceFactory {
+    async createResource(config, provider) {
+        (0, validateSecretsManagerConfig_1.validateSecretsManagerConfig)(config);
+        const { configuration } = config;
+        if (configuration.meta || configuration.notes) {
+            console.warn("[SecretsManagerFactory] 'meta' and 'notes' are for documentation only and will not be passed to the resource.");
+        }
+        const opts = provider ? { provider } : undefined;
+        const secret = (0, createAwsSecret_1.createAwsSecret)(configuration.name, {
+            name: configuration.name,
+            description: configuration.description,
+            kmsKeyId: configuration.kmsKeyId,
+            policy: configuration.policy ? JSON.stringify(configuration.policy) : undefined,
+            recoveryWindowInDays: configuration.recoveryWindowInDays,
+            forceOverwriteReplicaSecret: configuration.forceOverwriteReplicaSecret,
+            replicas: configuration.replica,
+            tags: configuration.tags,
+        }, opts);
+        if (configuration.rotationLambdaArn) {
+            (0, createAwsSecretRotation_1.createAwsSecretRotation)(`${configuration.name}-rotation`, {
+                secretId: secret.id,
+                rotationLambdaArn: configuration.rotationLambdaArn,
+                rotationRules: configuration.rotationRules,
+            }, opts);
+        }
+        if (configuration.secretString) {
+            const secretStringValue = this.resolveSecretString(configuration.secretString);
+            (0, createAwsSecretVersion_1.createAwsSecretVersion)(`${configuration.name}-version`, {
+                secretId: secret.id,
+                secretString: secretStringValue,
+            }, opts);
+        }
+        return secret;
+    }
+    resolveSecretString(secretString) {
+        const values = Object.values(secretString);
+        const hasOutputs = values.some(value => typeof value === 'object' &&
+            value !== null &&
+            typeof value.apply === 'function');
+        if (hasOutputs) {
+            const keys = Object.keys(secretString);
+            const outputValues = Object.values(secretString);
+            return pulumi.all(outputValues).apply((resolvedValues) => {
+                const resolvedObject = {};
+                keys.forEach((key, index) => {
+                    resolvedObject[key] = resolvedValues[index];
+                });
+                return JSON.stringify(resolvedObject);
+            });
+        }
+        else {
+            return JSON.stringify(secretString);
+        }
+    }
+    getOutputs(resource) {
+        return {
+            arn: resource.arn,
+            name: resource.name,
+        };
+    }
+    validateConfig(config) {
+        (0, validateSecretsManagerConfig_1.validateSecretsManagerConfig)(config);
+    }
+}
+exports.SecretsManagerFactory = SecretsManagerFactory;

package/dist/src/factories/securityGroupFactory.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SecurityGroupFactory = void 0;
+const resourceFactory_1 = require("./resourceFactory");
+const validateSecurityGroupConfig_1 = require("./validateSecurityGroupConfig");
+const createAwsSecurityGroup_1 = require("./createAwsSecurityGroup");
+class SecurityGroupFactory extends resourceFactory_1.ResourceFactory {
+    async createResource(config, provider) {
+        (0, validateSecurityGroupConfig_1.validateSecurityGroupConfig)(config);
+        const name = config.configuration.name || `${config.meta.environment}-${config.id}`;
+        const opts = provider ? { provider } : undefined;
+        return (0, createAwsSecurityGroup_1.createAwsSecurityGroup)(name, {
+            vpcId: config.inputs.vpcId || config.configuration.vpcId,
+            description: config.inputs.description || config.configuration.description,
+            tags: config.inputs.tags || config.configuration.tags,
+            ingress: config.configuration.ingress,
+            egress: config.configuration.egress,
+            revokeRulesOnDelete: config.configuration.revokeRulesOnDelete,
+        }, opts);
+    }
+    getOutputs(resource) {
+        return { id: resource.id };
+    }
+    validateConfig(config) {
+        (0, validateSecurityGroupConfig_1.validateSecurityGroupConfig)(config);
+    }
+}
+exports.SecurityGroupFactory = SecurityGroupFactory;

package/dist/src/factories/securityGroupRuleFactory.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SecurityGroupRuleFactory = void 0;
+const resourceFactory_1 = require("./resourceFactory");
+const validateSecurityGroupRuleConfig_1 = require("./validateSecurityGroupRuleConfig");
+const createAwsSecurityGroupRule_1 = require("./createAwsSecurityGroupRule");
+class SecurityGroupRuleFactory extends resourceFactory_1.ResourceFactory {
+    async createResource(config, provider) {
+        (0, validateSecurityGroupRuleConfig_1.validateSecurityGroupRuleConfig)(config);
+        const name = `${config.meta.environment}-${config.id}`;
+        const c = config.configuration;
+        const opts = provider ? { provider } : undefined;
+        return (0, createAwsSecurityGroupRule_1.createAwsSecurityGroupRule)(name, {
+            securityGroupId: config.inputs.securityGroupId || c.securityGroupId,
+            type: config.inputs.type || c.type,
+            fromPort: config.inputs.fromPort || c.fromPort,
+            toPort: config.inputs.toPort || c.toPort,
+            protocol: config.inputs.protocol || c.protocol,
+            cidrBlocks: config.inputs.cidrBlocks || c.cidrBlocks,
+            ipv6CidrBlocks: c.ipv6CidrBlocks,
+            prefixListIds: c.prefixListIds,
+            self: c.self,
+            sourceSecurityGroupId: config.inputs.sourceSecurityGroupId || c.sourceSecurityGroupId,
+            description: c.description,
+        }, opts);
+    }
+    getOutputs(resource) {
+        return {
+            id: resource.id,
+            securityGroupId: resource.securityGroupId,
+            type: resource.type,
+            fromPort: resource.fromPort,
+            toPort: resource.toPort,
+            protocol: resource.protocol,
+            cidrBlocks: resource.cidrBlocks,
+            sourceSecurityGroupId: resource.sourceSecurityGroupId,
+        };
+    }
+    validateConfig(config) {
+        (0, validateSecurityGroupRuleConfig_1.validateSecurityGroupRuleConfig)(config);
+    }
+}
+exports.SecurityGroupRuleFactory = SecurityGroupRuleFactory;

package/dist/src/factories/securityHubFactory.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SecurityHubFactory = void 0;
+const resourceFactory_1 = require("./resourceFactory");
+const createAwsSecurityHubAccount_1 = require("./createAwsSecurityHubAccount");
+const createAwsSecurityHubStandardsSubscription_1 = require("./createAwsSecurityHubStandardsSubscription");
+const createAwsSecurityHubStandardsControl_1 = require("./createAwsSecurityHubStandardsControl");
+const createAwsSecurityHubAutomationRule_1 = require("./createAwsSecurityHubAutomationRule");
+class SecurityHubFactory extends resourceFactory_1.ResourceFactory {
+    async createResource(config) {
+        if (config.hooks?.beforeCreateResources)
+            await config.hooks.beforeCreateResources(config);
+        const resources = {};
+        resources.account = (0, createAwsSecurityHubAccount_1.createAwsSecurityHubAccount)(config.id);
+        if (config.configuration.standards) {
+            resources.standards = config.configuration.standards.map(std => (0, createAwsSecurityHubStandardsSubscription_1.createAwsSecurityHubStandardsSubscription)(std, [resources.account]));
+        }
+        if (config.configuration.controls) {
+            resources.controls = config.configuration.controls.map(ctrl => (0, createAwsSecurityHubStandardsControl_1.createAwsSecurityHubStandardsControl)(ctrl));
+        }
+        if (config.configuration.automationRules) {
+            resources.automationRules = config.configuration.automationRules.map(rule => (0, createAwsSecurityHubAutomationRule_1.createAwsSecurityHubAutomationRule)(rule));
+        }
+        if (config.hooks?.afterCreateResources)
+            await config.hooks.afterCreateResources(resources, config);
+        return resources;
+    }
+    getOutputs(resources) {
+        const outputs = {};
+        if (resources.account) {
+            outputs.accountId = resources.account.id;
+            outputs.hubArn = resources.account.hubArn;
+        }
+        if (resources.standardsSubscriptions && resources.standardsSubscriptions.length > 0) {
+            outputs.standardsArns = resources.standardsSubscriptions.map((sub) => sub.standardsArn);
+            outputs.standardsSubscriptionArns = resources.standardsSubscriptions.map((sub) => sub.standardsSubscriptionArn);
+        }
+        if (resources.standardsControls && resources.standardsControls.length > 0) {
+            outputs.controlArns = resources.standardsControls.map((control) => control.standardsControlArn);
+            outputs.controlStatuses = resources.standardsControls.map((control) => control.controlStatus);
+        }
+        if (resources.automationRules && resources.automationRules.length > 0) {
+            outputs.automationRuleArns = resources.automationRules.map((rule) => rule.ruleArn);
+            outputs.automationRuleNames = resources.automationRules.map((rule) => rule.ruleName);
+        }
+        return outputs;
+    }
+    validateConfig(config) {
+        if (!config.id) {
+            throw new Error("SecurityHub factory configuration must include an 'id'");
+        }
+        if (!config.configuration) {
+            throw new Error("SecurityHub factory configuration must include a 'configuration' object");
+        }
+        if (config.configuration.standards) {
+            config.configuration.standards.forEach((standard, index) => {
+                if (!standard.standardsArn) {
+                    throw new Error(`SecurityHub standard at index ${index} must specify standardsArn`);
+                }
+                if (!standard.name) {
+                    throw new Error(`SecurityHub standard at index ${index} must specify name`);
+                }
+            });
+        }
+        if (config.configuration.controls) {
+            config.configuration.controls.forEach((control, index) => {
+                if (!control.standardsControlArn) {
+                    throw new Error(`SecurityHub control at index ${index} must specify standardsControlArn`);
+                }
+                if (!control.controlStatus || !["ENABLED", "DISABLED"].includes(control.controlStatus)) {
+                    throw new Error(`SecurityHub control '${control.standardsControlArn}' must have controlStatus of 'ENABLED' or 'DISABLED'`);
+                }
+                if (control.controlStatus === "DISABLED" && !control.disabledReason) {
+                    throw new Error(`SecurityHub control '${control.standardsControlArn}' with DISABLED status must specify disabledReason`);
+                }
+            });
+        }
+        if (config.configuration.automationRules) {
+            config.configuration.automationRules.forEach((rule, index) => {
+                if (!rule.ruleName) {
+                    throw new Error(`SecurityHub automation rule at index ${index} must specify ruleName`);
+                }
+                if (typeof rule.ruleOrder !== 'number' || rule.ruleOrder < 1 || rule.ruleOrder > 1000) {
+                    throw new Error(`SecurityHub automation rule '${rule.ruleName}' must have ruleOrder between 1 and 1000`);
+                }
+                if (!rule.criteria || typeof rule.criteria !== 'object') {
+                    throw new Error(`SecurityHub automation rule '${rule.ruleName}' must specify criteria object`);
+                }
+                if (!rule.actions || !Array.isArray(rule.actions) || rule.actions.length === 0) {
+                    throw new Error(`SecurityHub automation rule '${rule.ruleName}' must specify actions array with at least one action`);
+                }
+            });
+        }
+    }
+}
+exports.SecurityHubFactory = SecurityHubFactory;

package/dist/src/factories/sesDomainDkimFactory.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SesDomainDkimFactory = void 0;
+const resourceFactory_1 = require("./resourceFactory");
+const validateSesDomainDkimConfig_1 = require("./validateSesDomainDkimConfig");
+const createAwsSesDomainDkim_1 = require("./createAwsSesDomainDkim");
+class SesDomainDkimFactory extends resourceFactory_1.ResourceFactory {
+    async createResource(config) {
+        (0, validateSesDomainDkimConfig_1.validateSesDomainDkimConfig)(config);
+        return (0, createAwsSesDomainDkim_1.createAwsSesDomainDkim)(config.configuration.domain, {
+            domain: config.configuration.domain,
+        });
+    }
+    getOutputs(resource) {
+        return {
+            id: resource.id,
+            dkimTokens: resource.dkimTokens,
+            domain: resource.domain,
+        };
+    }
+    validateConfig(config) {
+        (0, validateSesDomainDkimConfig_1.validateSesDomainDkimConfig)(config);
+    }
+}
+exports.SesDomainDkimFactory = SesDomainDkimFactory;

package/dist/src/factories/sesFactory.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SesFactory = void 0;
+const resourceFactory_1 = require("./resourceFactory");
+const validateSesDomainIdentityConfig_1 = require("./validateSesDomainIdentityConfig");
+const createAwsSesDomainIdentity_1 = require("./createAwsSesDomainIdentity");
+class SesFactory extends resourceFactory_1.ResourceFactory {
+    async createResource(config) {
+        (0, validateSesDomainIdentityConfig_1.validateSesDomainIdentityConfig)(config);
+        return (0, createAwsSesDomainIdentity_1.createAwsSesDomainIdentity)(config.configuration.domain, {
+            domain: config.configuration.domain,
+        });
+    }
+    getOutputs(resource) {
+        return {
+            id: resource.id,
+            arn: resource.arn,
+            domain: resource.domain,
+        };
+    }
+    validateConfig(config) {
+        (0, validateSesDomainIdentityConfig_1.validateSesDomainIdentityConfig)(config);
+    }
+}
+exports.SesFactory = SesFactory;

package/dist/src/factories/sesIdentitiesFactory.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SesIdentitiesFactory = void 0;
+const resourceFactory_1 = require("./resourceFactory");
+const createAwsSesDomainIdentity_1 = require("./createAwsSesDomainIdentity");
+const createAwsSesEmailIdentity_1 = require("./createAwsSesEmailIdentity");
+const createAwsSesDomainDkim_1 = require("./createAwsSesDomainDkim");
+const createAwsRoute53Record_1 = require("./createAwsRoute53Record");
+class SesIdentitiesFactory extends resourceFactory_1.ResourceFactory {
+    static supportsProviderRegistry = true;
+    async createResource(config, provider, providerRegistry = {}) {
+        if (!config.configuration) {
+            throw new Error("SES Identities configuration is required");
+        }
+        if (!config.configuration.domains && !config.configuration.emails) {
+            throw new Error("At least one domain or email identity must be specified");
+        }
+        const getRoute53Provider = () => {
+            const route53Provider = config.inputs?.route53Provider;
+            let selectedProvider;
+            if (!route53Provider)
+                selectedProvider = provider;
+            else if (typeof route53Provider === "object" && route53Provider !== null)
+                selectedProvider = route53Provider;
+            else if (typeof route53Provider === "string" && providerRegistry && providerRegistry[route53Provider])
+                selectedProvider = providerRegistry[route53Provider];
+            else {
+                throw new Error(`route53Provider='${route53Provider}' is not found in providerRegistry. Available keys: ${Object.keys(providerRegistry).join(", ")}. Must be an aws.Provider object or a valid provider name string for cross-account Route53 access.`);
+            }
+            return selectedProvider;
+        };
+        const resources = {
+            domainIdentities: [],
+            emailIdentities: [],
+            dkimResources: [],
+            dnsRecords: []
+        };
+        if (config.configuration.domains) {
+            for (const domainConfig of config.configuration.domains) {
+                const domainIdentity = (0, createAwsSesDomainIdentity_1.createAwsSesDomainIdentity)(`${config.id}-domain-${domainConfig.domain.replace(/\./g, '-')}`, {
+                    domain: domainConfig.domain,
+                });
+                resources.domainIdentities.push(domainIdentity);
+                if (domainConfig.enableDkim !== false) {
+                    const dkim = (0, createAwsSesDomainDkim_1.createAwsSesDomainDkim)(`${config.id}-dkim-${domainConfig.domain.replace(/\./g, '-')}`, {
+                        domain: domainConfig.domain,
+                    });
+                    resources.dkimResources.push(dkim);
+                    if (config.configuration.dnsConfiguration?.autoCreateRecords && config.inputs?.hostedZoneId) {
+                        const recordProvider = domainConfig.crossAccountDns ? getRoute53Provider() : provider;
+                        for (let i = 0; i < 3; i++) {
+                            const dkimRecord = (0, createAwsRoute53Record_1.createAwsRoute53Record)(`${config.id}-dkim-${i}-${domainConfig.domain.replace(/\./g, '-')}`, {
+                                zoneId: config.inputs.hostedZoneId,
+                                name: dkim.dkimTokens.apply(tokens => `${tokens[i]}._domainkey.${domainConfig.domain}`),
+                                type: "CNAME",
+                                ttl: config.configuration.dnsConfiguration?.ttl || 300,
+                                records: [dkim.dkimTokens.apply(tokens => `${tokens[i]}.dkim.amazonses.com`)],
+                                allowOverwrite: true,
+                            }, recordProvider);
+                            resources.dnsRecords.push(dkimRecord);
+                        }
+                    }
+                }
+                if (domainConfig.enableSpf && config.configuration.dnsConfiguration?.autoCreateRecords && config.inputs?.hostedZoneId) {
+                    const recordProvider = domainConfig.crossAccountDns ? getRoute53Provider() : provider;
+                    const spfRecord = (0, createAwsRoute53Record_1.createAwsRoute53Record)(`${config.id}-spf-${domainConfig.domain.replace(/\./g, '-')}`, {
+                        zoneId: config.inputs.hostedZoneId,
+                        name: domainConfig.domain,
+                        type: "TXT",
+                        ttl: config.configuration.dnsConfiguration?.ttl || 300,
+                        records: [domainConfig.spfRecord || "v=spf1 include:amazonses.com ~all"],
+                        allowOverwrite: true,
+                    }, recordProvider);
+                    resources.dnsRecords.push(spfRecord);
+                }
+                if (domainConfig.enableDmarc && config.configuration.dnsConfiguration?.autoCreateRecords && config.inputs?.hostedZoneId) {
+                    const recordProvider = domainConfig.crossAccountDns ? getRoute53Provider() : provider;
+                    const dmarcRecord = (0, createAwsRoute53Record_1.createAwsRoute53Record)(`${config.id}-dmarc-${domainConfig.domain.replace(/\./g, '-')}`, {
+                        zoneId: config.inputs.hostedZoneId,
+                        name: `_dmarc.${domainConfig.domain}`,
+                        type: "TXT",
+                        ttl: config.configuration.dnsConfiguration?.ttl || 300,
+                        records: [domainConfig.dmarcPolicy || "v=DMARC1; p=quarantine; rua=mailto:dmarc@" + domainConfig.domain],
+                        allowOverwrite: true,
+                    }, recordProvider);
+                    resources.dnsRecords.push(dmarcRecord);
+                }
+                if (config.configuration.dnsConfiguration?.autoCreateRecords && config.inputs?.hostedZoneId) {
+                    const recordProvider = domainConfig.crossAccountDns ? getRoute53Provider() : provider;
+                    const verificationRecord = (0, createAwsRoute53Record_1.createAwsRoute53Record)(`${config.id}-verification-${domainConfig.domain.replace(/\./g, '-')}`, {
+                        zoneId: config.inputs.hostedZoneId,
+                        name: `_amazonses.${domainConfig.domain}`,
+                        type: "TXT",
+                        ttl: config.configuration.dnsConfiguration?.ttl || 300,
+                        records: [domainIdentity.verificationToken],
+                        allowOverwrite: true,
+                    }, recordProvider);
+                    resources.dnsRecords.push(verificationRecord);
+                }
+            }
+        }
+        if (config.configuration.emails) {
+            for (const emailConfig of config.configuration.emails) {
+                const emailIdentity = (0, createAwsSesEmailIdentity_1.createAwsSesEmailIdentity)(`${config.id}-email-${emailConfig.email.replace(/[@\.]/g, '-')}`, {
+                    email: emailConfig.email,
+                });
+                resources.emailIdentities.push(emailIdentity);
+            }
+        }
+        return resources;
+    }
+    getOutputs(resource) {
+        return {
+            domainIdentityArns: resource.domainIdentities.map(identity => identity.arn),
+            emailIdentityArns: resource.emailIdentities.map(identity => identity.arn),
+            dkimTokens: resource.dkimResources.map(dkim => dkim.dkimTokens),
+            dnsRecords: resource.dnsRecords.map(record => ({
+                name: record.name,
+                type: record.type,
+                records: record.records
+            })),
+            verificationTokens: resource.domainIdentities.map(identity => identity.verificationToken),
+        };
+    }
+    validateConfig(config) {
+        if (!config.configuration) {
+            throw new Error("SES Identities configuration is required");
+        }
+        if (!config.configuration.domains && !config.configuration.emails) {
+            throw new Error("At least one domain or email identity must be specified");
+        }
+    }
+}
+exports.SesIdentitiesFactory = SesIdentitiesFactory;

package/dist/src/factories/simpleNotificationFactory.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SimpleNotificationFactory = void 0;
+const resourceFactory_1 = require("./resourceFactory");
+const comprehensiveNotificationFactory_1 = require("./comprehensiveNotificationFactory");
+class SimpleNotificationFactory extends resourceFactory_1.ResourceFactory {
+    comprehensiveFactory = new comprehensiveNotificationFactory_1.ComprehensiveNotificationFactory();
+    validateConfig(config) {
+        if (!config.configuration.name) {
+            throw new Error("Notification name is required");
+        }
+        const hasAnyChannel = config.configuration.email ||
+            config.configuration.slack ||
+            config.configuration.webhookUrl ||
+            config.configuration.lambdaArn ||
+            config.configuration.phoneNumber;
+        if (!hasAnyChannel) {
+            throw new Error("At least one notification channel (email, slack, webhook, lambda, or sms) must be configured");
+        }
+        if (config.configuration.slack && (!config.configuration.slack.workspaceId || !config.configuration.slack.channelId)) {
+            throw new Error("Slack workspaceId and channelId are required when Slack is configured");
+        }
+    }
+    async createResource(config, provider) {
+        const channels = [];
+        if (config.configuration.email) {
+            channels.push({
+                type: "email",
+                enabled: true,
+                name: "email",
+                configuration: {
+                    email: config.configuration.email
+                },
+                tags: config.configuration.tags
+            });
+        }
+        if (config.configuration.slack) {
+            channels.push({
+                type: "slack",
+                enabled: true,
+                name: config.configuration.slack.channelName || "slack",
+                configuration: {
+                    slack: {
+                        workspaceId: config.configuration.slack.workspaceId,
+                        channelId: config.configuration.slack.channelId,
+                        loggingLevel: "ERROR"
+                    }
+                },
+                tags: config.configuration.tags
+            });
+        }
+        if (config.configuration.webhookUrl) {
+            channels.push({
+                type: "webhook",
+                enabled: true,
+                name: "webhook",
+                configuration: {
+                    webhook: {
+                        url: config.configuration.webhookUrl
+                    }
+                },
+                tags: config.configuration.tags
+            });
+        }
+        if (config.configuration.lambdaArn) {
+            channels.push({
+                type: "lambda",
+                enabled: true,
+                name: "lambda",
+                configuration: {
+                    lambda: {
+                        functionArn: config.configuration.lambdaArn
+                    }
+                },
+                tags: config.configuration.tags
+            });
+        }
+        if (config.configuration.phoneNumber) {
+            channels.push({
+                type: "sms",
+                enabled: true,
+                name: "sms",
+                configuration: {
+                    sms: {
+                        phoneNumber: config.configuration.phoneNumber
+                    }
+                },
+                tags: config.configuration.tags
+            });
+        }
+        const comprehensiveConfig = {
+            id: config.id,
+            configuration: {
+                name: config.configuration.name,
+                displayName: config.configuration.displayName,
+                description: config.configuration.description,
+                channels,
+                chatbotRole: config.configuration.slack ? {
+                    enabled: config.configuration.enableChatbotRole ?? true,
+                    name: `${config.configuration.name}-chatbot-role`
+                } : { enabled: false },
+                tags: config.configuration.tags
+            },
+            inputs: config.inputs
+        };
+        return await this.comprehensiveFactory.createResource(comprehensiveConfig, provider);
+    }
+    getOutputs(resource) {
+        return this.comprehensiveFactory.getOutputs(resource);
+    }
+}
+exports.SimpleNotificationFactory = SimpleNotificationFactory;