sst 2.30.4 → 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/BaseSite.d.ts

@@ -1,20 +1,9 @@
 import { ErrorResponse, DistributionProps, BehaviorOptions, IOrigin } from "aws-cdk-lib/aws-cloudfront";
-export interface BaseSiteFileOptionsFilter {
-    include?: string;
-    exclude?: string;
-}
 export interface BaseSiteFileOptions {
-    filters: BaseSiteFileOptionsFilter[];
-    cacheControl?: string;
-    contentType?: string;
-    contentEncoding?: string;
-}
-export interface BaseSiteFileOptionsDeprecated {
-    include?: string | string[];
-    exclude?: string | string[];
+    files: string | string[];
+    ignore?: string | string[];
     cacheControl?: string;
     contentType?: string;
-    contentEncoding?: string;
 }
 export interface BaseSiteEnvironmentOutputsInfo {
     path: string;

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

@@ -27,7 +27,7 @@ export interface NextjsSiteProps extends Omit<SsrSiteProps, "nodejs"> {
      * logging: "per-route",
      * ```
      */
-    _logging?: "combined" | "per-route";
+    logging?: "combined" | "per-route";
     imageOptimization?: {
         /**
          * The amount of memory in MB allocated for image optimization function.
@@ -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,7 +15,10 @@ 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";
-const LAYER_VERSION = "9";
+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 = [
     "accept",
@@ -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: {
@@ -305,14 +316,17 @@ export class NextjsSite extends SsrSite {
         };
     }
     wrapServerFunction(config) {
-        const { path: sitePath, experimental } = this.props;
+        const { path: sitePath, experimental, cdk } = this.props;
         const stack = Stack.of(this);
         const wrapperName = "nextjssite-index";
         const serverPath = path.join(sitePath, ".open-next", "server-function");
         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",
@@ -341,65 +355,194 @@ export class NextjsSite extends SsrSite {
             ...config,
             layers: this.isPerRouteLoggingEnabled()
                 ? [
-                    LayerVersion.fromLayerVersionArn(this, "SSTExtension", `arn:aws:lambda:${stack.region}:226609089145:layer:sst-extension:${LAYER_VERSION}`),
+                    LayerVersion.fromLayerVersionArn(this, "SSTExtension", cdk?.server?.architecture?.name === Architecture.X86_64.name
+                        ? `arn:aws:lambda:${stack.region}:226609089145:layer:sst-extension-amd64:${LAYER_VERSION}`
+                        : `arn:aws:lambda:${stack.region}:226609089145:layer:sst-extension-arm64:${LAYER_VERSION}`),
                 ]
                 : undefined,
             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 &&
-            this.props._logging === "per-route");
+            this.props.logging === "per-route");
     }
     disableDefaultLogging() {
+        // Note: keep default logs enabled
+        return;
         const stack = Stack.of(this);
         const server = this.serverFunction;
         const policy = new Policy(this, "DisableLoggingPolicy", {
@@ -420,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/RDS.js

@@ -1,5 +1,5 @@
 import path from "path";
-import glob from "glob";
+import { globSync } from "glob";
 import fs from "fs";
 import url from "url";
 import * as crypto from "crypto";
@@ -347,7 +347,7 @@ export class RDS extends Construct {
     }
     generateMigrationsHash(migrations) {
         // Get all files inside the migrations folder
-        const files = glob.sync("**", {
+        const files = globSync("**", {
             dot: true,
             nodir: true,
             follow: true,

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 =