sst 2.11.1 → 2.11.2

package/constructs/EventBus.d.ts

@@ -32,6 +32,10 @@ export interface EventBusFunctionTargetProps {
      * The function to trigger
      */
     function?: FunctionDefinition;
+    /**
+     * Number of retries
+     */
+    retries?: number;
     cdk?: {
         function?: lambda.IFunction;
         target?: LambdaFunctionTargetProps;
@@ -212,6 +216,17 @@ export interface EventBusProps {
          * ```
          */
         function?: FunctionProps;
+        /**
+         * Enable retries with exponential backoff for all lambda function targets in this eventbus
+         *
+         * @example
+         * ```js
+         * new EventBus(stack, "Bus", {
+         *   retries: 20
+         * });
+         * ```
+         */
+        retries?: number;
     };
     /**
      * The rules for the eventbus
@@ -409,11 +424,18 @@ export declare class EventBus extends Construct implements SSTConstruct {
     };
     /** @internal */
     getFunctionBinding(): FunctionBindingProps;
+    private retrierQueue;
+    private retrierFn;
+    private getRetrier;
     private createEventBus;
     private addRule;
     private addTarget;
     private addQueueTarget;
     private addLogGroupTarget;
     private addCdkFunctionTarget;
+    private subs;
+    subscribe(type: string, target: FunctionDefinition, props?: {
+        retries?: number;
+    }): this;
     private addFunctionTarget;
 }

package/constructs/EventBus.js

@@ -1,9 +1,14 @@
 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 path from "path";
 /////////////////////
 // Construct
 /////////////////////
@@ -224,6 +229,25 @@ export class EventBus extends Construct {
             },
         };
     }
+    retrierQueue;
+    retrierFn;
+    getRetrier() {
+        if (this.retrierFn && this.retrierQueue) {
+            return { fn: this.retrierFn, queue: this.retrierQueue };
+        }
+        this.retrierQueue = new sqs.Queue(this, `RetrierQueue`);
+        this.retrierFn = new lambda.Function(this, `RetrierFunction`, {
+            runtime: lambda.Runtime.NODEJS_14_X,
+            handler: "index.handler",
+            code: lambda.Code.fromAsset(path.join(__dirname, "../support/event-bus-retrier")),
+            environment: {
+                RETRIER_QUEUE_URL: this.retrierQueue.queueUrl,
+            },
+        });
+        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;
@@ -321,14 +345,36 @@ export class EventBus extends Construct {
         // Create target
         eventsRule.addTarget(new LambdaFunctionTarget(fn, targetProps));
     }
+    subs = new Map();
+    subscribe(type, target, props) {
+        const count = this.subs.get(type) || 0 + 1;
+        this.subs.set(type, count);
+        const name = `${type.replaceAll(/[^a-zA-Z_]/g, "_")}_${count}`;
+        const fn = Fn.fromDefinition(this, name, target);
+        this.addRule(this, 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;
+            retries = target.retries;
         }
         else {
             target = target;
@@ -339,6 +385,15 @@ export class EventBus extends Construct {
         this.targetsData[ruleKey][targetName] = fn;
         // Create target
         eventsRule.addTarget(new LambdaFunctionTarget(fn, targetProps));
+        // Configure retrier
+        if (retries) {
+            const retrier = this.getRetrier();
+            retrier.fn.addEnvironment(`RETRIER_${retrier.fn.functionName}`, retries.toString());
+            fn.grantInvoke(retrier.fn);
+            fn.configureAsyncInvoke({
+                onFailure: new SqsDestination(retrier.queue),
+            });
+        }
         // Attach existing permissions
         this.permissionsAttachedForAllTargets.forEach((permissions) => fn.attachPermissions(permissions));
         fn.bind(this.bindingForAllTargets);

package/package.json

@@ -1,7 +1,7 @@
 {
   "sideEffects": false,
   "name": "sst",
-  "version": "2.11.1",
+  "version": "2.11.2",
   "bin": {
     "sst": "cli/sst.js"
   },
@@ -93,6 +93,7 @@
     "@aws-sdk/client-api-gateway": "^3.208.0",
     "@aws-sdk/client-cloudfront": "^3.279.0",
     "@aws-sdk/client-codebuild": "^3.279.0",
+    "@aws-sdk/client-sqs": "^3.341.0",
     "@aws-sdk/types": "^3.272.0",
     "@graphql-tools/merge": "^8.3.16",
     "@sls-next/lambda-at-edge": "^3.7.0",