sst 2.11.1 → 2.11.3

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/node/event-bus/index.d.ts

@@ -1,3 +1,28 @@
 export interface EventBusResources {
 }
 export declare const EventBus: EventBusResources;
+import { EventBridgeEvent } from "aws-lambda";
+import { ZodAny, ZodObject, ZodRawShape, z } from "zod";
+export declare function createEventBuilder<Bus extends keyof typeof EventBus, MetadataShape extends ZodRawShape | undefined, MetadataFunction extends () => any>(props: {
+    bus: Bus;
+    metadata?: MetadataShape;
+    metadataFn?: MetadataFunction;
+}): <Type extends string, Shape extends ZodRawShape, Properties = z.objectOutputType<Shape, ZodAny, "strip">>(type: Type, properties: Shape) => {
+    publish: undefined extends MetadataShape ? (properties: Properties) => Promise<void> : (properties: Properties, metadata: z.infer<ZodObject<Exclude<MetadataShape, undefined>, "strip", ZodAny>>) => Promise<void>;
+    type: Type;
+    shape: {
+        metadata: Parameters<undefined extends MetadataShape ? (properties: Properties) => Promise<void> : (properties: Properties, metadata: z.infer<ZodObject<Exclude<MetadataShape, undefined>, "strip", ZodAny>>) => Promise<void>>[1];
+        properties: Properties;
+        metadataFn: ReturnType<MetadataFunction>;
+    };
+};
+export type inferEvent<T extends {
+    shape: ZodObject<any>;
+}> = z.infer<T["shape"]>;
+export declare function EventHandler<Event extends {
+    shape: {
+        properties: any;
+        metadata: any;
+        metadataFn: any;
+    };
+}>(_events: Event, cb: (properties: Event["shape"]["properties"], metadata: undefined extends Event["shape"]["metadata"] ? Event["shape"]["metadataFn"] : Event["shape"]["metadata"]) => Promise<void>): (event: EventBridgeEvent<string, any>) => Promise<void>;

package/node/event-bus/index.js

@@ -1,3 +1,53 @@
 import { createProxy } from "../util/index.js";
 export const EventBus = 
 /* @__PURE__ */ createProxy("EventBus");
+import { EventBridgeClient, PutEventsCommand, } from "@aws-sdk/client-eventbridge";
+import { z } from "zod";
+const client = new EventBridgeClient({});
+export function createEventBuilder(props) {
+    return function createEvent(type, properties) {
+        const propertiesSchema = z.object(properties);
+        const metadataSchema = props.metadata
+            ? z.object(props.metadata)
+            : undefined;
+        const publish = async (properties, metadata) => {
+            console.log("publishing", type, properties);
+            await client.send(new PutEventsCommand({
+                Entries: [
+                    {
+                        // @ts-expect-error
+                        EventBusName: EventBus[props.bus].busName,
+                        Source: "console",
+                        Detail: JSON.stringify({
+                            properties: propertiesSchema.parse(properties),
+                            metadata: (() => {
+                                if (metadataSchema) {
+                                    return metadataSchema.parse(metadata);
+                                }
+                                if (props.metadataFn) {
+                                    return props.metadataFn();
+                                }
+                            })(),
+                        }),
+                        DetailType: type,
+                    },
+                ],
+            }));
+        };
+        return {
+            publish: publish,
+            type,
+            shape: {
+                metadata: {},
+                properties: {},
+                metadataFn: {},
+            },
+        };
+    };
+}
+export function EventHandler(_events, cb) {
+    return async (event) => {
+        console.log("received", event);
+        await cb(event.detail.properties, event.detail.metadata);
+    };
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "sideEffects": false,
   "name": "sst",
-  "version": "2.11.1",
+  "version": "2.11.3",
   "bin": {
     "sst": "cli/sst.js"
   },
@@ -32,6 +32,7 @@
     "@aws-cdk/cloudformation-diff": "2.79.1",
     "@aws-cdk/cx-api": "2.79.1",
     "@aws-sdk/client-cloudformation": "^3.279.0",
+    "@aws-sdk/client-eventbridge": "^3.342.0",
     "@aws-sdk/client-iam": "^3.279.0",
     "@aws-sdk/client-iot": "^3.279.0",
     "@aws-sdk/client-iot-data-plane": "^3.279.0",
@@ -87,12 +88,14 @@
     "undici": "^5.12.0",
     "uuid": "^9.0.0",
     "ws": "^8.11.0",
-    "yargs": "^17.6.2"
+    "yargs": "^17.6.2",
+    "zod": "^3.21.4"
   },
   "devDependencies": {
     "@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",