sst 2.1.20 → 2.1.22

package/cli/commands/dev.d.ts

@@ -13,3 +13,11 @@ export declare const dev: (program: Program) => import("yargs").Argv<{
 } & {
     "increase-timeout": boolean | undefined;
 }>;
+declare module "../../bus.js" {
+    interface Events {
+        "cli.dev": {
+            app: string;
+            stage: string;
+        };
+    }
+}

package/cli/commands/dev.js

@@ -29,6 +29,7 @@ export const dev = (program) => program.command(["dev", "start"], "Work on your
     const { useRDSWarmer } = await import("./plugins/warmer.js");
     const { useProject } = await import("../../project.js");
     const { useMetadata } = await import("../../stacks/metadata.js");
+    const { useIOT } = await import("../../iot.js");
     const { clear } = await import("../terminal.js");
     if (args._[0] === "start") {
         console.log(yellow(`Warning: ${bold(`sst start`)} has been renamed to ${bold(`sst dev`)}`));
@@ -223,6 +224,27 @@ export const dev = (program) => program.command(["dev", "start"], "Work on your
         });
         await build();
     });
+    const useDisconnector = Context.memo(async () => {
+        const bus = useBus();
+        const project = useProject();
+        const iot = await useIOT();
+        bus.subscribe("cli.dev", async (evt) => {
+            const topic = `${iot.prefix}/events`;
+            iot.publish(topic, "cli.dev", evt.properties);
+        });
+        bus.publish("cli.dev", {
+            stage: project.config.stage,
+            app: project.config.name,
+        });
+        bus.subscribe("cli.dev", async (evt) => {
+            if (evt.properties.stage !== project.config.stage)
+                return;
+            if (evt.properties.app !== project.config.name)
+                return;
+            Colors.line(Colors.danger(`➜ `), "Another sst dev session has been started up for this stage. Exiting");
+            process.exit(0);
+        });
+    });
     const [appMetadata] = await Promise.all([
         useAppMetadata(),
         useLocalServer({
@@ -240,6 +262,7 @@ export const dev = (program) => program.command(["dev", "start"], "Work on your
     clear();
     await printHeader({ console: true, hint: "ready!" });
     await Promise.all([
+        useDisconnector(),
         useRuntimeWorkers(),
         useIOTBridge(),
         useRuntimeServer(),

package/constructs/AstroSite.js

@@ -32,7 +32,7 @@ export class AstroSite extends SsrSite {
         super.validateBuildOutput();
     }
     createFunctionForRegional() {
-        const { runtime, timeout, memorySize, permissions, environment, bind, cdk, } = this.props;
+        const { runtime, timeout, memorySize, permissions, environment, nodejs, bind, cdk, } = this.props;
         const fn = new Function(this, `ServerFunction`, {
             description: "Server handler",
             handler: path.join(this.props.path, "dist", "server", "entry.handler"),
@@ -42,6 +42,7 @@ export class AstroSite extends SsrSite {
             timeout,
             nodejs: {
                 format: "esm",
+                ...nodejs,
             },
             bind,
             environment,
@@ -53,7 +54,7 @@ export class AstroSite extends SsrSite {
         return fn;
     }
     createFunctionForEdge() {
-        const { runtime, timeout, memorySize, bind, permissions, environment } = this.props;
+        const { runtime, timeout, memorySize, bind, permissions, environment, nodejs, } = this.props;
         return new EdgeFunction(this, `Server`, {
             scopeOverride: this,
             handler: path.join(this.props.path, "dist", "server", "entry.handler"),
@@ -63,7 +64,10 @@ export class AstroSite extends SsrSite {
             bind,
             environment,
             permissions,
-            format: "esm",
+            nodejs: {
+                format: "esm",
+                ...nodejs,
+            },
         });
     }
 }

package/constructs/EdgeFunction.d.ts

@@ -1,8 +1,8 @@
-import { BuildOptions } from "esbuild";
 import { Construct, IConstruct } from "constructs";
 import { Role } from "aws-cdk-lib/aws-iam";
 import { IVersion } from "aws-cdk-lib/aws-lambda";
 import { SSTConstruct } from "./Construct.js";
+import { NodeJSProps } from "./Function.js";
 import { Size } from "./util/size.js";
 import { Duration } from "./util/duration.js";
 import { Permissions } from "./util/permission.js";
@@ -15,13 +15,15 @@ export interface EdgeFunctionProps {
     permissions?: Permissions;
     environment?: Record<string, string>;
     bind?: SSTConstruct[];
-    esbuild?: BuildOptions;
-    format: "cjs" | "esm";
+    nodejs?: NodeJSProps;
     scopeOverride?: IConstruct;
 }
 export declare class EdgeFunction extends Construct {
     role: Role;
     functionArn: string;
+    private function;
+    private assetReplacer;
+    private assetReplacerPolicy;
     private scope;
     private versionId;
     private bindingEnvs;
@@ -29,14 +31,15 @@ export declare class EdgeFunction extends Construct {
     constructor(scope: Construct, id: string, props: EdgeFunctionProps);
     get currentVersion(): IVersion;
     attachPermissions(permissions: Permissions): void;
-    private buildBundle;
-    private updateBundleWithEnvWrapper;
+    private buildAssetFromHandler;
+    private buildAssetFromBundle;
     private bind;
-    private createCodeAsset;
     private createCodeReplacer;
+    private updateCodeReplacer;
     private createRole;
     private createSingletonBucketInUsEast1;
     private createFunctionInUsEast1;
+    private updateFunctionInUsEast1;
     private createVersionInUsEast1;
     private getHandlerExtension;
     private trimFromStart;

package/constructs/EdgeFunction.js

@@ -2,14 +2,16 @@ import fs from "fs";
 import url from "url";
 import path from "path";
 import crypto from "crypto";
-import { buildSync } from "esbuild";
 import { Construct } from "constructs";
 import { Effect, Role, Policy, PolicyStatement, CompositePrincipal, ServicePrincipal, ManagedPolicy, } from "aws-cdk-lib/aws-iam";
 import { Version, Code, Runtime, Function as CdkFunction, } from "aws-cdk-lib/aws-lambda";
 import { Asset } from "aws-cdk-lib/aws-s3-assets";
 import { Lazy, Duration as CdkDuration, CustomResource, } from "aws-cdk-lib";
 import { useProject } from "../project.js";
+import { useRuntimeHandlers } from "../runtime/handlers.js";
 import { Stack } from "./Stack.js";
+import { useFunctions } from "./Function.js";
+import { useDeferredTasks } from "./deferred_task.js";
 import { bindEnvironment, bindPermissions, getReferencedSecrets, } from "./util/functionBinding.js";
 import { toCdkSize } from "./util/size.js";
 import { toCdkDuration } from "./util/duration.js";
@@ -21,6 +23,9 @@ const __dirname = path.dirname(url.fileURLToPath(import.meta.url));
 export class EdgeFunction extends Construct {
     role;
     functionArn;
+    function;
+    assetReplacer;
+    assetReplacerPolicy;
     scope;
     versionId;
     bindingEnvs;
@@ -36,29 +41,46 @@ export class EdgeFunction extends Construct {
         this.scope = props.scopeOverride || this;
         this.props = {
             ...props,
-            bundle: props.bundle || "placeholder",
             environment: props.environment || {},
             permissions: props.permissions || [],
         };
-        // Build bundle if not prebuilt
-        const { bundle, handler, handlerFilename } = props.bundle
-            ? this.updateBundleWithEnvWrapper()
-            : this.buildBundle();
-        this.props.bundle = bundle;
-        this.props.handler = handler;
+        const { assetBucket, assetKey, handlerFilename } = (props.bundle
+            ? // Case: bundle is pre-built
+                () => {
+                    const { asset, handlerFilename } = this.buildAssetFromBundle(props.bundle, props.handler);
+                    return {
+                        assetBucket: asset.s3BucketName,
+                        assetKey: asset.s3ObjectKey,
+                        handlerFilename,
+                    };
+                }
+            : // Case: bundle is NOT pre-built
+                () => {
+                    this.buildAssetFromHandler((asset, handlerFilename) => {
+                        this.updateCodeReplacer(asset.s3BucketName, asset.s3ObjectKey, handlerFilename);
+                        this.updateFunctionInUsEast1(asset.s3BucketName, asset.s3ObjectKey);
+                    });
+                    return {
+                        assetBucket: "placeholder",
+                        assetKey: "placeholder",
+                        handlerFilename: "placeholder",
+                    };
+                })();
         // Bind first b/e function's environment variables cannot be added after
         this.bindingEnvs = {};
         this.bind(props.bind || []);
-        const asset = this.createCodeAsset();
-        const assetReplacer = this.createCodeReplacer(asset, handlerFilename);
+        const { assetReplacer, assetReplacerPolicy } = this.createCodeReplacer(assetBucket, assetKey, handlerFilename);
         this.role = this.createRole();
-        const bucket = this.createSingletonBucketInUsEast1();
-        const { fn, fnArn } = this.createFunctionInUsEast1(asset, bucket);
+        const lambdaBucket = this.createSingletonBucketInUsEast1();
+        const { fn, fnArn } = this.createFunctionInUsEast1(assetBucket, assetKey, lambdaBucket);
         const { versionId } = this.createVersionInUsEast1(fn, fnArn);
         // Deploy after the code is updated
         fn.node.addDependency(assetReplacer);
+        this.function = fn;
         this.functionArn = fnArn;
         this.versionId = versionId;
+        this.assetReplacer = assetReplacer;
+        this.assetReplacerPolicy = assetReplacerPolicy;
     }
     get currentVersion() {
         return Version.fromVersionArn(this, `${this.node.id}FunctionVersion`, `${this.functionArn}:${this.versionId}`);
@@ -66,60 +88,35 @@ export class EdgeFunction extends Construct {
     attachPermissions(permissions) {
         attachPermissionsToRole(this.role, permissions);
     }
-    buildBundle() {
-        const { handler, format, esbuild, runtime } = this.props;
-        const isESM = format === "esm";
-        const { dir: inputPath, base: inputHandler, name: inputFilename, ext: inputHandlerFunction, } = path.parse(handler);
-        const inputFileExt = this.getHandlerExtension(path.join(inputPath, inputFilename));
-        // Create a directory that we will use to create the bundled version
-        // of the "core server build" along with our custom Lamba server handler.
-        const outputPath = path.resolve(path.join(useProject().paths.artifacts, `EdgeFunction-${this.node.id}-${this.node.addr}`));
-        const outputHandler = inputHandler;
-        const outputFilename = inputFilename;
-        const outputFileExt = isESM ? ".mjs" : ".cjs";
-        const { external, ...override } = esbuild || {};
-        const result = buildSync({
-            entryPoints: [handler.replace(inputHandlerFunction, inputFileExt)],
-            platform: "node",
-            external: [
-                ...(isESM || runtime === "nodejs18.x" ? [] : ["aws-sdk"]),
-                ...(external || []),
-            ],
-            metafile: true,
-            bundle: true,
-            ...(isESM
-                ? {
-                    format: "esm",
-                    target: "esnext",
-                    mainFields: ["module", "main"],
-                    banner: {
-                        js: [
-                            `import { createRequire as topLevelCreateRequire } from 'module';`,
-                            `const require = topLevelCreateRequire(import.meta.url);`,
-                            `import { fileURLToPath as topLevelFileUrlToPath } from "url"`,
-                            `const __dirname = topLevelFileUrlToPath(new URL(".", import.meta.url))`,
-                            `process.env = { ...process.env, ..."{{ _SST_FUNCTION_ENVIRONMENT_ }}" };`,
-                        ].join("\n"),
-                    },
-                }
-                : {
-                    format: "cjs",
-                    target: "node14",
-                }),
-            outfile: path.join(outputPath, outputFilename + outputFileExt),
-            ...override,
+    buildAssetFromHandler(onBundled) {
+        const { nodejs } = this.props;
+        useFunctions().add(this.node.addr, {
+            ...this.props,
+            nodejs: {
+                ...nodejs,
+                banner: [
+                    `process.env = { ...process.env, ..."{{ _SST_FUNCTION_ENVIRONMENT_ }}" };`,
+                    nodejs?.banner || "",
+                ].join("\n"),
+            },
+        });
+        useDeferredTasks().add(async () => {
+            // Build function
+            const bundle = await useRuntimeHandlers().build(this.node.addr, "deploy");
+            // create wrapper that calls the handler
+            if (bundle.type === "error")
+                throw new Error(`There was a problem bundling the SSR function for the "${this.scope.node.id}" Site.`);
+            const asset = new Asset(this.scope, `FunctionAsset`, {
+                path: bundle.out,
+            });
+            // Get handler filename
+            const isESM = (nodejs?.format || "esm") === "esm";
+            const parsed = path.parse(bundle.handler);
+            const handlerFilename = `${parsed.dir}/${parsed.name}${isESM ? ".mjs" : ".cjs"}`;
+            onBundled(asset, handlerFilename);
         });
-        if (result.errors.length > 0) {
-            result.errors.forEach((error) => console.error(error));
-            throw new Error(`There was a problem bundling the SSR function for the "${this.scope.node.id}" Site.`);
-        }
-        return {
-            bundle: outputPath,
-            handler: outputHandler,
-            handlerFilename: outputFilename + outputFileExt,
-        };
     }
-    updateBundleWithEnvWrapper() {
+    buildAssetFromBundle(bundle, handler) {
         // We expose an environment variable token which is used by the code
         // replacer to inject the environment variables assigned to the
         // EdgeFunction construct.
@@ -132,14 +129,17 @@ export class EdgeFunction extends Construct {
         // support runtime environment variables. A downside of this approach
         // is that environment variables cannot be toggled after deployment,
         // each change to one requires a redeployment.
-        const { bundle, handler } = this.props;
         const { dir: inputPath, name: inputFilename, ext: inputHandlerFunction, } = path.parse(handler);
         const inputFileExt = this.getHandlerExtension(path.join(bundle, inputPath, inputFilename));
         const handlerFilename = handler.replace(inputHandlerFunction, inputFileExt);
         const filePath = path.join(bundle, handlerFilename);
         const fileData = fs.readFileSync(filePath, "utf8");
         fs.writeFileSync(filePath, `process.env = { ...process.env, ..."{{ _SST_FUNCTION_ENVIRONMENT_ }}" };\n${fileData}`);
-        return { bundle, handler, handlerFilename };
+        // Create asset
+        const asset = new Asset(this.scope, `FunctionAsset`, {
+            path: bundle,
+        });
+        return { handlerFilename, asset };
     }
     bind(constructs) {
         const app = this.node.root;
@@ -168,13 +168,7 @@ export class EdgeFunction extends Construct {
             }
         });
     }
-    createCodeAsset() {
-        const { bundle } = this.props;
-        return new Asset(this.scope, `FunctionAsset`, {
-            path: bundle,
-        });
-    }
-    createCodeReplacer(asset, handlerFilename) {
+    createCodeReplacer(assetBucket, assetKey, handlerFilename) {
         const { environment } = this.props;
         const replacements = [
             {
@@ -200,7 +194,7 @@ export class EdgeFunction extends Construct {
                 new PolicyStatement({
                     effect: Effect.ALLOW,
                     actions: ["s3:GetObject", "s3:PutObject"],
-                    resources: [`arn:${stack.partition}:s3:::${asset.s3BucketName}/*`],
+                    resources: [`arn:${stack.partition}:s3:::${assetBucket}/*`],
                 }),
             ],
         });
@@ -209,13 +203,23 @@ export class EdgeFunction extends Construct {
             serviceToken: stack.customResourceHandler.functionArn,
             resourceType: "Custom::AssetReplacer",
             properties: {
-                bucket: asset.s3BucketName,
-                key: asset.s3ObjectKey,
+                bucket: assetBucket,
+                key: assetKey,
                 replacements,
             },
         });
         resource.node.addDependency(policy);
-        return resource;
+        return { assetReplacer: resource, assetReplacerPolicy: policy };
+    }
+    updateCodeReplacer(assetBucket, assetKey, handlerFilename) {
+        const stack = Stack.of(this);
+        const cfnReplacer = this.assetReplacer.node
+            .defaultChild;
+        cfnReplacer.addPropertyOverride("bucket", assetBucket);
+        cfnReplacer.addPropertyOverride("key", assetKey);
+        cfnReplacer.addPropertyOverride("replacements.0.files", handlerFilename);
+        const cfnPolicy = this.assetReplacerPolicy.node.defaultChild;
+        cfnPolicy.addPropertyOverride("PolicyDocument.Statement.0.Resource", `arn:${stack.partition}:s3:::${assetBucket}/*`);
     }
     createRole() {
         const { permissions } = this.props;
@@ -268,7 +272,7 @@ export class EdgeFunction extends Construct {
         });
         return resource;
     }
-    createFunctionInUsEast1(asset, bucket) {
+    createFunctionInUsEast1(assetBucket, assetKey, lambdaBucket) {
         const { handler, runtime, timeout, memorySize } = this.props;
         // Do not recreate if exist
         const providerId = "EdgeLambdaProvider";
@@ -301,13 +305,13 @@ export class EdgeFunction extends Construct {
             resourceType: "Custom::SSTEdgeLambda",
             properties: {
                 FunctionNamePrefix: `${Stack.of(this).stackName}-${resId}`,
-                FunctionBucket: bucket.getAttString("BucketName"),
+                FunctionBucket: lambdaBucket.getAttString("BucketName"),
                 FunctionParams: {
                     Description: `${this.node.id} handler`,
                     Handler: handler,
                     Code: {
-                        S3Bucket: asset.s3BucketName,
-                        S3Key: asset.s3ObjectKey,
+                        S3Bucket: assetBucket,
+                        S3Key: assetKey,
                     },
                     Runtime: runtime === "nodejs14.x"
                         ? Runtime.NODEJS_14_X.name
@@ -326,6 +330,13 @@ export class EdgeFunction extends Construct {
         });
         return { fn, fnArn: fn.getAttString("FunctionArn") };
     }
+    updateFunctionInUsEast1(assetBucket, assetKey) {
+        const cfnLambda = this.function.node.defaultChild;
+        cfnLambda.addPropertyOverride("FunctionParams.Code", {
+            S3Bucket: assetBucket,
+            S3Key: assetKey,
+        });
+    }
     createVersionInUsEast1(fn, fnArn) {
         // Do not recreate if exist
         const providerId = "EdgeLambdaVersionProvider";

package/constructs/NextjsSite.d.ts

@@ -1,9 +1,9 @@
 import { Construct } from "constructs";
-import * as lambda from "aws-cdk-lib/aws-lambda";
-import * as cloudfront from "aws-cdk-lib/aws-cloudfront";
+import { Function as CdkFunction } from "aws-cdk-lib/aws-lambda";
+import { Distribution, CachePolicy } from "aws-cdk-lib/aws-cloudfront";
 import { SsrSite, SsrSiteProps } from "./SsrSite.js";
 import { Size } from "./util/size.js";
-export interface NextjsSiteProps extends Omit<SsrSiteProps, "edge"> {
+export interface NextjsSiteProps extends Omit<SsrSiteProps, "edge" | "nodejs"> {
     imageOptimization?: {
         /**
          * The amount of memory in MB allocated for image optimization function.
@@ -41,10 +41,10 @@ export declare class NextjsSite extends SsrSite {
         clientBuildOutputDir: string;
         clientBuildVersionedSubDir: string;
     };
-    protected createFunctionForRegional(): lambda.Function;
+    protected createFunctionForRegional(): CdkFunction;
     private createImageOptimizationFunctionForRegional;
     private createMiddlewareEdgeFunctionForRegional;
-    protected createCloudFrontDistributionForRegional(): cloudfront.Distribution;
-    protected createCloudFrontServerCachePolicy(): cloudfront.CachePolicy;
+    protected createCloudFrontDistributionForRegional(): Distribution;
+    protected createCloudFrontServerCachePolicy(): CachePolicy;
     protected generateBuildId(): string;
 }

package/constructs/NextjsSite.js

@@ -2,10 +2,10 @@ import fs from "fs";
 import url from "url";
 import path from "path";
 import { Fn, Duration as CdkDuration, RemovalPolicy } from "aws-cdk-lib";
-import * as logs from "aws-cdk-lib/aws-logs";
-import * as lambda from "aws-cdk-lib/aws-lambda";
-import * as cloudfront from "aws-cdk-lib/aws-cloudfront";
-import * as origins from "aws-cdk-lib/aws-cloudfront-origins";
+import { RetentionDays } from "aws-cdk-lib/aws-logs";
+import { Function as CdkFunction, Code, Runtime, Architecture, FunctionUrlAuthType, } from "aws-cdk-lib/aws-lambda";
+import { Distribution, ViewerProtocolPolicy, AllowedMethods, LambdaEdgeEventType, CachedMethods, CachePolicy, CacheQueryStringBehavior, CacheCookieBehavior, CacheHeaderBehavior, } from "aws-cdk-lib/aws-cloudfront";
+import { S3Origin, HttpOrigin, OriginGroup, } from "aws-cdk-lib/aws-cloudfront-origins";
 import { SsrFunction } from "./SsrFunction.js";
 import { EdgeFunction } from "./EdgeFunction.js";
 import { SsrSite } from "./SsrSite.js";
@@ -55,22 +55,22 @@ export class NextjsSite extends SsrSite {
     }
     createImageOptimizationFunctionForRegional() {
         const { imageOptimization, path: sitePath } = this.props;
-        return new lambda.Function(this, `ImageFunction`, {
+        return new CdkFunction(this, `ImageFunction`, {
             description: "Image optimization handler for Next.js",
             handler: "index.handler",
             currentVersionOptions: {
                 removalPolicy: RemovalPolicy.DESTROY,
             },
-            logRetention: logs.RetentionDays.THREE_DAYS,
-            code: lambda.Code.fromAsset(path.join(sitePath, ".open-next/image-optimization-function")),
-            runtime: lambda.Runtime.NODEJS_18_X,
+            logRetention: RetentionDays.THREE_DAYS,
+            code: Code.fromAsset(path.join(sitePath, ".open-next/image-optimization-function")),
+            runtime: Runtime.NODEJS_18_X,
             memorySize: imageOptimization?.memorySize
                 ? typeof imageOptimization.memorySize === "string"
                     ? toCdkSize(imageOptimization.memorySize).toMebibytes()
                     : imageOptimization.memorySize
                 : 1536,
             timeout: CdkDuration.seconds(25),
-            architecture: lambda.Architecture.ARM_64,
+            architecture: Architecture.ARM_64,
             environment: {
                 BUCKET_NAME: this.cdk.bucket.bucketName,
             },
@@ -94,29 +94,31 @@ export class NextjsSite extends SsrSite {
                 memorySize: 128,
                 permissions,
                 environment,
-                format: "esm",
+                nodejs: {
+                    format: "esm",
+                },
             });
         }
     }
     createCloudFrontDistributionForRegional() {
         const { cdk } = this.props;
         const cfDistributionProps = cdk?.distribution || {};
-        const s3Origin = new origins.S3Origin(this.cdk.bucket);
+        const s3Origin = new S3Origin(this.cdk.bucket);
         // Create server behavior
         const middlewareFn = this.createMiddlewareEdgeFunctionForRegional();
         const serverFnUrl = this.serverLambdaForRegional.addFunctionUrl({
-            authType: lambda.FunctionUrlAuthType.NONE,
+            authType: FunctionUrlAuthType.NONE,
         });
         const serverBehavior = {
-            viewerProtocolPolicy: cloudfront.ViewerProtocolPolicy.REDIRECT_TO_HTTPS,
-            origin: new origins.HttpOrigin(Fn.parseDomainName(serverFnUrl.url)),
-            allowedMethods: cloudfront.AllowedMethods.ALLOW_ALL,
-            cachedMethods: cloudfront.CachedMethods.CACHE_GET_HEAD_OPTIONS,
+            viewerProtocolPolicy: ViewerProtocolPolicy.REDIRECT_TO_HTTPS,
+            origin: new HttpOrigin(Fn.parseDomainName(serverFnUrl.url)),
+            allowedMethods: AllowedMethods.ALLOW_ALL,
+            cachedMethods: CachedMethods.CACHE_GET_HEAD_OPTIONS,
             compress: true,
             cachePolicy: cdk?.serverCachePolicy ?? this.createCloudFrontServerCachePolicy(),
             edgeLambdas: middlewareFn && [
                 {
-                    eventType: cloudfront.LambdaEdgeEventType.VIEWER_REQUEST,
+                    eventType: LambdaEdgeEventType.VIEWER_REQUEST,
                     functionVersion: middlewareFn.currentVersion,
                 },
             ],
@@ -124,37 +126,37 @@ export class NextjsSite extends SsrSite {
         // Create image optimization behavior
         const imageFn = this.createImageOptimizationFunctionForRegional();
         const imageFnUrl = imageFn.addFunctionUrl({
-            authType: lambda.FunctionUrlAuthType.NONE,
+            authType: FunctionUrlAuthType.NONE,
         });
         const imageBehavior = {
-            viewerProtocolPolicy: cloudfront.ViewerProtocolPolicy.REDIRECT_TO_HTTPS,
-            origin: new origins.HttpOrigin(Fn.parseDomainName(imageFnUrl.url)),
-            allowedMethods: cloudfront.AllowedMethods.ALLOW_ALL,
-            cachedMethods: cloudfront.CachedMethods.CACHE_GET_HEAD_OPTIONS,
+            viewerProtocolPolicy: ViewerProtocolPolicy.REDIRECT_TO_HTTPS,
+            origin: new HttpOrigin(Fn.parseDomainName(imageFnUrl.url)),
+            allowedMethods: AllowedMethods.ALLOW_ALL,
+            cachedMethods: CachedMethods.CACHE_GET_HEAD_OPTIONS,
             compress: true,
             cachePolicy: serverBehavior.cachePolicy,
         };
         // Create statics behavior
         const staticFileBehaviour = {
             origin: s3Origin,
-            viewerProtocolPolicy: cloudfront.ViewerProtocolPolicy.REDIRECT_TO_HTTPS,
-            allowedMethods: cloudfront.AllowedMethods.ALLOW_GET_HEAD_OPTIONS,
-            cachedMethods: cloudfront.CachedMethods.CACHE_GET_HEAD_OPTIONS,
+            viewerProtocolPolicy: ViewerProtocolPolicy.REDIRECT_TO_HTTPS,
+            allowedMethods: AllowedMethods.ALLOW_GET_HEAD_OPTIONS,
+            cachedMethods: CachedMethods.CACHE_GET_HEAD_OPTIONS,
             compress: true,
-            cachePolicy: cloudfront.CachePolicy.CACHING_OPTIMIZED,
+            cachePolicy: CachePolicy.CACHING_OPTIMIZED,
         };
         // Create default behavior
         // default handler for requests that don't match any other path:
         //   - try lambda handler first first
         //   - if failed, fall back to S3
-        const fallbackOriginGroup = new origins.OriginGroup({
+        const fallbackOriginGroup = new OriginGroup({
             primaryOrigin: serverBehavior.origin,
             fallbackOrigin: s3Origin,
             fallbackStatusCodes: [404],
         });
         const defaultBehavior = {
             origin: fallbackOriginGroup,
-            viewerProtocolPolicy: cloudfront.ViewerProtocolPolicy.REDIRECT_TO_HTTPS,
+            viewerProtocolPolicy: ViewerProtocolPolicy.REDIRECT_TO_HTTPS,
             compress: true,
             cachePolicy: serverBehavior.cachePolicy,
             edgeLambdas: serverBehavior.edgeLambdas,
@@ -208,7 +210,7 @@ export class NextjsSite extends SsrSite {
          *    - Cache-Control: public, max-age=0, must-revalidate
          *    - x-vercel-cache: MISS
          */
-        return new cloudfront.Distribution(this, "Distribution", {
+        return new Distribution(this, "Distribution", {
             // these values can be overwritten by cfDistributionProps
             defaultRootObject: "",
             // Override props.
@@ -227,16 +229,16 @@ export class NextjsSite extends SsrSite {
         });
     }
     createCloudFrontServerCachePolicy() {
-        return new cloudfront.CachePolicy(this, "ServerCache", {
-            queryStringBehavior: cloudfront.CacheQueryStringBehavior.all(),
-            headerBehavior: cloudfront.CacheHeaderBehavior.allowList(
+        return new CachePolicy(this, "ServerCache", {
+            queryStringBehavior: CacheQueryStringBehavior.all(),
+            headerBehavior: CacheHeaderBehavior.allowList(
             // required by image optimization request
             "accept", 
             // required by server request
             "x-op-middleware-request-headers", "x-op-middleware-response-headers", "x-nextjs-data", "x-middleware-prefetch", 
             // required by server request (in-place routing)
             "rsc", "next-router-prefetch", "next-router-state-tree"),
-            cookieBehavior: cloudfront.CacheCookieBehavior.all(),
+            cookieBehavior: CacheCookieBehavior.all(),
             defaultTtl: CdkDuration.days(0),
             maxTtl: CdkDuration.days(365),
             minTtl: CdkDuration.days(0),

package/constructs/RemixSite.js

@@ -89,7 +89,7 @@ export class RemixSite extends SsrSite {
         };
     }
     createFunctionForRegional() {
-        const { runtime, timeout, memorySize, permissions, environment, bind, cdk, } = this.props;
+        const { runtime, timeout, memorySize, permissions, environment, bind, nodejs, cdk, } = this.props;
         const { handler, esbuild } = this.createServerLambdaBundle("regional-server.js");
         const fn = new Function(this, `ServerFunction`, {
             description: "Server handler",
@@ -100,8 +100,12 @@ export class RemixSite extends SsrSite {
             timeout,
             nodejs: {
                 format: "cjs",
-                install: ["sharp"],
-                esbuild,
+                ...nodejs,
+                esbuild: {
+                    ...esbuild,
+                    ...nodejs?.esbuild,
+                    inject: [...(nodejs?.esbuild?.inject || []), ...esbuild.inject],
+                },
             },
             bind,
             environment,
@@ -113,7 +117,7 @@ export class RemixSite extends SsrSite {
         return fn;
     }
     createFunctionForEdge() {
-        const { runtime, timeout, memorySize, bind, permissions, environment } = this.props;
+        const { runtime, timeout, memorySize, bind, permissions, environment, nodejs, } = this.props;
         const { handler, esbuild } = this.createServerLambdaBundle("edge-server.js");
         return new EdgeFunction(this, `Server`, {
             scopeOverride: this,
@@ -124,8 +128,15 @@ export class RemixSite extends SsrSite {
             bind,
             environment,
             permissions,
-            format: "cjs",
-            esbuild,
+            nodejs: {
+                format: "cjs",
+                ...nodejs,
+                esbuild: {
+                    ...esbuild,
+                    ...nodejs?.esbuild,
+                    inject: [...(nodejs?.esbuild?.inject || []), ...esbuild.inject],
+                },
+            },
         });
     }
 }

package/constructs/SolidStartSite.js

@@ -23,7 +23,7 @@ export class SolidStartSite extends SsrSite {
         };
     }
     createFunctionForRegional() {
-        const { runtime, timeout, memorySize, bind, permissions, environment, cdk, } = this.props;
+        const { runtime, timeout, memorySize, bind, nodejs, permissions, environment, cdk, } = this.props;
         // Create function
         const fn = new Function(this, `ServerFunction`, {
             description: "Server handler",
@@ -34,6 +34,7 @@ export class SolidStartSite extends SsrSite {
             timeout,
             nodejs: {
                 format: "esm",
+                ...nodejs,
             },
             bind,
             environment,
@@ -45,7 +46,7 @@ export class SolidStartSite extends SsrSite {
         return fn;
     }
     createFunctionForEdge() {
-        const { runtime, timeout, memorySize, bind, permissions, environment } = this.props;
+        const { runtime, timeout, memorySize, bind, permissions, environment, nodejs, } = this.props;
         return new EdgeFunction(this, `Server`, {
             scopeOverride: this,
             handler: path.join(this.props.path, "dist", "server", "index.handler"),
@@ -55,7 +56,10 @@ export class SolidStartSite extends SsrSite {
             bind,
             permissions,
             environment,
-            format: "esm",
+            nodejs: {
+                format: "esm",
+                ...nodejs,
+            },
         });
     }
 }

package/constructs/SsrSite.d.ts

@@ -6,6 +6,7 @@ import { Distribution, ICachePolicy, BehaviorOptions, CachePolicy } from "aws-cd
 import { ICertificate } from "aws-cdk-lib/aws-certificatemanager";
 import { S3Origin } from "aws-cdk-lib/aws-cloudfront-origins";
 import { SSTConstruct } from "./Construct.js";
+import { NodeJSProps } from "./Function.js";
 import { EdgeFunction } from "./EdgeFunction.js";
 import { BaseSiteDomainProps, BaseSiteReplaceProps, BaseSiteCdkDistributionProps } from "./BaseSite.js";
 import { Size } from "./util/size.js";
@@ -17,6 +18,8 @@ export type SsrBuildConfig = {
     clientBuildOutputDir: string;
     clientBuildVersionedSubDir: string;
 };
+export interface SsrSiteNodeJSProps extends NodeJSProps {
+}
 export interface SsrDomainProps extends BaseSiteDomainProps {
 }
 export interface SsrSiteReplaceProps extends BaseSiteReplaceProps {
@@ -103,6 +106,10 @@ export interface SsrSiteProps {
      * ```
      */
     runtime?: "nodejs14.x" | "nodejs16.x" | "nodejs18.x";
+    /**
+     * Used to configure nodejs function properties
+     */
+    nodejs?: SsrSiteNodeJSProps;
     /**
      * Attaches the given list of permissions to the SSR function. Configuring this property is equivalent to calling `attachPermissions()` after the site is created.
      * @example

package/node/future/auth/session.js

@@ -19,12 +19,7 @@ const SessionMemo = /* @__PURE__ */ Context.memo(() => {
             })(token);
             return jwt;
         }
-        catch {
-            return {
-                type: "public",
-                properties: {},
-            };
-        }
+        catch { }
     }
     return {
         type: "public",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sst",
-  "version": "2.1.20",
+  "version": "2.1.22",
   "bin": {
     "sst": "cli/sst.js"
   },

package/runtime/handlers/node.js

@@ -99,11 +99,16 @@ export const useNodeHandler = Context.memo(async () => {
                 };
             }
             const { external, ...override } = nodejs.esbuild || {};
+            const forceExternal = [
+                "sharp",
+                "pg-native",
+                ...(isESM || input.props.runtime === "nodejs18.x" ? [] : ["aws-sdk"]),
+            ];
             const options = {
                 entryPoints: [file],
                 platform: "node",
                 external: [
-                    ...(isESM || input.props.runtime === "nodejs18.x" ? [] : ["aws-sdk"]),
+                    ...forceExternal,
                     ...(nodejs.install || []),
                     ...(external || []),
                 ],
@@ -144,39 +149,57 @@ export const useNodeHandler = Context.memo(async () => {
             try {
                 const result = await esbuild.build(options);
                 // Install node_modules
-                if (options.external?.length) {
-                    async function find(dir, target) {
-                        if (dir === "/")
-                            throw new VisibleError("Could not find a package.json file");
-                        if (await fs
-                            .access(path.join(dir, target))
-                            .then(() => true)
-                            .catch(() => false))
-                            return dir;
-                        return find(path.join(dir, ".."), target);
+                const installPackages = [
+                    ...(nodejs.install || []),
+                    ...forceExternal
+                        .filter((pkg) => pkg !== "aws-sdk")
+                        .filter((pkg) => !external?.includes(pkg))
+                        .filter((pkg) => Object.values(result.metafile?.inputs || {}).some(({ imports }) => imports.some(({ path }) => path === pkg))),
+                ];
+                // TODO bubble up the warnings
+                const warnings = [];
+                Object.entries(result.metafile?.inputs || {}).forEach(([inputPath, { imports }]) => imports
+                    .filter(({ path }) => path.includes("sst/constructs"))
+                    .forEach(({ path }) => {
+                    warnings.push(`You are importing from "${path}" in "${inputPath}". Did you mean to import from "sst/node"?`);
+                }));
+                async function find(dir, target) {
+                    if (dir === "/")
+                        throw new VisibleError("Could not find a package.json file");
+                    if (await fs
+                        .access(path.join(dir, target))
+                        .then(() => true)
+                        .catch(() => false))
+                        return dir;
+                    return find(path.join(dir, ".."), target);
+                }
+                if (input.mode === "deploy" && installPackages) {
+                    const src = await find(parsed.dir, "package.json");
+                    const json = JSON.parse(await fs
+                        .readFile(path.join(src, "package.json"))
+                        .then((x) => x.toString()));
+                    fs.writeFile(path.join(input.out, "package.json"), JSON.stringify({
+                        dependencies: Object.fromEntries(installPackages.map((x) => [x, json.dependencies?.[x] || "*"])),
+                    }));
+                    const cmd = ["npm install"];
+                    if (installPackages.includes("sharp")) {
+                        cmd.push("--platform=linux", input.props.architecture === "arm_64"
+                            ? "--arch=arm64"
+                            : "--arch=x64");
                     }
-                    if (input.mode === "deploy" && nodejs.install) {
-                        const src = await find(parsed.dir, "package.json");
-                        const json = JSON.parse(await fs
-                            .readFile(path.join(src, "package.json"))
-                            .then((x) => x.toString()));
-                        fs.writeFile(path.join(input.out, "package.json"), JSON.stringify({
-                            dependencies: Object.fromEntries(nodejs.install?.map((x) => [x, json.dependencies?.[x] || "*"])),
-                        }));
-                        await new Promise((resolve) => {
-                            const process = exec("npm install", {
-                                cwd: input.out,
-                            });
-                            process.on("exit", () => resolve());
+                    await new Promise((resolve) => {
+                        const process = exec(cmd.join(" "), {
+                            cwd: input.out,
                         });
+                        process.on("exit", () => resolve());
+                    });
+                }
+                if (input.mode === "start") {
+                    const dir = path.join(await find(parsed.dir, "package.json"), "node_modules");
+                    try {
+                        await fs.symlink(path.resolve(dir), path.resolve(path.join(input.out, "node_modules")), "dir");
                     }
-                    if (input.mode === "start") {
-                        const dir = path.join(await find(parsed.dir, "package.json"), "node_modules");
-                        try {
-                            await fs.symlink(path.resolve(dir), path.resolve(path.join(input.out, "node_modules")), "dir");
-                        }
-                        catch { }
-                    }
+                    catch { }
                 }
                 cache[input.functionID] = result;
                 return {

package/sst.mjs

@@ -2603,6 +2603,11 @@ var init_workers = __esm({
 });
 
 // src/iot.ts
+var iot_exports = {};
+__export(iot_exports, {
+  useIOT: () => useIOT,
+  useIOTEndpoint: () => useIOTEndpoint
+});
 import { IoTClient, DescribeEndpointCommand } from "@aws-sdk/client-iot";
 import iot from "aws-iot-device-sdk";
 function encode(input) {
@@ -2721,8 +2726,8 @@ var init_iot = __esm({
 });
 
 // src/runtime/iot.ts
-var iot_exports = {};
-__export(iot_exports, {
+var iot_exports2 = {};
+__export(iot_exports2, {
   useIOTBridge: () => useIOTBridge
 });
 var useIOTBridge;
@@ -4974,11 +4979,16 @@ var init_node = __esm({
             };
           }
           const { external, ...override } = nodejs.esbuild || {};
+          const forceExternal = [
+            "sharp",
+            "pg-native",
+            ...isESM || input.props.runtime === "nodejs18.x" ? [] : ["aws-sdk"]
+          ];
           const options = {
             entryPoints: [file],
             platform: "node",
             external: [
-              ...isESM || input.props.runtime === "nodejs18.x" ? [] : ["aws-sdk"],
+              ...forceExternal,
               ...nodejs.install || [],
               ...external || []
             ],
@@ -5014,47 +5024,68 @@ var init_node = __esm({
           };
           try {
             const result = await esbuild2.build(options);
-            if (options.external?.length) {
-              async function find2(dir, target2) {
-                if (dir === "/")
-                  throw new VisibleError("Could not find a package.json file");
-                if (await fs10.access(path10.join(dir, target2)).then(() => true).catch(() => false))
-                  return dir;
-                return find2(path10.join(dir, ".."), target2);
-              }
-              if (input.mode === "deploy" && nodejs.install) {
-                const src = await find2(parsed.dir, "package.json");
-                const json = JSON.parse(
-                  await fs10.readFile(path10.join(src, "package.json")).then((x) => x.toString())
+            const installPackages = [
+              ...nodejs.install || [],
+              ...forceExternal.filter((pkg) => pkg !== "aws-sdk").filter((pkg) => !external?.includes(pkg)).filter(
+                (pkg) => Object.values(result.metafile?.inputs || {}).some(
+                  ({ imports }) => imports.some(({ path: path20 }) => path20 === pkg)
+                )
+              )
+            ];
+            const warnings = [];
+            Object.entries(result.metafile?.inputs || {}).forEach(
+              ([inputPath, { imports }]) => imports.filter(({ path: path20 }) => path20.includes("sst/constructs")).forEach(({ path: path20 }) => {
+                warnings.push(
+                  `You are importing from "${path20}" in "${inputPath}". Did you mean to import from "sst/node"?`
                 );
-                fs10.writeFile(
-                  path10.join(input.out, "package.json"),
-                  JSON.stringify({
-                    dependencies: Object.fromEntries(
-                      nodejs.install?.map((x) => [x, json.dependencies?.[x] || "*"])
-                    )
-                  })
+              })
+            );
+            async function find2(dir, target2) {
+              if (dir === "/")
+                throw new VisibleError("Could not find a package.json file");
+              if (await fs10.access(path10.join(dir, target2)).then(() => true).catch(() => false))
+                return dir;
+              return find2(path10.join(dir, ".."), target2);
+            }
+            if (input.mode === "deploy" && installPackages) {
+              const src = await find2(parsed.dir, "package.json");
+              const json = JSON.parse(
+                await fs10.readFile(path10.join(src, "package.json")).then((x) => x.toString())
+              );
+              fs10.writeFile(
+                path10.join(input.out, "package.json"),
+                JSON.stringify({
+                  dependencies: Object.fromEntries(
+                    installPackages.map((x) => [x, json.dependencies?.[x] || "*"])
+                  )
+                })
+              );
+              const cmd = ["npm install"];
+              if (installPackages.includes("sharp")) {
+                cmd.push(
+                  "--platform=linux",
+                  input.props.architecture === "arm_64" ? "--arch=arm64" : "--arch=x64"
                 );
-                await new Promise((resolve) => {
-                  const process2 = exec2("npm install", {
-                    cwd: input.out
-                  });
-                  process2.on("exit", () => resolve());
-                });
               }
-              if (input.mode === "start") {
-                const dir = path10.join(
-                  await find2(parsed.dir, "package.json"),
-                  "node_modules"
+              await new Promise((resolve) => {
+                const process2 = exec2(cmd.join(" "), {
+                  cwd: input.out
+                });
+                process2.on("exit", () => resolve());
+              });
+            }
+            if (input.mode === "start") {
+              const dir = path10.join(
+                await find2(parsed.dir, "package.json"),
+                "node_modules"
+              );
+              try {
+                await fs10.symlink(
+                  path10.resolve(dir),
+                  path10.resolve(path10.join(input.out, "node_modules")),
+                  "dir"
                 );
-                try {
-                  await fs10.symlink(
-                    path10.resolve(dir),
-                    path10.resolve(path10.join(input.out, "node_modules")),
-                    "dir"
-                  );
-                } catch {
-                }
+              } catch {
               }
             }
             cache[input.functionID] = result;
@@ -6742,7 +6773,7 @@ var dev = (program2) => program2.command(
     const { mapValues, omitBy: omitBy2, pipe: pipe3 } = await import("remeda");
     const path20 = await import("path");
     const { useRuntimeWorkers: useRuntimeWorkers2 } = await Promise.resolve().then(() => (init_workers(), workers_exports));
-    const { useIOTBridge: useIOTBridge2 } = await Promise.resolve().then(() => (init_iot2(), iot_exports));
+    const { useIOTBridge: useIOTBridge2 } = await Promise.resolve().then(() => (init_iot2(), iot_exports2));
     const { useRuntimeServer: useRuntimeServer2 } = await Promise.resolve().then(() => (init_server2(), server_exports2));
     const { useBus: useBus2 } = await Promise.resolve().then(() => (init_bus(), bus_exports));
     const { useWatcher: useWatcher2 } = await Promise.resolve().then(() => (init_watcher(), watcher_exports));
@@ -6764,6 +6795,7 @@ var dev = (program2) => program2.command(
     const { useRDSWarmer: useRDSWarmer2 } = await Promise.resolve().then(() => (init_warmer(), warmer_exports));
     const { useProject: useProject2 } = await Promise.resolve().then(() => (init_project(), project_exports));
     const { useMetadata: useMetadata2 } = await Promise.resolve().then(() => (init_metadata(), metadata_exports));
+    const { useIOT: useIOT2 } = await Promise.resolve().then(() => (init_iot(), iot_exports));
     const { clear: clear2 } = await Promise.resolve().then(() => (init_terminal(), terminal_exports));
     if (args._[0] === "start") {
       console.log(
@@ -6985,6 +7017,30 @@ var dev = (program2) => program2.command(
       });
       await build2();
     });
+    const useDisconnector = Context2.memo(async () => {
+      const bus = useBus2();
+      const project = useProject2();
+      const iot2 = await useIOT2();
+      bus.subscribe("cli.dev", async (evt) => {
+        const topic = `${iot2.prefix}/events`;
+        iot2.publish(topic, "cli.dev", evt.properties);
+      });
+      bus.publish("cli.dev", {
+        stage: project.config.stage,
+        app: project.config.name
+      });
+      bus.subscribe("cli.dev", async (evt) => {
+        if (evt.properties.stage !== project.config.stage)
+          return;
+        if (evt.properties.app !== project.config.name)
+          return;
+        Colors2.line(
+          Colors2.danger(`\u279C `),
+          "Another sst dev session has been started up for this stage. Exiting"
+        );
+        process.exit(0);
+      });
+    });
     const [appMetadata] = await Promise.all([
       useAppMetadata2(),
       useLocalServer2({
@@ -7001,6 +7057,7 @@ var dev = (program2) => program2.command(
     clear2();
     await printHeader2({ console: true, hint: "ready!" });
     await Promise.all([
+      useDisconnector(),
       useRuntimeWorkers2(),
       useIOTBridge2(),
       useRuntimeServer2(),

package/support/custom-resources/index.mjs

@@ -30082,7 +30082,7 @@ var require_StandardRetryStrategy = __commonJS({
     var config_1 = require_config2();
     var constants_1 = require_constants3();
     var defaultRetryToken_1 = require_defaultRetryToken();
-    var StandardRetryStrategy = class {
+    var StandardRetryStrategy2 = class {
       constructor(maxAttemptsProvider) {
         this.maxAttemptsProvider = maxAttemptsProvider;
         this.mode = config_1.RETRY_MODES.STANDARD;
@@ -30120,8 +30120,8 @@ var require_StandardRetryStrategy = __commonJS({
         return errorType === "THROTTLING" || errorType === "TRANSIENT";
       }
     };
-    __name(StandardRetryStrategy, "StandardRetryStrategy");
-    exports.StandardRetryStrategy = StandardRetryStrategy;
+    __name(StandardRetryStrategy2, "StandardRetryStrategy");
+    exports.StandardRetryStrategy = StandardRetryStrategy2;
   }
 });
 
@@ -30283,7 +30283,7 @@ var require_StandardRetryStrategy2 = __commonJS({
     var delayDecider_1 = require_delayDecider();
     var retryDecider_1 = require_retryDecider();
     var util_1 = require_util();
-    var StandardRetryStrategy = class {
+    var StandardRetryStrategy2 = class {
       constructor(maxAttemptsProvider, options) {
         var _a, _b, _c;
         this.maxAttemptsProvider = maxAttemptsProvider;
@@ -30351,8 +30351,8 @@ var require_StandardRetryStrategy2 = __commonJS({
         }
       }
     };
-    __name(StandardRetryStrategy, "StandardRetryStrategy");
-    exports.StandardRetryStrategy = StandardRetryStrategy;
+    __name(StandardRetryStrategy2, "StandardRetryStrategy");
+    exports.StandardRetryStrategy = StandardRetryStrategy2;
     var getDelayFromRetryAfterHeader = /* @__PURE__ */ __name((response) => {
       if (!protocol_http_1.HttpResponse.isInstance(response))
         return;
@@ -103057,7 +103057,7 @@ var require_StandardRetryStrategy3 = __commonJS({
     var defaultRetryQuota_1 = require_defaultRetryQuota2();
     var delayDecider_1 = require_delayDecider2();
     var retryDecider_1 = require_retryDecider2();
-    var StandardRetryStrategy = class {
+    var StandardRetryStrategy2 = class {
       constructor(maxAttemptsProvider, options) {
         var _a, _b, _c;
         this.maxAttemptsProvider = maxAttemptsProvider;
@@ -103125,8 +103125,8 @@ var require_StandardRetryStrategy3 = __commonJS({
         }
       }
     };
-    __name(StandardRetryStrategy, "StandardRetryStrategy");
-    exports.StandardRetryStrategy = StandardRetryStrategy;
+    __name(StandardRetryStrategy2, "StandardRetryStrategy");
+    exports.StandardRetryStrategy = StandardRetryStrategy2;
     var getDelayFromRetryAfterHeader = /* @__PURE__ */ __name((response) => {
       if (!protocol_http_1.HttpResponse.isInstance(response))
         return;
@@ -164635,7 +164635,22 @@ __name(wait, "wait");
 // support/custom-resources/apigateway-cloudwatch-role.ts
 var import_client_api_gateway = __toESM(require_dist_cjs111(), 1);
 var import_client_iam = __toESM(require_dist_cjs112(), 1);
-var apig = new import_client_api_gateway.APIGatewayClient({ logger: console });
+var import_middleware_retry = __toESM(require_dist_cjs17(), 1);
+var apig = new import_client_api_gateway.APIGatewayClient({
+  logger: console,
+  retryStrategy: new import_middleware_retry.StandardRetryStrategy(async () => 1e4, {
+    retryDecider: (e) => {
+      if (e.name === "TooManyRequestsException" && e.message === "Too Many Requests") {
+        console.log("Retry on error", e.name);
+        return true;
+      }
+      return false;
+    },
+    delayDecider: (_, attempts) => {
+      return Math.min(1.5 ** attempts * 100, 3e3);
+    }
+  })
+});
 var iam = new import_client_iam.IAMClient({ logger: console });
 async function ApiGatewayCloudWatchRole(cfnRequest) {
   switch (cfnRequest.RequestType) {
@@ -164702,17 +164717,28 @@ async function createRole(roleName) {
 __name(createRole, "createRole");
 async function attachRoleToApiGateway(roleArn) {
   console.log("attachRoleToApiGateway");
-  await apig.send(
-    new import_client_api_gateway.UpdateAccountCommand({
-      patchOperations: [
-        {
-          op: "replace",
-          path: "/cloudwatchRoleArn",
-          value: roleArn
-        }
-      ]
-    })
-  );
+  try {
+    await apig.send(
+      new import_client_api_gateway.UpdateAccountCommand({
+        patchOperations: [
+          {
+            op: "replace",
+            path: "/cloudwatchRoleArn",
+            value: roleArn
+          }
+        ]
+      })
+    );
+  } catch (e) {
+    console.log(e);
+    if (e.name === "BadRequestException" && e.message === "The role ARN does not have required permissions configured. Please grant trust permission for API Gateway and add the required role policy.") {
+      console.log("Retry after 1 second");
+      await new Promise((resolve) => setTimeout(resolve, 1e3));
+      await attachRoleToApiGateway(roleArn);
+      return;
+    }
+    throw e;
+  }
 }
 __name(attachRoleToApiGateway, "attachRoleToApiGateway");
 

package/support/remix-site-function/edge-server.js

@@ -9,9 +9,9 @@ installGlobals();
 import {
   Headers as NodeHeaders,
   Request as NodeRequest,
+  createRequestHandler as createNodeRequestHandler,
   readableStreamToString,
 } from "@remix-run/node";
-import { createRequestHandler as createRemixRequestHandler } from "@remix-run/server-runtime";
 import { URL } from "url";
 
 // Import the server build that was produced by `remix build`;
@@ -146,7 +146,7 @@ async function convertNodeResponseToCf(nodeResponse) {
 }
 
 function createCfHandler(build) {
-  const requestHandler = createRemixRequestHandler(build, process.env.NODE_ENV);
+  const requestHandler = createNodeRequestHandler(build, process.env.NODE_ENV);
 
   return async (event) => {
     const request = convertCfRequestToNode(event);