terruvim-core-test 0.0.1

package/dist/src/factories/codePipelineNotificationFactory.js

@@ -0,0 +1,193 @@
+"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.CodePipelineNotificationFactory = void 0;
+const aws = __importStar(require("@pulumi/aws"));
+const pulumi = __importStar(require("@pulumi/pulumi"));
+const resourceFactory_1 = require("./resourceFactory");
+class CodePipelineNotificationFactory extends resourceFactory_1.ResourceFactory {
+    validateConfig(config) {
+        if (!config.configuration.pipelineName) {
+            throw new Error("Pipeline name is required");
+        }
+        if (!config.configuration.snsTopicArn) {
+            throw new Error("SNS topic ARN is required");
+        }
+    }
+    async createResource(config, provider) {
+        const { configuration } = config;
+        const eventTypes = configuration.eventTypes || [
+            "PIPELINE_EXECUTION_STARTED",
+            "PIPELINE_EXECUTION_SUCCEEDED",
+            "PIPELINE_EXECUTION_FAILED"
+        ];
+        const eventPattern = configuration.customEventPattern || {
+            source: ["aws.codepipeline"],
+            "detail-type": this.createDetailTypePattern(eventTypes),
+            detail: {
+                pipeline: [configuration.pipelineName],
+                ...(configuration.stageNames && { stage: configuration.stageNames })
+            }
+        };
+        const ruleName = `${config.id}-events`.substring(0, 64);
+        const eventRule = new aws.cloudwatch.EventRule(ruleName, {
+            name: ruleName,
+            description: `Monitor CodePipeline events for ${configuration.pipelineName}`,
+            eventPattern: JSON.stringify(eventPattern),
+            state: "ENABLED",
+            tags: configuration.tags
+        }, provider ? { provider } : undefined);
+        let snsTopicPolicy;
+        const topicArn = configuration.snsTopicArn;
+        snsTopicPolicy = new aws.sns.TopicPolicy(`${config.id}-sns-policy`, {
+            arn: topicArn,
+            policy: pulumi.interpolate `{
+          "Version": "2012-10-17",
+          "Statement": [
+            {
+              "Sid": "AllowCloudWatchEventsToPublish",
+              "Effect": "Allow",
+              "Principal": {
+                "Service": "events.amazonaws.com"
+              },
+              "Action": "sns:Publish",
+              "Resource": "${topicArn}",
+              "Condition": {
+                "StringEquals": {
+                  "aws:SourceAccount": "${aws.getCallerIdentity().then(id => id.accountId)}"
+                }
+              }
+            }
+          ]
+        }`
+        }, provider ? { provider } : undefined);
+        const eventTarget = new aws.cloudwatch.EventTarget(`${config.id}-sns-target`, {
+            rule: eventRule.name,
+            targetId: `${config.id}-sns-target`,
+            arn: topicArn,
+            inputTransformer: configuration.detailType === "Full" ? {
+                inputPaths: {
+                    pipeline: "$.detail.pipeline",
+                    state: "$.detail.state",
+                    stage: "$.detail.stage",
+                    action: "$.detail.action-name",
+                    region: "$.region",
+                    time: "$.time",
+                    account: "$.account"
+                },
+                inputTemplate: JSON.stringify({
+                    version: "1.0",
+                    source: "aws.codepipeline",
+                    account: "<account>",
+                    region: "<region>",
+                    time: "<time>",
+                    pipeline: "<pipeline>",
+                    state: "<state>",
+                    stage: "<stage>",
+                    action: "<action>",
+                    message: "CodePipeline <pipeline> <state> in stage <stage>",
+                    severity: this.getSeverityFromState("<state>"),
+                    eventType: "PIPELINE_EVENT",
+                    tags: {
+                        service: "CodePipeline",
+                        pipeline: "<pipeline>",
+                        environment: configuration.tags?.Environment || "unknown"
+                    }
+                })
+            } : {
+                inputPaths: {
+                    pipeline: "$.detail.pipeline",
+                    state: "$.detail.state"
+                },
+                inputTemplate: `"CodePipeline <pipeline> <state>"`
+            }
+        }, provider ? { provider } : undefined);
+        return {
+            eventRule,
+            eventTarget,
+            snsTopicPolicy
+        };
+    }
+    getOutputs(resource) {
+        return {
+            eventRuleArn: resource.eventRule.arn,
+            eventRuleName: resource.eventRule.name,
+            eventTargetId: resource.eventTarget.targetId
+        };
+    }
+    createDetailTypePattern(eventTypes) {
+        const detailTypes = [];
+        for (const eventType of eventTypes) {
+            switch (eventType) {
+                case "PIPELINE_EXECUTION_STARTED":
+                case "PIPELINE_EXECUTION_SUCCEEDED":
+                case "PIPELINE_EXECUTION_FAILED":
+                case "PIPELINE_EXECUTION_CANCELED":
+                case "PIPELINE_EXECUTION_SUPERSEDED":
+                    detailTypes.push("CodePipeline Pipeline Execution State Change");
+                    break;
+                case "STAGE_EXECUTION_STARTED":
+                case "STAGE_EXECUTION_SUCCEEDED":
+                case "STAGE_EXECUTION_FAILED":
+                case "STAGE_EXECUTION_CANCELED":
+                    detailTypes.push("CodePipeline Stage Execution State Change");
+                    break;
+                case "ACTION_EXECUTION_STARTED":
+                case "ACTION_EXECUTION_SUCCEEDED":
+                case "ACTION_EXECUTION_FAILED":
+                case "ACTION_EXECUTION_CANCELED":
+                    detailTypes.push("CodePipeline Action Execution State Change");
+                    break;
+            }
+        }
+        return [...new Set(detailTypes)];
+    }
+    getSeverityFromState(state) {
+        switch (state.toUpperCase()) {
+            case "FAILED":
+                return "HIGH";
+            case "CANCELED":
+            case "SUPERSEDED":
+                return "MEDIUM";
+            case "STARTED":
+                return "INFO";
+            case "SUCCEEDED":
+                return "LOW";
+            default:
+                return "INFO";
+        }
+    }
+}
+exports.CodePipelineNotificationFactory = CodePipelineNotificationFactory;

