sst 2.31.0 → 2.32.0

package/constructs/App.js

@@ -264,28 +264,28 @@ export class App extends CDKApp {
                     const functions = useFunctions();
                     const sourcemaps = functions.sourcemaps.forStack(child.stackName);
                     if (sourcemaps.length) {
-                        const policy = new Policy(child, "FunctionSourcemapUploaderPolicy", {
+                        const policy = new Policy(child, "SourcemapUploaderPolicy", {
                             statements: [
                                 new PolicyStatement({
                                     effect: Effect.ALLOW,
                                     actions: ["s3:GetObject", "s3:PutObject"],
                                     resources: [
-                                        sourcemaps[0].bucket.bucketArn + "/*",
+                                        sourcemaps[0].srcBucket.bucketArn + "/*",
                                         `arn:${child.partition}:s3:::${bootstrap.bucket}/*`,
                                     ],
                                 }),
                             ],
                         });
                         child.customResourceHandler.role?.attachInlinePolicy(policy);
-                        const resource = new CustomResource(child, "FunctionSourcemapUploader", {
+                        const resource = new CustomResource(child, "SourcemapUploader", {
                             serviceToken: child.customResourceHandler.functionArn,
-                            resourceType: "Custom::FunctionSourcemapUploader",
+                            resourceType: "Custom::SourcemapUploader",
                             properties: {
                                 app: this.name,
                                 stage: this.stage,
-                                bootstrap: bootstrap.bucket,
-                                bucket: sourcemaps[0].bucket.bucketName,
-                                functions: sourcemaps.map((s) => [s.func.functionArn, s.key]),
+                                tarBucket: bootstrap.bucket,
+                                srcBucket: sourcemaps[0].srcBucket.bucketName,
+                                sourcemaps: sourcemaps.map((s) => [s.tarKey, s.srcKey]),
                             },
                         });
                         resource.node.addDependency(policy);

package/constructs/Distribution.d.ts

@@ -94,15 +94,6 @@ export interface DistributionProps {
      * ```
      */
     customDomain?: string | DistributionDomainProps;
-    /**
-     * The SSR function is deployed to Lambda in a single region. Alternatively, you can enable this option to deploy to Lambda@Edge.
-     * @default false
-     */
-    /**
-     * 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
-     */
-    waitForInvalidation?: boolean;
     scopeOverride?: IConstruct;
     cdk: {
         distribution: CdkDistributionProps | IDistribution;
@@ -132,7 +123,11 @@ export declare class Distribution extends Construct {
         hostedZone: IHostedZone | undefined;
         certificate: ICertificate | undefined;
     };
-    createInvalidation(buildId?: string, paths?: string[]): CustomResource;
+    createInvalidation(props?: {
+        version?: string;
+        paths?: string[];
+        wait?: boolean;
+    }): CustomResource;
     private validateCloudFrontDistributionSettings;
     private validateCustomDomainSettings;
     private lookupHostedZone;

package/constructs/Distribution.js

@@ -70,7 +70,8 @@ export class Distribution extends Construct {
             certificate: this.certificate,
         };
     }
-    createInvalidation(buildId, paths) {
+    createInvalidation(props) {
+        const { version, paths, wait } = props ?? {};
         const stack = Stack.of(this);
         const policy = new Policy(this.scope, "CloudFrontInvalidatorPolicy", {
             statements: [
@@ -91,10 +92,11 @@ export class Distribution extends Construct {
             serviceToken: stack.customResourceHandler.functionArn,
             resourceType: "Custom::CloudFrontInvalidator",
             properties: {
-                buildId: buildId || Date.now().toString(),
+                version: version ||
+                    Date.now().toString(16) + Math.random().toString(16).slice(2),
                 distributionId: this.distribution.distributionId,
-                paths: paths ?? ["/*"],
-                waitForInvalidation: this.props.waitForInvalidation,
+                paths: [...new Set(paths ?? ["/*"])],
+                wait: wait ?? false,
             },
         });
         resource.node.addDependency(policy);

package/constructs/Function.d.ts

@@ -693,14 +693,14 @@ export declare class Function extends CDKFunction implements SSTConstruct {
 export declare const useFunctions: () => {
     sourcemaps: {
         add(stack: string, source: {
-            bucket: IBucket;
-            key: string;
-            func: Function;
+            srcBucket: IBucket;
+            srcKey: string;
+            tarKey: string;
         }): void;
         forStack(stack: string): {
-            bucket: IBucket;
-            key: string;
-            func: Function;
+            srcBucket: IBucket;
+            srcKey: string;
+            tarKey: string;
         }[];
     };
     fromID(id: string): FunctionProps | undefined;

package/constructs/Function.js

@@ -257,9 +257,9 @@ export class Function extends CDKFunction {
                     });
                     await fs.rm(result.sourcemap);
                     useFunctions().sourcemaps.add(stack.stackName, {
-                        bucket: asset.bucket,
-                        key: asset.s3ObjectKey,
-                        func: this,
+                        srcBucket: asset.bucket,
+                        srcKey: asset.s3ObjectKey,
+                        tarKey: this.functionArn,
                     });
                 }
                 // Update code

package/constructs/NextjsSite.d.ts

@@ -123,7 +123,11 @@ type NextjsSiteNormalizedProps = NextjsSiteProps & SsrSiteNormalizedProps;
  */
 export declare class NextjsSite extends SsrSite {
     props: NextjsSiteNormalizedProps;
-    private routes?;
+    private _routes?;
+    private routesManifest?;
+    private appPathRoutesManifest?;
+    private appPathsManifest?;
+    private pagesManifest?;
     constructor(scope: Construct, id: string, props?: NextjsSiteProps);
     static buildDefaultServerCachePolicyProps(): CachePolicyProps;
     protected plan(bucket: Bucket): {
@@ -335,10 +339,18 @@ export declare class NextjsSite extends SsrSite {
         };
     };
     private wrapServerFunction;
+    private removeSourcemaps;
     private useRoutes;
+    private useRoutesManifest;
+    private useAppPathRoutesManifest;
+    private useAppPathsManifest;
+    private usePagesManifest;
     private getBuildId;
+    private getSourcemapForAppRoute;
+    private getSourcemapForPagesRoute;
     private isPerRouteLoggingEnabled;
     private disableDefaultLogging;
+    private uploadSourcemaps;
     private static buildCloudWatchRouteName;
     private static buildCloudWatchRouteHash;
     static _test: {

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 =

package/constructs/SsrSite.d.ts

@@ -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?: {
@@ -343,13 +364,16 @@ export interface SsrSiteProps {
         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.