sst 2.11.0 → 2.11.2

package/cli/commands/bind.d.ts

@@ -12,6 +12,10 @@ export declare const bind: (program: Program) => import("yargs").Argv<{
     role: string | undefined;
 } & {
     future: boolean | undefined;
+} & {
+    site: boolean | undefined;
+} & {
+    script: boolean | undefined;
 } & {
     command: (string | number)[] | undefined;
 }>;

package/cli/commands/bind.js

@@ -1,12 +1,23 @@
 import path from "path";
 import { VisibleError } from "../../error.js";
-class OutdatedMetadataError extends Error {
+class MetadataNotFoundError extends Error {
+}
+class MetadataOutdatedError extends Error {
 }
 export const bind = (program) => program
     .command(["bind <command..>", "env <command..>"], "Bind your app's resources to a command", (yargs) => yargs
+    .option("site", {
+    type: "boolean",
+    describe: "Run in site mode",
+})
+    .option("script", {
+    type: "boolean",
+    describe: "Run in script mode",
+})
     .array("command")
-    .example(`sst bind "vitest run"`, "Bind your resources to your tests")
-    .example(`sst bind "tsx scripts/myscript.ts"`, "Bind your resources to a script"), async (args) => {
+    .example(`sst bind vitest run`, "Bind resources to your tests")
+    .example(`sst bind next dev`, "Bind resources to your site")
+    .example(`sst bind --script next build`, "Bind resources to your site before deployment"), async (args) => {
     const { spawn } = await import("child_process");
     const kill = await import("tree-kill");
     const { useProject } = await import("../../project.js");
@@ -22,6 +33,7 @@ export const bind = (program) => program
     const project = useProject();
     const command = args.command?.join(" ");
     const isSite = await isRunningInSite();
+    const mode = args.site ? "site" : args.script ? "script" : "auto";
     let p;
     let timer;
     let siteConfigCache;
@@ -30,22 +42,12 @@ export const bind = (program) => program
         throw new VisibleError(`Command is required, e.g. sst bind ${isSite ? "next dev" : "vitest run"}`);
     }
     // Bind script
-    if (!isSite) {
+    if (args.script || (!isSite && !args.site)) {
         Logger.debug("Running in script mode.");
         return await bindScript();
     }
     // Bind site
-    try {
-        await bindSite("init");
-    }
-    catch (e) {
-        // Bind script (fallback)
-        if (e instanceof OutdatedMetadataError) {
-            Colors.line(Colors.warning("Warning: This was deployed with an old version of SST. Run `sst dev` or `sst deploy` to update."));
-            return await bindScript();
-        }
-        throw e;
-    }
+    await bindSite("init");
     bus.subscribe("stacks.metadata.updated", () => bindSite("metadata_updated"));
     bus.subscribe("stacks.metadata.deleted", () => bindSite("metadata_updated"));
     bus.subscribe("config.secret.updated", (payload) => {
@@ -93,7 +95,25 @@ export const bind = (program) => program
     }
     async function bindSite(reason) {
         // Get metadata
-        const siteMetadata = await getSiteMetadataUntilAvailable();
+        let siteMetadata;
+        try {
+            siteMetadata = await getSiteMetadata();
+        }
+        catch (e) {
+            // unhandled error
+            if (!(e instanceof MetadataOutdatedError) &&
+                !(e instanceof MetadataNotFoundError)) {
+                throw e;
+            }
+            // ignore error if previously failed to fetch metadata
+            if (reason !== "init")
+                return;
+            // run in script mode
+            Colors.line(Colors.warning(e instanceof MetadataOutdatedError
+                ? "Warning: This was deployed with an old version of SST. Run `sst dev` or `sst deploy` to update."
+                : "Warning: The site has not been deployed. Some resources might not be available."));
+            return await bindScript();
+        }
         const siteConfig = await parseSiteMetadata(siteMetadata);
         // Handle rebind due to metadata updated
         if (reason === "metadata_updated") {
@@ -103,57 +123,26 @@ export const bind = (program) => program
         }
         siteConfigCache = siteConfig;
         // Assume function's role credentials
-        if (siteConfig.role) {
-            const credentials = await assumeSsrRole(siteConfig.role);
-            if (credentials) {
-                // refresh crecentials 1 minute before expiration
-                const expireAt = credentials.Expiration.getTime() - 60000;
-                clearTimeout(timer);
-                timer = setTimeout(() => {
-                    Colors.line(`\n`, `Your AWS session is about to expire. Creating a new session and restarting \`${command}\`...`);
-                    bindSite("iam_expired");
-                }, expireAt - Date.now());
-                await runCommand({
-                    ...siteConfig.envs,
-                    AWS_ACCESS_KEY_ID: credentials.AccessKeyId,
-                    AWS_SECRET_ACCESS_KEY: credentials.SecretAccessKey,
-                    AWS_SESSION_TOKEN: credentials.SessionToken,
-                });
-                return;
-            }
-        }
         // Fallback to use local IAM credentials
+        const credentials = (siteConfig.role &&
+            (await getLiveIamCredentials(siteConfig.role))) ||
+            (await getLocalIamCredentials());
         await runCommand({
             ...siteConfig.envs,
-            ...(await localIamCredentials()),
+            ...credentials,
         });
     }
     async function bindScript() {
         const { Config } = await import("../../config.js");
         await runCommand({
             ...(await Config.env()),
-            ...(await localIamCredentials()),
+            ...(await getLocalIamCredentials()),
         });
     }
-    async function getSiteMetadataUntilAvailable() {
-        const { createSpinner } = await import("../spinner.js");
-        const spinner = createSpinner({});
-        while (true) {
-            const data = await getSiteMetadata();
-            // Handle site metadata not found
-            if (!data) {
-                spinner.start("Make sure `sst dev` is running...");
-                await new Promise((resolve) => setTimeout(resolve, 1000));
-                continue;
-            }
-            spinner.isSpinning && spinner.stop().clear();
-            return data;
-        }
-    }
     async function getSiteMetadata() {
         const { metadata } = await import("../../stacks/metadata.js");
         const metadataData = await metadata();
-        return Object.values(metadataData)
+        const data = Object.values(metadataData)
             .flat()
             .filter((c) => [
             "StaticSite",
@@ -170,10 +159,14 @@ export const bind = (program) => program
             if (!c.data.path ||
                 (isSsr && !c.data.server) ||
                 (!isSsr && !c.data.environment)) {
-                throw new OutdatedMetadataError();
+                throw new MetadataOutdatedError();
             }
             return (path.resolve(project.paths.root, c.data.path) === process.cwd());
         });
+        if (!data) {
+            throw new MetadataNotFoundError();
+        }
+        return data;
     }
     async function parseSiteMetadata(metadata) {
         const { LambdaClient, GetFunctionCommand } = await import("@aws-sdk/client-lambda");
@@ -194,40 +187,24 @@ export const bind = (program) => program
             secrets: metadata.data.secrets,
         };
     }
-    async function assumeSsrRole(roleArn) {
-        const { STSClient, AssumeRoleCommand } = await import("@aws-sdk/client-sts");
-        const { useAWSClient } = await import("../../credentials.js");
-        const sts = useAWSClient(STSClient);
-        const assumeRole = async (duration) => {
-            const { Credentials: credentials } = await sts.send(new AssumeRoleCommand({
-                RoleArn: roleArn,
-                RoleSessionName: "dev-session",
-                DurationSeconds: duration,
-            }));
-            return credentials;
+    async function getLiveIamCredentials(roleArn) {
+        const credentials = await assumeSsrRole(roleArn);
+        if (!credentials)
+            return;
+        // refresh crecentials 1 minute before expiration
+        const expireAt = credentials.Expiration.getTime() - 60000;
+        clearTimeout(timer);
+        timer = setTimeout(() => {
+            Colors.line(`\n`, `Your AWS session is about to expire. Creating a new session and restarting \`${command}\`...`);
+            bindSite("iam_expired");
+        }, expireAt - Date.now());
+        return {
+            AWS_ACCESS_KEY_ID: credentials.AccessKeyId,
+            AWS_SECRET_ACCESS_KEY: credentials.SecretAccessKey,
+            AWS_SESSION_TOKEN: credentials.SessionToken,
         };
-        // Assue role with max duration first. This can fail if chaining roles, or if
-        // the role has a max duration set. If it fails, assume role with 1 hour duration.
-        let err;
-        try {
-            return await assumeRole(43200);
-        }
-        catch (e) {
-            err = e;
-        }
-        if (err.name === "ValidationError" &&
-            err.message.startsWith("The requested DurationSeconds exceeds")) {
-            try {
-                return await assumeRole(3600);
-            }
-            catch (e) {
-                err = e;
-            }
-        }
-        Colors.line("Using local IAM credentials since `sst dev` is not running.");
-        Logger.debug(`Failed to assume ${roleArn}.`, err);
     }
-    async function localIamCredentials() {
+    async function getLocalIamCredentials() {
         const { useAWSCredentials } = await import("../../credentials.js");
         const credentials = await useAWSCredentials();
         return {
@@ -269,5 +246,38 @@ export const bind = (program) => program
         return (Object.keys(envs1).length === Object.keys(envs2).length &&
             Object.keys(envs1).every((key) => envs1[key] === envs2[key]));
     }
+    async function assumeSsrRole(roleArn) {
+        const { STSClient, AssumeRoleCommand } = await import("@aws-sdk/client-sts");
+        const { useAWSClient } = await import("../../credentials.js");
+        const sts = useAWSClient(STSClient);
+        const assumeRole = async (duration) => {
+            const { Credentials: credentials } = await sts.send(new AssumeRoleCommand({
+                RoleArn: roleArn,
+                RoleSessionName: "dev-session",
+                DurationSeconds: duration,
+            }));
+            return credentials;
+        };
+        // Assue role with max duration first. This can fail if chaining roles, or if
+        // the role has a max duration set. If it fails, assume role with 1 hour duration.
+        let err;
+        try {
+            return await assumeRole(43200);
+        }
+        catch (e) {
+            err = e;
+        }
+        if (err.name === "ValidationError" &&
+            err.message.startsWith("The requested DurationSeconds exceeds")) {
+            try {
+                return await assumeRole(3600);
+            }
+            catch (e) {
+                err = e;
+            }
+        }
+        Colors.line("Using local IAM credentials since `sst dev` is not running.");
+        Logger.debug(`Failed to assume ${roleArn}.`, err);
+    }
 })
     .strict(false);

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/constructs/NextjsSite.js

@@ -29,7 +29,7 @@ const __dirname = url.fileURLToPath(new URL(".", import.meta.url));
 export class NextjsSite extends SsrSite {
     constructor(scope, id, props) {
         super(scope, id, {
-            buildCommand: "npx --yes open-next@1.3.x build",
+            buildCommand: "npx --yes open-next@^1.3 build",
             ...props,
         });
         this.createWarmer();

package/package.json

@@ -1,7 +1,7 @@
 {
   "sideEffects": false,
   "name": "sst",
-  "version": "2.11.0",
+  "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",