package/dist/src/factories/codePipelineNotificationRulesFactory.js

@@ -0,0 +1,117 @@
+"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.CodePipelineNotificationRulesFactory = void 0;
+const aws = __importStar(require("@pulumi/aws"));
+const pulumi = __importStar(require("@pulumi/pulumi"));
+const resourceFactory_1 = require("./resourceFactory");
+class CodePipelineNotificationRulesFactory extends resourceFactory_1.ResourceFactory {
+    validateConfig(config) {
+        if (!config.configuration.pipelineArn) {
+            throw new Error("Pipeline ARN is required for notification rules");
+        }
+        if (!config.configuration.snsTopicArn) {
+            throw new Error("SNS Topic ARN is required for notification rules");
+        }
+    }
+    async createResource(config, provider) {
+        const { configuration } = config;
+        const eventTypeIds = configuration.eventTypeIds || [
+            "codepipeline-pipeline-pipeline-execution-started",
+            "codepipeline-pipeline-pipeline-execution-succeeded",
+            "codepipeline-pipeline-pipeline-execution-failed",
+            "codepipeline-pipeline-manual-approval-needed"
+        ];
+        const ruleName = configuration.name || `${config.id}-notification-rule`;
+        const cleanTags = {};
+        if (configuration.tags) {
+            for (const [key, value] of Object.entries(configuration.tags)) {
+                if (!value.includes('${')) {
+                    cleanTags[key] = value;
+                }
+            }
+        }
+        const current = aws.getCallerIdentity({});
+        const snsTopicPolicy = new aws.sns.TopicPolicy(`${config.id}-codestar-sns-policy`, {
+            arn: configuration.snsTopicArn,
+            policy: pulumi.all([current, configuration.snsTopicArn]).apply(([account, topicArn]) => JSON.stringify({
+                Version: "2012-10-17",
+                Statement: [
+                    {
+                        Sid: "AllowCodeStarNotificationsToPublish",
+                        Effect: "Allow",
+                        Principal: {
+                            Service: "codestar-notifications.amazonaws.com"
+                        },
+                        Action: "sns:Publish",
+                        Resource: topicArn,
+                        Condition: {
+                            StringEquals: {
+                                "aws:SourceAccount": account.accountId
+                            }
+                        }
+                    }
+                ]
+            }))
+        }, provider ? { provider } : undefined);
+        const notificationRule = new aws.codestarnotifications.NotificationRule(`${config.id}-notification-rule`, {
+            name: ruleName,
+            resource: configuration.pipelineArn,
+            detailType: configuration.detailType || "FULL",
+            eventTypeIds: eventTypeIds,
+            targets: [
+                {
+                    address: configuration.snsTopicArn,
+                    type: "SNS"
+                }
+            ],
+            tags: Object.keys(cleanTags).length > 0 ? cleanTags : undefined
+        }, {
+            provider,
+            dependsOn: [snsTopicPolicy]
+        });
+        return {
+            notificationRule,
+            snsTopicPolicy
+        };
+    }
+    getOutputs(resource) {
+        return {
+            notificationRuleArn: resource.notificationRule.arn,
+            snsTopicPolicyId: resource.snsTopicPolicy?.id
+        };
+    }
+}
+exports.CodePipelineNotificationRulesFactory = CodePipelineNotificationRulesFactory;

