sst 3.0.0 → 3.0.1-2

package/constructs/EventBus.js

@@ -1,440 +0,0 @@
-import { Construct } from "constructs";
-import * as lambda from "aws-cdk-lib/aws-lambda";
-import * as sqs from "aws-cdk-lib/aws-sqs";
-import * as events from "aws-cdk-lib/aws-events";
-import { LambdaFunction as LambdaFunctionTarget, SqsQueue as SqsQueueTarget, CloudWatchLogGroup as LogGroupTarget, } from "aws-cdk-lib/aws-events-targets";
-import { Queue } from "./Queue.js";
-import { getFunctionRef, isCDKConstruct } from "./Construct.js";
-import { Function as Fn, } from "./Function.js";
-import { SqsEventSource } from "aws-cdk-lib/aws-lambda-event-sources";
-import { SqsDestination } from "aws-cdk-lib/aws-lambda-destinations";
-import url from "url";
-import path from "path";
-import { Effect, PolicyStatement } from "aws-cdk-lib/aws-iam";
-import { Duration } from "aws-cdk-lib/core";
-import { Stack } from "./Stack.js";
-const __dirname = path.dirname(url.fileURLToPath(import.meta.url));
-/////////////////////
-// Construct
-/////////////////////
-/**
- * The `EventBus` construct is a higher level CDK construct that makes it easy to create an EventBridge Event Bus.
- *
- * @example
- *
- * ```js
- * import { EventBus } from "sst/constructs";
- *
- * new EventBus(stack, "Bus", {
- *   rules: {
- *     myRule: {
- *       pattern: { source: ["myevent"] },
- *       targets: {
- *         myTarget1: "src/function1.handler",
- *         myTarget2: "src/function2.handler"
- *       },
- *     },
- *   },
- * });
- * ```
- */
-export class EventBus extends Construct {
-    id;
-    cdk;
-    rulesData = {};
-    targetsData = {};
-    bindingForAllTargets = [];
-    permissionsAttachedForAllTargets = [];
-    props;
-    constructor(scope, id, props) {
-        super(scope, props?.cdk?.id || id);
-        this.id = id;
-        this.props = props || {};
-        this.cdk = {};
-        this.createEventBus();
-        this.addRules(this, props?.rules || {});
-    }
-    /**
-     * The ARN of the internally created `EventBus` instance.
-     */
-    get eventBusArn() {
-        return this.cdk.eventBus.eventBusArn;
-    }
-    /**
-     * The name of the internally created `EventBus` instance.
-     */
-    get eventBusName() {
-        return this.cdk.eventBus.eventBusName;
-    }
-    /**
-     * Get a rule
-     *
-     * @example
-     * ```js
-     * bus.getRule("myRule");
-     * ```
-     */
-    getRule(key) {
-        return this.rulesData[key];
-    }
-    /**
-     * Add rules after the EventBus has been created.
-     *
-     * @example
-     * ```js
-     * bus.addRules(stack, {
-     *   myRule2: {
-     *     pattern: { source: ["myevent"] },
-     *       targets: {
-     *         myTarget3: "src/function3.handler"
-     *         myTarget4: "src/function4.handler"
-     *       },
-     *   },
-     * });
-     * ```
-     */
-    addRules(scope, rules) {
-        Object.entries(rules).forEach(([ruleKey, rule]) => this.addRule(scope, ruleKey, rule));
-    }
-    /**
-     * Add targets to existing rules.
-     *
-     * @example
-     * ```js
-     * bus.addRules(stack, "myRule", {
-     *   myTarget1: "src/function1.handler"
-     *   myTarget2: "src/function2.handler"
-     * });
-     * ```
-     */
-    addTargets(scope, ruleKey, targets) {
-        // Get rule
-        const eventsRule = this.getRule(ruleKey);
-        if (!eventsRule) {
-            throw new Error(`Cannot find the rule "${ruleKey}" in the "${this.node.id}" EventBus.`);
-        }
-        // Add targets
-        Object.entries(targets).forEach(([targetName, target]) => this.addTarget(scope, ruleKey, eventsRule, targetName, target));
-    }
-    /**
-     * Binds the given list of resources to all event targets in this EventBus.
-     *
-     * @example
-     * ```js
-     * bus.bind([STRIPE_KEY, bucket]);
-     * ```
-     */
-    bind(constructs) {
-        Object.values(this.targetsData).forEach((rule) => Object.values(rule)
-            .filter((target) => target instanceof Fn)
-            .forEach((target) => target.bind(constructs)));
-        this.bindingForAllTargets.push(...constructs);
-    }
-    /**
-     * Binds the given list of resources to a specific event bus rule target
-     *
-     * @example
-     * ```js
-     * const bus = new EventBus(stack, "Bus", {
-     *   rules: {
-     *     myRule: {
-     *       pattern: { source: ["myevent"] },
-     *       targets: {
-     *         myTarget1: "src/function1.handler"
-     *         myTarget2: "src/function2.handler"
-     *       },
-     *     },
-     *   },
-     * });
-     *
-     * bus.bindToTarget("myRule", 0, [STRIPE_KEY, bucket]);
-     * ```
-     */
-    bindToTarget(ruleKey, targetName, constructs) {
-        const rule = this.targetsData[ruleKey];
-        if (!rule) {
-            throw new Error(`Cannot find the rule "${ruleKey}" in the "${this.node.id}" EventBus.`);
-        }
-        const target = rule[targetName];
-        if (!(target instanceof Fn)) {
-            throw new Error(`Cannot bind to the "${this.node.id}" EventBus target because it's not a Lambda function`);
-        }
-        target.bind(constructs);
-    }
-    /**
-     * Add permissions to all event targets in this EventBus.
-     *
-     * @example
-     * ```js
-     * bus.attachPermissions(["s3"]);
-     * ```
-     */
-    attachPermissions(permissions) {
-        Object.values(this.targetsData).forEach((rule) => Object.values(rule)
-            .filter((target) => target instanceof Fn)
-            .forEach((target) => target.attachPermissions(permissions)));
-        this.permissionsAttachedForAllTargets.push(permissions);
-    }
-    /**
-     * Add permissions to a specific event bus rule target
-     *
-     * @example
-     * ```js
-     * const bus = new EventBus(stack, "Bus", {
-     *   rules: {
-     *     myRule: {
-     *       pattern: { source: ["myevent"] },
-     *       targets: {
-     *         myTarget1: "src/function1.handler"
-     *         myTarget2: "src/function2.handler"
-     *       },
-     *     },
-     *   },
-     * });
-     *
-     * bus.attachPermissionsToTarget("myRule", 0, ["s3"]);
-     * ```
-     */
-    attachPermissionsToTarget(ruleKey, targetName, permissions) {
-        const rule = this.targetsData[ruleKey];
-        if (!rule) {
-            throw new Error(`Cannot find the rule "${ruleKey}" in the "${this.node.id}" EventBus.`);
-        }
-        const target = rule[targetName];
-        if (!(target instanceof Fn)) {
-            throw new Error(`Cannot attach permissions to the "${this.node.id}" EventBus target because it's not a Lambda function`);
-        }
-        target.attachPermissions(permissions);
-    }
-    getConstructMetadata() {
-        return {
-            type: "EventBus",
-            data: {
-                eventBusName: this.cdk.eventBus.eventBusName,
-                rules: Object.entries(this.targetsData).map(([ruleName, rule]) => ({
-                    key: ruleName,
-                    targets: Object.values(rule).map(getFunctionRef).filter(Boolean),
-                    targetNames: Object.keys(rule),
-                })),
-            },
-        };
-    }
-    /** @internal */
-    getFunctionBinding() {
-        return {
-            clientPackage: "event-bus",
-            variables: {
-                eventBusName: {
-                    type: "plain",
-                    value: this.eventBusName,
-                },
-            },
-            permissions: {
-                "events:*": [this.eventBusArn],
-            },
-        };
-    }
-    retrierQueue;
-    retrierFn;
-    getRetrier() {
-        const app = this.node.root;
-        if (this.retrierFn && this.retrierQueue) {
-            return { fn: this.retrierFn, queue: this.retrierQueue };
-        }
-        this.retrierQueue = new sqs.Queue(this, `RetrierQueue`, {
-            queueName: app.logicalPrefixedName(this.node.id + "Retrier"),
-        });
-        this.retrierFn = new lambda.Function(this, `RetrierFunction`, {
-            functionName: app.logicalPrefixedName(this.node.id + "Retrier"),
-            runtime: lambda.Runtime.NODEJS_16_X,
-            timeout: Duration.seconds(30),
-            handler: "index.handler",
-            code: lambda.Code.fromAsset(path.join(__dirname, "../support/event-bus-retrier")),
-            environment: {
-                RETRIER_QUEUE_URL: this.retrierQueue.queueUrl,
-            },
-        });
-        this.retrierFn.addToRolePolicy(new PolicyStatement({
-            effect: Effect.ALLOW,
-            actions: ["lambda:InvokeFunction", "lambda:GetFunction"],
-            resources: [
-                `arn:${Stack.of(this).partition}:lambda:${app.region}:${app.account}:function:*`,
-            ],
-            conditions: {
-                StringEquals: {
-                    "aws:ResourceTag/sst:app": app.name,
-                    "aws:ResourceTag/sst:stage": app.stage,
-                },
-            },
-        }));
-        this.retrierFn.addEventSource(new SqsEventSource(this.retrierQueue));
-        this.retrierQueue.grantSendMessages(this.retrierFn);
-        return { fn: this.retrierFn, queue: this.retrierQueue };
-    }
-    createEventBus() {
-        const app = this.node.root;
-        const id = this.node.id;
-        const { cdk } = this.props;
-        if (isCDKConstruct(cdk?.eventBus)) {
-            this.cdk.eventBus = cdk?.eventBus;
-        }
-        else {
-            const ebProps = (cdk?.eventBus || {});
-            this.cdk.eventBus = new events.EventBus(this, "EventBus", {
-                // Note: Set default eventBusName only if eventSourceName is not configured.
-                //       This is because both cannot be configured at the same time.
-                eventBusName: ebProps.eventSourceName
-                    ? undefined
-                    : app.logicalPrefixedName(id),
-                ...ebProps,
-            });
-        }
-    }
-    addRule(scope, ruleKey, rule) {
-        // Validate input
-        // @ts-expect-error "eventBus" is not a prop
-        if (rule.cdk?.rule.eventBus) {
-            throw new Error(`Cannot configure the "rule.cdk.rule.eventBus" in the "${this.node.id}" EventBus`);
-        }
-        // Validate rule not redefined
-        if (this.targetsData[ruleKey]) {
-            throw new Error(`A rule already exists for "${ruleKey}"`);
-        }
-        // Create Rule
-        const root = this.node.root;
-        const eventsRule = new events.Rule(scope, ruleKey, {
-            ruleName: root.logicalPrefixedName(ruleKey),
-            ...rule.cdk?.rule,
-            eventPattern: rule.pattern
-                ? { ...rule.pattern }
-                : rule.cdk?.rule?.eventPattern,
-            eventBus: this.cdk.eventBus,
-            targets: [],
-        });
-        this.rulesData[ruleKey] = eventsRule;
-        // Create Targets
-        this.addTargets(scope, ruleKey, rule.targets || {});
-    }
-    addTarget(scope, ruleKey, eventsRule, targetName, target) {
-        this.targetsData[ruleKey] = this.targetsData[ruleKey] || {};
-        // Validate rule not redefined
-        if (this.targetsData[ruleKey][targetName]) {
-            throw new Error(`A target with name "${targetName}" already exists in rule "${ruleKey}"`);
-        }
-        if (target instanceof Queue || target.queue) {
-            target = target;
-            this.addQueueTarget(scope, ruleKey, eventsRule, targetName, target);
-        }
-        else if (target.cdk?.logGroup) {
-            target = target;
-            this.addLogGroupTarget(scope, ruleKey, eventsRule, targetName, target);
-        }
-        else if (target.cdk?.function) {
-            target = target;
-            this.addCdkFunctionTarget(scope, ruleKey, eventsRule, targetName, target);
-        }
-        else {
-            target = target;
-            this.addFunctionTarget(scope, ruleKey, eventsRule, targetName, target);
-        }
-    }
-    addQueueTarget(scope, ruleKey, eventsRule, targetName, target) {
-        // Parse target props
-        let targetProps;
-        let queue;
-        if (target instanceof Queue) {
-            target = target;
-            queue = target;
-        }
-        else {
-            target = target;
-            targetProps = target.cdk?.target;
-            queue = target.queue;
-        }
-        this.targetsData[ruleKey][targetName] = queue;
-        // Create target
-        eventsRule.addTarget(new SqsQueueTarget(queue.cdk.queue, targetProps));
-    }
-    addLogGroupTarget(scope, ruleKey, eventsRule, targetName, target) {
-        const { logGroup, target: targetProps } = target.cdk;
-        this.targetsData[ruleKey][targetName] = logGroup;
-        eventsRule.addTarget(new LogGroupTarget(logGroup, targetProps));
-    }
-    addCdkFunctionTarget(scope, ruleKey, eventsRule, targetName, target) {
-        // Parse target props
-        const targetProps = target.cdk.target;
-        const fn = target.cdk.function;
-        this.targetsData[ruleKey][targetName] = fn;
-        // Create target
-        eventsRule.addTarget(new LambdaFunctionTarget(fn, targetProps));
-    }
-    subs = new Map();
-    subscribe(scope_or_type, type_or_target, target_or_props, maybe_props) {
-        let [scope, type, target, props] = (() => {
-            if (scope_or_type instanceof Construct) {
-                return [
-                    scope_or_type,
-                    type_or_target,
-                    target_or_props,
-                    maybe_props,
-                ];
-            }
-            return [this, scope_or_type, type_or_target, maybe_props];
-        })();
-        type = Array.isArray(type) ? type : [type];
-        const joined = type.length > 1 ? "multi" : type.join("_");
-        const count = (this.subs.get(joined) || 0) + 1;
-        this.subs.set(joined, count);
-        const name = `${joined.replaceAll(/[^a-zA-Z_]/g, "_")}_${count}`;
-        const retries = props?.retries || this.props.defaults?.retries;
-        const fn = (() => {
-            if (retries) {
-                const retrier = this.getRetrier();
-                const fn = Fn.fromDefinition(scope, name, target, {
-                    onFailure: new SqsDestination(retrier.queue),
-                });
-                fn.addEnvironment("SST_RETRIES", retries.toString());
-                return fn;
-            }
-            return Fn.fromDefinition(scope, name, target);
-        })();
-        this.addRule(scope, name + "_rule", {
-            pattern: {
-                detailType: type,
-            },
-            targets: {
-                [name + "_target"]: {
-                    type: "function",
-                    function: fn,
-                    retries: props?.retries,
-                },
-            },
-        });
-        return this;
-    }
-    addFunctionTarget(scope, ruleKey, eventsRule, targetName, target) {
-        // Parse target props
-        let targetProps;
-        let functionDefinition;
-        let retries = this.props.defaults?.retries;
-        if (target.function) {
-            target = target;
-            targetProps = target.cdk?.target;
-            functionDefinition = target.function;
-            if (target.retries)
-                retries = target.retries;
-        }
-        else {
-            target = target;
-            functionDefinition = target;
-        }
-        // Create function
-        const fn = Fn.fromDefinition(scope, `Target_${this.node.id}_${ruleKey}_${targetName}`, functionDefinition, this.props.defaults?.function, `The "defaults.function" cannot be applied if an instance of a Function construct is passed in. Make sure to define all the targets using FunctionProps, so the EventBus construct can apply the "defaults.function" to them.`);
-        this.targetsData[ruleKey][targetName] = fn;
-        // Create target
-        eventsRule.addTarget(new LambdaFunctionTarget(fn, targetProps));
-        // Attach existing permissions
-        this.permissionsAttachedForAllTargets.forEach((permissions) => fn.attachPermissions(permissions));
-        fn.bind(this.bindingForAllTargets);
-    }
-}