sst 2.31.0 → 2.32.1

package/constructs/NextjsSite.js

@@ -1,6 +1,8 @@
 import fs from "fs";
 import path from "path";
+import zlib from "zlib";
 import crypto from "crypto";
+import { globSync } from "glob";
 import { Duration as CdkDuration, RemovalPolicy, CustomResource, } from "aws-cdk-lib/core";
 import { Code, Runtime, Function as CdkFunction, Architecture, LayerVersion, } from "aws-cdk-lib/aws-lambda";
 import { AttributeType, Billing, TableV2 as Table, } from "aws-cdk-lib/aws-dynamodb";
@@ -13,6 +15,9 @@ import { toCdkSize } from "./util/size.js";
 import { Effect, Policy, PolicyStatement } from "aws-cdk-lib/aws-iam";
 import { RetentionDays } from "aws-cdk-lib/aws-logs";
 import { VisibleError } from "../error.js";
+import { Asset } from "aws-cdk-lib/aws-s3-assets";
+import { useFunctions } from "./Function.js";
+import { useDeferredTasks } from "./deferred_task.js";
 const LAYER_VERSION = "2";
 const DEFAULT_OPEN_NEXT_VERSION = "2.2.4";
 const DEFAULT_CACHE_POLICY_ALLOWED_HEADERS = [
@@ -34,7 +39,11 @@ const DEFAULT_CACHE_POLICY_ALLOWED_HEADERS = [
  * ```
  */
 export class NextjsSite extends SsrSite {
-    routes;
+    _routes;
+    routesManifest;
+    appPathRoutesManifest;
+    appPathsManifest;
+    pagesManifest;
     constructor(scope, id, props) {
         const streaming = props?.experimental?.streaming ?? false;
         const disableDynamoDBCache = props?.experimental?.disableDynamoDBCache ?? false;
@@ -57,6 +66,7 @@ export class NextjsSite extends SsrSite {
         });
         if (this.isPerRouteLoggingEnabled()) {
             this.disableDefaultLogging();
+            this.uploadSourcemaps();
         }
         if (!disableIncrementalCache) {
             this.createRevalidationQueue();
@@ -80,6 +90,7 @@ export class NextjsSite extends SsrSite {
                 CACHE_BUCKET_REGION: Stack.of(this).region,
             },
         });
+        this.removeSourcemaps();
         return this.validatePlan({
             cloudFrontFunctions: {
                 serverCfFunction: {
@@ -312,7 +323,10 @@ export class NextjsSite extends SsrSite {
         const injections = [];
         if (this.isPerRouteLoggingEnabled()) {
             injections.push(`
-      const routeData = ${JSON.stringify(this.useRoutes())}.find(({ regex }) => event.rawPath.match(new RegExp(regex)));
+      const routeData = ${JSON.stringify(this.useRoutes().map(({ regex, logGroupPath }) => ({
+                regex,
+                logGroupPath,
+            })))}.find(({ regex }) => event.rawPath.match(new RegExp(regex)));
       if (routeData) {
         console.log("::sst::" + JSON.stringify({
           action:"log.split",
@@ -349,53 +363,178 @@ export class NextjsSite extends SsrSite {
             handler: `${wrapperName}.handler`,
         };
     }
+    removeSourcemaps() {
+        const { path: sitePath } = this.props;
+        const files = globSync("**/*.js.map", {
+            cwd: path.join(sitePath, ".open-next", "server-function"),
+            nodir: true,
+            dot: true,
+        });
+        for (const file of files) {
+            fs.rmSync(path.join(sitePath, ".open-next", "server-function", file));
+        }
+    }
     useRoutes() {
-        if (this.routes)
-            return this.routes;
-        const id = this.node.id;
+        if (this._routes)
+            return this._routes;
+        const routesManifest = this.useRoutesManifest();
+        this._routes = [
+            ...[...routesManifest.dynamicRoutes, ...routesManifest.staticRoutes]
+                .map(({ page, regex }) => {
+                const cwRoute = NextjsSite.buildCloudWatchRouteName(page);
+                const cwHash = NextjsSite.buildCloudWatchRouteHash(page);
+                const sourcemapPath = this.getSourcemapForAppRoute(page) ||
+                    this.getSourcemapForPagesRoute(page);
+                return {
+                    route: page,
+                    regex,
+                    logGroupPath: `/${cwHash}${cwRoute}`,
+                    sourcemapPath: sourcemapPath,
+                    sourcemapKey: cwHash,
+                };
+            })
+                .sort((a, b) => a.route.localeCompare(b.route)),
+            ...(routesManifest.dataRoutes || [])
+                .map(({ page, dataRouteRegex }) => {
+                const routeDisplayName = page.endsWith("/")
+                    ? `/_next/data/BUILD_ID${page}index.json`
+                    : `/_next/data/BUILD_ID${page}.json`;
+                const cwRoute = NextjsSite.buildCloudWatchRouteName(routeDisplayName);
+                const cwHash = NextjsSite.buildCloudWatchRouteHash(page);
+                return {
+                    route: routeDisplayName,
+                    regex: dataRouteRegex,
+                    logGroupPath: `/${cwHash}${cwRoute}`,
+                };
+            })
+                .sort((a, b) => a.route.localeCompare(b.route)),
+        ];
+        return this._routes;
+    }
+    useRoutesManifest() {
+        if (this.routesManifest)
+            return this.routesManifest;
         const { path: sitePath } = this.props;
+        const id = this.node.id;
         try {
-            const content = JSON.parse(fs
+            const content = fs
                 .readFileSync(path.join(sitePath, ".next/routes-manifest.json"))
-                .toString());
-            this.routes = [
-                ...[...content.dynamicRoutes, ...content.staticRoutes]
-                    .map(({ page, regex }) => {
-                    const cwRoute = NextjsSite.buildCloudWatchRouteName(page);
-                    const cwHash = NextjsSite.buildCloudWatchRouteHash(page);
-                    return {
-                        route: page,
-                        regex,
-                        logGroupPath: `/${cwHash}${cwRoute}`,
-                    };
-                })
-                    .sort((a, b) => a.route.localeCompare(b.route)),
-                ...(content.dataRoutes || [])
-                    .map(({ page, dataRouteRegex }) => {
-                    const routeDisplayName = page.endsWith("/")
-                        ? `/_next/data/BUILD_ID${page}index.json`
-                        : `/_next/data/BUILD_ID${page}.json`;
-                    const cwRoute = NextjsSite.buildCloudWatchRouteName(routeDisplayName);
-                    const cwHash = NextjsSite.buildCloudWatchRouteHash(`data:${page}`);
-                    return {
-                        route: routeDisplayName,
-                        regex: dataRouteRegex,
-                        logGroupPath: `/${cwHash}${cwRoute}`,
-                    };
-                })
-                    .sort((a, b) => a.route.localeCompare(b.route)),
-            ];
-            return this.routes;
+                .toString();
+            this.routesManifest = JSON.parse(content);
+            return this.routesManifest;
         }
         catch (e) {
             console.error(e);
             throw new VisibleError(`Failed to read routes data from ".next/routes-manifest.json" for the "${id}" site.`);
         }
     }
+    useAppPathRoutesManifest() {
+        if (this.appPathRoutesManifest)
+            return this.appPathRoutesManifest;
+        const { path: sitePath } = this.props;
+        try {
+            const content = fs
+                .readFileSync(path.join(sitePath, ".next/app-path-routes-manifest.json"))
+                .toString();
+            this.appPathRoutesManifest = JSON.parse(content);
+            return this.appPathRoutesManifest;
+        }
+        catch (e) {
+            return {};
+        }
+    }
+    useAppPathsManifest() {
+        if (this.appPathsManifest)
+            return this.appPathsManifest;
+        const { path: sitePath } = this.props;
+        try {
+            const content = fs
+                .readFileSync(path.join(sitePath, ".next/server/app-paths-manifest.json"))
+                .toString();
+            this.appPathsManifest = JSON.parse(content);
+            return this.appPathsManifest;
+        }
+        catch (e) {
+            return {};
+        }
+    }
+    usePagesManifest() {
+        if (this.pagesManifest)
+            return this.pagesManifest;
+        const { path: sitePath } = this.props;
+        try {
+            const content = fs
+                .readFileSync(path.join(sitePath, ".next/server/pages-manifest.json"))
+                .toString();
+            this.pagesManifest = JSON.parse(content);
+            return this.pagesManifest;
+        }
+        catch (e) {
+            return {};
+        }
+    }
     getBuildId() {
         const { path: sitePath } = this.props;
         return fs.readFileSync(path.join(sitePath, ".next/BUILD_ID")).toString();
     }
+    getSourcemapForAppRoute(page) {
+        const { path: sitePath } = this.props;
+        // Step 1: look up in "appPathRoutesManifest" to find the key with
+        //         value equal to the page
+        // {
+        //   "/_not-found": "/_not-found",
+        //   "/about/page": "/about",
+        //   "/about/profile/page": "/about/profile",
+        //   "/page": "/",
+        //   "/favicon.ico/route": "/favicon.ico"
+        // }
+        const appPathRoutesManifest = this.useAppPathRoutesManifest();
+        const appPathRoute = Object.keys(appPathRoutesManifest).find((key) => appPathRoutesManifest[key] === page);
+        if (!appPathRoute)
+            return;
+        // Step 2: look up in "appPathsManifest" to find the file with key equal
+        //         to the page
+        // {
+        //   "/_not-found": "app/_not-found.js",
+        //   "/about/page": "app/about/page.js",
+        //   "/about/profile/page": "app/about/profile/page.js",
+        //   "/page": "app/page.js",
+        //   "/favicon.ico/route": "app/favicon.ico/route.js"
+        // }
+        const appPathsManifest = this.useAppPathsManifest();
+        const filePath = appPathsManifest[appPathRoute];
+        if (!filePath)
+            return;
+        // Step 3: check the .map file exists
+        const sourcemapPath = path.join(sitePath, ".next", "server", `${filePath}.map`);
+        if (!fs.existsSync(sourcemapPath))
+            return;
+        return sourcemapPath;
+    }
+    getSourcemapForPagesRoute(page) {
+        const { path: sitePath } = this.props;
+        // Step 1: look up in "pathsManifest" to find the file with key equal
+        //         to the page
+        // {
+        //   "/_app": "pages/_app.js",
+        //   "/_error": "pages/_error.js",
+        //   "/404": "pages/404.html",
+        //   "/api/hello": "pages/api/hello.js",
+        //   "/api/auth/[...nextauth]": "pages/api/auth/[...nextauth].js",
+        //   "/api/next-auth-restricted": "pages/api/next-auth-restricted.js",
+        //   "/": "pages/index.js",
+        //   "/ssr": "pages/ssr.js"
+        // }
+        const pagesManifest = this.usePagesManifest();
+        const filePath = pagesManifest[page];
+        if (!filePath)
+            return;
+        // Step 2: check the .map file exists
+        const sourcemapPath = path.join(sitePath, ".next", "server", `${filePath}.map`);
+        if (!fs.existsSync(sourcemapPath))
+            return;
+        return sourcemapPath;
+    }
     isPerRouteLoggingEnabled() {
         return (!this.doNotDeploy &&
             !this.props.edge &&
@@ -424,6 +563,28 @@ export class NextjsSite extends SsrSite {
         });
         server.role?.attachInlinePolicy(policy);
     }
+    uploadSourcemaps() {
+        const stack = Stack.of(this);
+        const server = this.serverFunction;
+        this.useRoutes().forEach(({ sourcemapPath, sourcemapKey }) => {
+            if (!sourcemapPath || !sourcemapKey)
+                return;
+            useDeferredTasks().add(async () => {
+                // zip sourcemap
+                const zipPath = `${sourcemapPath}.gz.zip`;
+                const data = await fs.promises.readFile(sourcemapPath);
+                await fs.promises.writeFile(zipPath, zlib.gzipSync(data));
+                const asset = new Asset(this, `Sourcemap-${sourcemapKey}`, {
+                    path: zipPath,
+                });
+                useFunctions().sourcemaps.add(stack.stackName, {
+                    srcBucket: asset.bucket,
+                    srcKey: asset.s3ObjectKey,
+                    tarKey: path.join(server.functionArn, sourcemapKey),
+                });
+            });
+        });
+    }
     static buildCloudWatchRouteName(route) {
         return route.replace(/[^a-zA-Z0-9_\-/.#]/g, "");
     }

package/constructs/Service.d.ts

@@ -375,7 +375,6 @@ type ServiceNormalizedProps = ServiceProps & {
     memory: Exclude<ServiceProps["memory"], undefined>;
     port: Exclude<ServiceProps["port"], undefined>;
     logRetention: Exclude<ServiceProps["logRetention"], undefined>;
-    waitForInvalidation: Exclude<ServiceProps["waitForInvalidation"], undefined>;
 };
 /**
  * The `Service` construct is a higher level CDK construct that makes it easy to create modern web apps with Server Side Rendering capabilities.

package/constructs/Service.js

@@ -159,7 +159,6 @@ export class Service extends Construct {
             memory: props?.memory || "0.5 GB",
             port: props?.port || 3000,
             logRetention: props?.logRetention || "infinite",
-            waitForInvalidation: false,
             ...props,
         };
         this.doNotDeploy =
@@ -645,7 +644,7 @@ export class Service extends Construct {
             platform: architecture === "arm64" ? Platform.LINUX_ARM64 : Platform.LINUX_AMD64,
             file: dockerfile,
             buildArgs: build?.buildArgs,
-            exclude: [".sst"],
+            exclude: [".sst/dist", ".sst/artifacts"],
             ignoreMode: IgnoreMode.GLOB,
         });
         const cfnTask = taskDefinition.node.defaultChild;

package/constructs/SsrSite.d.ts

@@ -1,7 +1,7 @@
 import { Construct } from "constructs";
 import { Bucket, BucketProps, IBucket } from "aws-cdk-lib/aws-s3";
 import { Function as CdkFunction, FunctionProps as CdkFunctionProps } from "aws-cdk-lib/aws-lambda";
-import { ICachePolicy, IResponseHeadersPolicy, AllowedMethods, CachePolicyProps, ErrorResponse } from "aws-cdk-lib/aws-cloudfront";
+import { ICachePolicy, IResponseHeadersPolicy, ViewerProtocolPolicy, AllowedMethods, CachePolicyProps, ErrorResponse } from "aws-cdk-lib/aws-cloudfront";
 import { Schedule } from "aws-cdk-lib/aws-events";
 import { DistributionDomainProps } from "./Distribution.js";
 import { SSTConstruct } from "./Construct.js";
@@ -214,21 +214,6 @@ export interface SsrSiteProps {
          * ```
          */
         textEncoding?: "utf-8" | "iso-8859-1" | "windows-1252" | "ascii" | "none";
-        /**
-         * The strategy to use for invalidating the CDN cache. By default, the CDN cache will invalidate on changes any cached file, but this could become slow on very large projects.
-         * - "never" - No invalidation will be performed.
-         * - "all" - All files will be invalidated when any file changes. (Default, requires checking file content which will increase deployment time)
-         * - "versioned" - Only versioned files will be invalidated when versioned files change.
-         * - "always" - All files are invalidated on every deployment.
-         * @default all
-         * @example
-         * ```js
-         * assets: {
-         *   cdnInvalidationStrategy: "versioned"
-         * }
-         * ```
-         */
-        cdnInvalidationStrategy?: "never" | "all" | "versioned" | "always";
         /**
          * The TTL for versioned files (ex: `main-1234.css`) in the CDN and browser cache. Ignored when `versionedFilesCacheHeader` is specified.
          * @default 1 year
@@ -294,9 +279,45 @@ export interface SsrSiteProps {
          */
         _uploadConcurrency?: number;
     };
+    invalidation?: {
+        /**
+         * While deploying, SST waits for the CloudFront cache invalidation process to finish. This ensures that the new content will be served once the deploy command finishes. However, this process can sometimes take more than 5 mins. For non-prod environments it might make sense to pass in `false`. That'll skip waiting for the cache to invalidate and speed up the deploy process.
+         * @default false
+         * @example
+         * ```js
+         * invalidation: {
+         *   wait: true,
+         * }
+         * ```
+         */
+        wait?: boolean;
+        /**
+         * The paths to invalidate. There are three built-in options:
+         * - "none" - No invalidation will be performed.
+         * - "all" - All files will be invalidated when any file changes.
+         * - "versioned" - Only versioned files will be invalidated when versioned files change.
+         * Alternatively you can pass in an array of paths to invalidate.
+         * @default "all"
+         * @example
+         * Disable invalidation:
+         * ```js
+         * invalidation: {
+         *   paths: "none",
+         * }
+         * ```
+         * Invalidate "index.html" and all files under the "products" route:
+         * ```js
+         * invalidation: {
+         *   paths: ["/index.html", "/products/*"],
+         * }
+         * ```
+         */
+        paths?: "none" | "all" | "versioned" | string[];
+    };
     /**
      * While deploying, SST waits for the CloudFront cache invalidation process to finish. This ensures that the new content will be served once the deploy command finishes. However, this process can sometimes take more than 5 mins. For non-prod environments it might make sense to pass in `false`. That'll skip waiting for the cache to invalidate and speed up the deploy process.
      * @default false
+     * @deprecated Use `invalidation.wait` instead.
      */
     waitForInvalidation?: boolean;
     cdk?: {
@@ -340,16 +361,32 @@ export interface SsrSiteProps {
          * from the server rendering Lambda.
          */
         responseHeadersPolicy?: IResponseHeadersPolicy;
+        /**
+         * Override the CloudFront viewer protocol policy properties.
+         * @default ViewerProtocolPolicy.REDIRECT_TO_HTTPS
+         * @example
+         * ```js
+         * import { ViewerProtocolPolicy } from "aws-cdk-lib/aws-cloudfront";
+         *
+         * cdk: {
+         *   viewerProtocolPolicy: ViewerProtocolPolicy.REDIRECT_TO_HTTPS,
+         * }
+         * ```
+         */
+        viewerProtocolPolicy?: ViewerProtocolPolicy;
         server?: Pick<CdkFunctionProps, "layers" | "vpc" | "vpcSubnets" | "securityGroups" | "allowAllOutbound" | "allowPublicSubnet" | "architecture" | "logRetention"> & Pick<FunctionProps, "copyFiles">;
     };
 }
+type SsrSiteInvalidationNormalizedProps = Exclude<SsrSiteProps["invalidation"], undefined>;
 export type SsrSiteNormalizedProps = SsrSiteProps & {
     path: Exclude<SsrSiteProps["path"], undefined>;
     typesPath: Exclude<SsrSiteProps["typesPath"], undefined>;
     runtime: Exclude<SsrSiteProps["runtime"], undefined>;
     timeout: Exclude<SsrSiteProps["timeout"], undefined>;
     memorySize: Exclude<SsrSiteProps["memorySize"], undefined>;
-    waitForInvalidation: Exclude<SsrSiteProps["waitForInvalidation"], undefined>;
+    invalidation: Exclude<SsrSiteProps["invalidation"], undefined> & {
+        paths: Exclude<SsrSiteInvalidationNormalizedProps["paths"], undefined>;
+    };
 };
 /**
  * The `SsrSite` construct is a higher level CDK construct that makes it easy to create modern web apps with Server Side Rendering capabilities.

package/constructs/SsrSite.js

@@ -55,18 +55,22 @@ export class SsrSite extends Construct {
         const props = {
             path: ".",
             typesPath: ".",
-            waitForInvalidation: false,
             runtime: "nodejs18.x",
             timeout: "10 seconds",
             memorySize: "1024 MB",
             ...rawProps,
+            invalidation: {
+                wait: rawProps?.waitForInvalidation,
+                paths: "all",
+                ...rawProps?.invalidation,
+            },
         };
         this.id = id;
         this.props = props;
         const app = scope.node.root;
         const stack = Stack.of(this);
         const self = this;
-        const { path: sitePath, typesPath, buildCommand, runtime, timeout, memorySize, edge, regional, dev, assets, nodejs, permissions, environment, bind, customDomain, waitForInvalidation, warm, cdk, } = props;
+        const { path: sitePath, typesPath, buildCommand, runtime, timeout, memorySize, edge, regional, dev, assets, nodejs, permissions, environment, bind, customDomain, invalidation, warm, cdk, } = props;
         this.doNotDeploy = !stack.isActive || (app.mode === "dev" && !dev?.deploy);
         validateSiteExists();
         validateTimeout();
@@ -259,7 +263,6 @@ export class SsrSite extends Construct {
             const distribution = new Distribution(self, "CDN", {
                 scopeOverride: self,
                 customDomain,
-                waitForInvalidation,
                 cdk: {
                     distribution: {
                         // these values can be overwritten
@@ -305,7 +308,7 @@ export class SsrSite extends Construct {
             if (behavior.cacheType === "static") {
                 return {
                     origin,
-                    viewerProtocolPolicy: ViewerProtocolPolicy.REDIRECT_TO_HTTPS,
+                    viewerProtocolPolicy: cdk?.viewerProtocolPolicy ?? ViewerProtocolPolicy.REDIRECT_TO_HTTPS,
                     allowedMethods: behavior.allowedMethods ?? AllowedMethods.ALLOW_GET_HEAD_OPTIONS,
                     cachedMethods: CachedMethods.CACHE_GET_HEAD_OPTIONS,
                     compress: true,
@@ -323,7 +326,7 @@ export class SsrSite extends Construct {
             }
             else if (behavior.cacheType === "server") {
                 return {
-                    viewerProtocolPolicy: ViewerProtocolPolicy.REDIRECT_TO_HTTPS,
+                    viewerProtocolPolicy: cdk?.viewerProtocolPolicy ?? ViewerProtocolPolicy.REDIRECT_TO_HTTPS,
                     origin,
                     allowedMethods: behavior.allowedMethods ?? AllowedMethods.ALLOW_ALL,
                     cachedMethods: CachedMethods.CACHE_GET_HEAD_OPTIONS,
@@ -689,18 +692,7 @@ function handler(event) {
             return replaceValues;
         }
         function createDistributionInvalidation() {
-            const cdnInvalidationStrategy = assets?.cdnInvalidationStrategy ?? "all";
-            if (cdnInvalidationStrategy === "never")
-                return;
-            if (plan.buildId) {
-                distribution.createInvalidation(plan.buildId);
-                return;
-            }
-            if (cdnInvalidationStrategy === "always") {
-                const buildId = Date.now().toString(16) + Math.random().toString(16).slice(2);
-                distribution.createInvalidation(buildId);
-                return;
-            }
+            const paths = invalidation.paths;
             // We will generate a hash based on the contents of the S3 files with cache enabled.
             // This will be used to determine if we need to invalidate our CloudFront cache.
             const s3Origin = Object.values(plan.origins).find((origin) => origin.type === "s3");
@@ -711,46 +703,64 @@ function handler(event) {
                 return;
             // Build invalidation paths
             const invalidationPaths = [];
-            if (cdnInvalidationStrategy === "versioned") {
+            if (paths === "none") {
+            }
+            else if (paths === "all") {
+                invalidationPaths.push("/*");
+            }
+            else if (paths === "versioned") {
                 cachedS3Files.forEach((item) => {
                     if (!item.versionedSubDir)
                         return;
                     invalidationPaths.push(path.posix.join("/", item.to, item.versionedSubDir, "*"));
                 });
             }
+            else {
+                invalidationPaths.push(...paths);
+            }
             if (invalidationPaths.length === 0)
-                invalidationPaths.push("/*");
+                return;
             // Build build ID
-            const hash = crypto.createHash("md5");
-            cachedS3Files.forEach((item) => {
-                // The below options are needed to support following symlinks when building zip files:
-                // - nodir: This will prevent symlinks themselves from being copied into the zip.
-                // - follow: This will follow symlinks and copy the files within.
-                // For versioned files, use file path for digest since file version in name should change on content change
-                if (item.versionedSubDir) {
-                    globSync("**", {
-                        dot: true,
-                        nodir: true,
-                        follow: true,
-                        cwd: path.resolve(sitePath, item.from, item.versionedSubDir),
-                    }).forEach((filePath) => hash.update(filePath));
-                }
-                // For non-versioned files, use file content for digest
-                if (cdnInvalidationStrategy === "all") {
-                    globSync("**", {
-                        ignore: item.versionedSubDir
-                            ? [path.posix.join(item.versionedSubDir, "**")]
-                            : undefined,
-                        dot: true,
-                        nodir: true,
-                        follow: true,
-                        cwd: path.resolve(sitePath, item.from),
-                    }).forEach((filePath) => hash.update(fs.readFileSync(path.resolve(sitePath, item.from, filePath))));
-                }
+            let invalidationBuildId;
+            if (plan.buildId) {
+                invalidationBuildId = plan.buildId;
+            }
+            else {
+                const hash = crypto.createHash("md5");
+                cachedS3Files.forEach((item) => {
+                    // The below options are needed to support following symlinks when building zip files:
+                    // - nodir: This will prevent symlinks themselves from being copied into the zip.
+                    // - follow: This will follow symlinks and copy the files within.
+                    // For versioned files, use file path for digest since file version in name should change on content change
+                    if (item.versionedSubDir) {
+                        globSync("**", {
+                            dot: true,
+                            nodir: true,
+                            follow: true,
+                            cwd: path.resolve(sitePath, item.from, item.versionedSubDir),
+                        }).forEach((filePath) => hash.update(filePath));
+                    }
+                    // For non-versioned files, use file content for digest
+                    if (paths !== "versioned") {
+                        globSync("**", {
+                            ignore: item.versionedSubDir
+                                ? [path.posix.join(item.versionedSubDir, "**")]
+                                : undefined,
+                            dot: true,
+                            nodir: true,
+                            follow: true,
+                            cwd: path.resolve(sitePath, item.from),
+                        }).forEach((filePath) => hash.update(fs.readFileSync(path.resolve(sitePath, item.from, filePath))));
+                    }
+                });
+                invalidationBuildId = hash.digest("hex");
+                Logger.debug(`Generated build ID ${invalidationBuildId}`);
+            }
+            distribution.createInvalidation({
+                version: invalidationBuildId,
+                paths: invalidationPaths,
+                wait: invalidation.wait,
             });
-            const buildId = hash.digest("hex");
-            Logger.debug(`Generated build ID ${buildId}`);
-            distribution.createInvalidation(buildId, invalidationPaths);
         }
     }
     static buildDefaultServerCachePolicyProps(allowedHeaders) {

package/constructs/StaticSite.js

@@ -49,7 +49,6 @@ export class StaticSite extends Construct {
         this.id = id;
         this.props = {
             path: ".",
-            waitForInvalidation: false,
             ...props,
         };
         this.doNotDeploy =
@@ -74,7 +73,9 @@ export class StaticSite extends Construct {
             const s3deployCR = this.createS3Deployment(assets, filenamesAsset);
             this.distribution.node.addDependency(s3deployCR);
             // Invalidate CloudFront
-            this.distribution.createInvalidation(this.generateInvalidationId(assets));
+            this.distribution.createInvalidation({
+                version: this.generateInvalidationId(assets),
+            });
         });
         app.registerTypes(this);
     }

package/package.json

@@ -1,7 +1,7 @@
 {
   "sideEffects": false,
   "name": "sst",
-  "version": "2.31.0",
+  "version": "2.32.1",
   "bin": {
     "sst": "cli/sst.js"
   },
@@ -120,7 +120,7 @@
     "@types/ws": "^8.5.3",
     "@types/yargs": "^17.0.13",
     "archiver": "^5.3.1",
-    "astro-sst": "2.31.0",
+    "astro-sst": "2.32.1",
     "async": "^3.2.4",
     "tsx": "^3.12.1",
     "typescript": "^5.2.2",