package/dist/src/factories/codeStarConnectionFactory.js

@@ -0,0 +1,56 @@
+"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.CodeStarConnectionFactory = void 0;
+const pulumi = __importStar(require("@pulumi/pulumi"));
+const resourceFactory_1 = require("./resourceFactory");
+const createGithubCodeStarConnection_1 = require("./createGithubCodeStarConnection");
+class CodeStarConnectionFactory extends resourceFactory_1.ResourceFactory {
+    async createResource(config) {
+        const { id, configuration } = config;
+        return (0, createGithubCodeStarConnection_1.createGithubCodeStarConnection)(id, configuration.providerType || "GitHub", configuration.tags);
+    }
+    getOutputs(resource) {
+        return {
+            arn: pulumi.output(resource.arn),
+            name: pulumi.output(resource.name),
+        };
+    }
+    validateConfig(config) {
+        if (!config.id)
+            throw new Error("Missing 'id' for CodeStar connection");
+    }
+}
+exports.CodeStarConnectionFactory = CodeStarConnectionFactory;

package/dist/src/factories/collectSecretKeys.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectSecretKeys = collectSecretKeys;
+function collectSecretKeys(env) {
+    const secretsById = {};
+    for (const envVar of env) {
+        if (typeof envVar.value === "string" && envVar.value.startsWith("${secret:")) {
+            const match = envVar.value.match(/^\$\{secret:([^:}]+):([^}]+)\}$/);
+            if (match) {
+                const [_, secretId, key] = match;
+                if (!secretsById[secretId])
+                    secretsById[secretId] = [];
+                secretsById[secretId].push(key);
+            }
+        }
+    }
+    return secretsById;
+}

package/dist/src/factories/comprehensiveNotificationFactory.js

@@ -0,0 +1,250 @@
+"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.ComprehensiveNotificationFactory = void 0;
+const aws = __importStar(require("@pulumi/aws"));
+const resourceFactory_1 = require("./resourceFactory");
+const createAwsSnsTopic_1 = require("./createAwsSnsTopic");
+const createAwsSnsSubscription_1 = require("./createAwsSnsSubscription");
+const createSlackChannelConfiguration_1 = require("./createSlackChannelConfiguration");
+class ComprehensiveNotificationFactory extends resourceFactory_1.ResourceFactory {
+    validateConfig(config) {
+        if (!config.configuration.name) {
+            throw new Error("Notification topic name is required");
+        }
+        if (!config.configuration.channels || config.configuration.channels.length === 0) {
+            throw new Error("At least one notification channel must be configured");
+        }
+        for (const channel of config.configuration.channels) {
+            if (!channel.type || !channel.name) {
+                throw new Error(`Channel type and name are required for channel: ${channel.name || 'unnamed'}`);
+            }
+            switch (channel.type) {
+                case "email":
+                    if (channel.enabled && !channel.configuration.email) {
+                        throw new Error(`Email address is required for email channel: ${channel.name}`);
+                    }
+                    break;
+                case "slack":
+                    if (channel.enabled && (!channel.configuration.slack?.workspaceId || !channel.configuration.slack?.channelId)) {
+                        throw new Error(`Slack workspace ID and channel ID are required for Slack channel: ${channel.name}`);
+                    }
+                    break;
+                case "lambda":
+                    if (channel.enabled && !channel.configuration.lambda?.functionArn) {
+                        throw new Error(`Lambda function ARN is required for Lambda channel: ${channel.name}`);
+                    }
+                    break;
+                case "webhook":
+                    if (channel.enabled && !channel.configuration.webhook?.url) {
+                        throw new Error(`Webhook URL is required for webhook channel: ${channel.name}`);
+                    }
+                    break;
+                case "sms":
+                    if (channel.enabled && !channel.configuration.sms?.phoneNumber) {
+                        throw new Error(`Phone number is required for SMS channel: ${channel.name}`);
+                    }
+                    break;
+            }
+        }
+    }
+    async createResource(config, provider) {
+        const { configuration } = config;
+        const topicConfig = {
+            name: configuration.name,
+            displayName: configuration.displayName,
+            fifoTopic: configuration.fifoTopic,
+            contentBasedDeduplication: configuration.contentBasedDeduplication,
+            kmsMasterKeyId: configuration.kmsMasterKeyId,
+        };
+        const topic = (0, createAwsSnsTopic_1.createAwsSnsTopic)(`${config.id}-topic`, topicConfig, provider);
+        const subscriptions = {};
+        const chatbotConfigurations = {};
+        let chatbotRole;
+        let chatbotRolePolicyAttachments;
+        const slackChannels = configuration.channels.filter(c => c.type === "slack" && c.enabled);
+        if (slackChannels.length > 0 && configuration.chatbotRole?.enabled) {
+            chatbotRole = new aws.iam.Role(`${config.id}-chatbot-role`, {
+                name: configuration.chatbotRole.name || `${configuration.name}-chatbot-role`,
+                assumeRolePolicy: JSON.stringify({
+                    Version: "2012-10-17",
+                    Statement: [
+                        {
+                            Effect: "Allow",
+                            Principal: {
+                                Service: "chatbot.amazonaws.com"
+                            },
+                            Action: "sts:AssumeRole"
+                        }
+                    ]
+                }),
+            }, provider ? { provider } : undefined);
+            const defaultPolicies = [
+                "arn:aws:iam::aws:policy/CloudWatchReadOnlyAccess",
+                "arn:aws:iam::aws:policy/ReadOnlyAccess"
+            ];
+            const policiesToAttach = configuration.chatbotRole.policies || defaultPolicies;
+            chatbotRolePolicyAttachments = policiesToAttach.map((policyArn, index) => new aws.iam.RolePolicyAttachment(`${config.id}-chatbot-policy-${index}`, {
+                role: chatbotRole.name,
+                policyArn: policyArn
+            }, provider ? { provider } : undefined));
+            if (configuration.chatbotRole.customPolicyStatements) {
+                const customPolicy = new aws.iam.RolePolicy(`${config.id}-chatbot-custom-policy`, {
+                    role: chatbotRole.id,
+                    policy: JSON.stringify({
+                        Version: "2012-10-17",
+                        Statement: configuration.chatbotRole.customPolicyStatements
+                    })
+                }, provider ? { provider } : undefined);
+            }
+        }
+        for (const channel of configuration.channels) {
+            if (!channel.enabled)
+                continue;
+            const channelId = `${config.id}-${channel.name}`;
+            switch (channel.type) {
+                case "email":
+                    if (channel.configuration.email) {
+                        const subscription = await (0, createAwsSnsSubscription_1.createAwsSnsSubscription)({
+                            id: channelId,
+                            configuration: {
+                                topicArn: topic.arn,
+                                protocol: "email",
+                                endpoint: channel.configuration.email,
+                                filterPolicy: channel.filterPolicy,
+                                rawMessageDelivery: channel.rawMessageDelivery,
+                                deliveryPolicy: channel.deliveryPolicy
+                            }
+                        }, provider);
+                        subscriptions[channel.name] = subscription.subscription;
+                    }
+                    break;
+                case "slack":
+                    if (channel.configuration.slack) {
+                        if (chatbotRole) {
+                            const slackConfig = (0, createSlackChannelConfiguration_1.createSlackChannelConfiguration)(channelId, {
+                                name: `${configuration.name}-${channel.name}`,
+                                slackWorkspaceId: channel.configuration.slack.workspaceId,
+                                slackChannelId: channel.configuration.slack.channelId,
+                                snsTopicArns: [topic.arn],
+                                iamRoleArn: chatbotRole.arn,
+                                loggingLevel: channel.configuration.slack.loggingLevel || "ERROR",
+                                guardrailPolicies: channel.configuration.slack.guardrailPolicies,
+                                userRoleRequired: channel.configuration.slack.userRoleRequired,
+                                tags: channel.tags
+                            }, provider);
+                            chatbotConfigurations[channel.name] = slackConfig;
+                        }
+                        else {
+                            console.log(`Slack channel ${channel.name} configured but ChatBot role is disabled - skipping ChatBot integration`);
+                        }
+                    }
+                    break;
+                case "lambda":
+                    if (channel.configuration.lambda) {
+                        const subscription = await (0, createAwsSnsSubscription_1.createAwsSnsSubscription)({
+                            id: channelId,
+                            configuration: {
+                                topicArn: topic.arn,
+                                protocol: "lambda",
+                                endpoint: channel.configuration.lambda.functionArn,
+                                filterPolicy: channel.configuration.lambda.filterPolicy || channel.filterPolicy,
+                                rawMessageDelivery: channel.configuration.lambda.rawMessageDelivery ?? channel.rawMessageDelivery,
+                                deliveryPolicy: channel.deliveryPolicy
+                            }
+                        }, provider);
+                        subscriptions[channel.name] = subscription.subscription;
+                    }
+                    break;
+                case "webhook":
+                    if (channel.configuration.webhook) {
+                        const subscription = await (0, createAwsSnsSubscription_1.createAwsSnsSubscription)({
+                            id: channelId,
+                            configuration: {
+                                topicArn: topic.arn,
+                                protocol: "https",
+                                endpoint: channel.configuration.webhook.url,
+                                filterPolicy: channel.configuration.webhook.filterPolicy || channel.filterPolicy,
+                                rawMessageDelivery: channel.configuration.webhook.rawMessageDelivery ?? channel.rawMessageDelivery,
+                                deliveryPolicy: channel.deliveryPolicy
+                            }
+                        }, provider);
+                        subscriptions[channel.name] = subscription.subscription;
+                    }
+                    break;
+                case "sms":
+                    if (channel.configuration.sms) {
+                        const subscription = await (0, createAwsSnsSubscription_1.createAwsSnsSubscription)({
+                            id: channelId,
+                            configuration: {
+                                topicArn: topic.arn,
+                                protocol: "sms",
+                                endpoint: channel.configuration.sms.phoneNumber,
+                                filterPolicy: channel.filterPolicy,
+                                deliveryPolicy: channel.deliveryPolicy
+                            }
+                        }, provider);
+                        subscriptions[channel.name] = subscription.subscription;
+                    }
+                    break;
+            }
+        }
+        return {
+            topic,
+            subscriptions,
+            chatbotConfigurations,
+            chatbotRole,
+            chatbotRolePolicyAttachments
+        };
+    }
+    getOutputs(resource) {
+        const subscriptionArns = {};
+        Object.keys(resource.subscriptions).forEach(key => {
+            subscriptionArns[key] = resource.subscriptions[key].arn;
+        });
+        const chatbotConfigArns = {};
+        Object.keys(resource.chatbotConfigurations).forEach(key => {
+            chatbotConfigArns[key] = resource.chatbotConfigurations[key].configurationName;
+        });
+        return {
+            topicArn: resource.topic.arn,
+            topicName: resource.topic.name,
+            subscriptionArns,
+            chatbotConfigurations: chatbotConfigArns,
+            chatbotRoleArn: resource.chatbotRole?.arn
+        };
+    }
+}
+exports.ComprehensiveNotificationFactory = ComprehensiveNotificationFactory;

package/dist/src/factories/costAndUsageReportFactory.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CostAndUsageReportFactory = void 0;
+const resourceFactory_1 = require("./resourceFactory");
+const createCostAndUsageReport_1 = require("./createCostAndUsageReport");
+class CostAndUsageReportFactory extends resourceFactory_1.ResourceFactory {
+    getConfig(config) {
+        if (config && config.configuration) {
+            return {
+                id: config.id,
+                args: config.configuration
+            };
+        }
+        return config;
+    }
+    async createResource(config) {
+        const cfg = this.getConfig(config);
+        return (0, createCostAndUsageReport_1.createCostAndUsageReport)(cfg.id, cfg.args);
+    }
+    getOutputs(resource) {
+        return {
+            reportName: resource.reportName,
+            arn: resource.arn,
+        };
+    }
+    validateConfig(config) {
+        const cfg = this.getConfig(config);
+        if (!cfg.id || !cfg.args)
+            throw new Error("CostAndUsageReportConfig requires id and args");
+    }
+}
+exports.CostAndUsageReportFactory = CostAndUsageReportFactory;