sst 2.29.2 → 2.30.2

package/cli/commands/types.js

@@ -8,10 +8,20 @@ export const types = (program) => program.command("types", "Generate resource ty
     try {
         const project = useProject();
         const [_metafile, sstConfig] = await Stacks.load(project.paths.config);
-        await Stacks.synth({
-            fn: sstConfig.stacks,
+        // Note: do not run synth which requires AWS credentials. B/c generating
+        //       types is usually done inside CI pipelines. And credentials
+        //       might not be available. ie.
+        //  await Stacks.synth({
+        //    fn: sstConfig.stacks,
+        //    mode: "remove",
+        //  });
+        const app = new App({
             mode: "remove",
+            stage: project.config.stage,
+            name: project.config.name,
+            region: project.config.region,
         });
+        sstConfig.stacks(app);
         Colors.line(Colors.success(`✔ `), `Types generated in ${path.resolve(project.paths.out, "types")}`);
         await exit();
     }

package/constructs/BaseSite.d.ts

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

package/constructs/Distribution.d.ts

@@ -132,7 +132,7 @@ export declare class Distribution extends Construct {
         hostedZone: IHostedZone | undefined;
         certificate: ICertificate | undefined;
     };
-    createInvalidation(buildId?: string): CustomResource;
+    createInvalidation(buildId?: string, paths?: string[]): CustomResource;
     private validateCloudFrontDistributionSettings;
     private validateCustomDomainSettings;
     private lookupHostedZone;

package/constructs/Distribution.js

@@ -70,7 +70,7 @@ export class Distribution extends Construct {
             certificate: this.certificate,
         };
     }
-    createInvalidation(buildId) {
+    createInvalidation(buildId, paths) {
         const stack = Stack.of(this);
         const policy = new Policy(this.scope, "CloudFrontInvalidatorPolicy", {
             statements: [
@@ -93,7 +93,7 @@ export class Distribution extends Construct {
             properties: {
                 buildId: buildId || Date.now().toString(),
                 distributionId: this.distribution.distributionId,
-                paths: ["/*"],
+                paths: paths ?? ["/*"],
                 waitForInvalidation: this.props.waitForInvalidation,
             },
         });

package/constructs/NextjsSite.d.ts

@@ -3,7 +3,17 @@ import { Runtime, FunctionProps, Architecture } from "aws-cdk-lib/aws-lambda";
 import { SsrSite, SsrSiteNormalizedProps, SsrSiteProps } from "./SsrSite.js";
 import { Size } from "./util/size.js";
 import { Bucket } from "aws-cdk-lib/aws-s3";
+import { CachePolicyProps } from "aws-cdk-lib/aws-cloudfront";
 export interface NextjsSiteProps extends Omit<SsrSiteProps, "nodejs"> {
+    /**
+     * OpenNext version for building the Next.js site.
+     * @default Latest OpenNext version
+     * @example
+     * ```js
+     * openNextVersion: "2.2.4",
+     * ```
+     */
+    openNextVersion?: string;
     imageOptimization?: {
         /**
          * The amount of memory in MB allocated for image optimization function.
@@ -99,8 +109,8 @@ type NextjsSiteNormalizedProps = NextjsSiteProps & SsrSiteNormalizedProps;
  */
 export declare class NextjsSite extends SsrSite {
     props: NextjsSiteNormalizedProps;
-    private buildId?;
     constructor(scope: Construct, id: string, props?: NextjsSiteProps);
+    static buildDefaultServerCachePolicyProps(): CachePolicyProps;
     protected plan(bucket: Bucket): {
         cloudFrontFunctions?: {
             serverCfFunction: {

package/constructs/NextjsSite.js

@@ -12,6 +12,14 @@ import { toCdkSize } from "./util/size.js";
 import { PolicyStatement } from "aws-cdk-lib/aws-iam";
 import { RetentionDays } from "aws-cdk-lib/aws-logs";
 import { VisibleError } from "../error.js";
+const DEFAULT_OPEN_NEXT_VERSION = "2.2.4";
+const DEFAULT_CACHE_POLICY_ALLOWED_HEADERS = [
+    "accept",
+    "rsc",
+    "next-router-prefetch",
+    "next-router-state-tree",
+    "next-url",
+];
 /**
  * The `NextjsSite` construct is a higher level CDK construct that makes it easy to create a Next.js app.
  * @example
@@ -24,7 +32,6 @@ import { VisibleError } from "../error.js";
  * ```
  */
 export class NextjsSite extends SsrSite {
-    buildId;
     constructor(scope, id, props) {
         const { streaming, disableDynamoDBCache, disableIncrementalCache } = {
             streaming: false,
@@ -34,7 +41,10 @@ export class NextjsSite extends SsrSite {
         };
         super(scope, id, {
             buildCommand: [
-                "npx --yes open-next@2.2.3 build",
+                "npx",
+                "--yes",
+                `open-next@${props?.openNextVersion ?? DEFAULT_OPEN_NEXT_VERSION}`,
+                "build",
                 ...(streaming ? ["--streaming"] : []),
                 ...(disableDynamoDBCache
                     ? ["--dangerously-disable-dynamodb-cache"]
@@ -52,6 +62,9 @@ export class NextjsSite extends SsrSite {
             }
         }
     }
+    static buildDefaultServerCachePolicyProps() {
+        return super.buildDefaultServerCachePolicyProps(DEFAULT_CACHE_POLICY_ALLOWED_HEADERS);
+    }
     plan(bucket) {
         const { path: sitePath, edge, experimental, imageOptimization, } = this.props;
         const serverConfig = {
@@ -184,13 +197,7 @@ export class NextjsSite extends SsrSite {
                     origin: "s3",
                 })),
             ],
-            cachePolicyAllowedHeaders: [
-                "accept",
-                "rsc",
-                "next-router-prefetch",
-                "next-router-state-tree",
-                "next-url",
-            ],
+            cachePolicyAllowedHeaders: DEFAULT_CACHE_POLICY_ALLOWED_HEADERS,
             buildId: this.getBuildId(),
             warmerConfig: {
                 function: path.join(sitePath, ".open-next", "warmer-function"),
@@ -287,15 +294,22 @@ export class NextjsSite extends SsrSite {
         };
     }
     wrapHandler() {
-        const { path: sitePath } = this.props;
+        const { path: sitePath, experimental } = this.props;
         const wrapperName = "nextjssite-index";
         const serverPath = path.join(sitePath, ".open-next", "server-function");
-        fs.writeFileSync(path.join(serverPath, `${wrapperName}.mjs`), [
-            `import { handler as rawHandler } from "./index.mjs";`,
-            `export const handler = (event, context) => {`,
-            `  return rawHandler(event, context);`,
-            `};`,
-        ].join("\n"));
+        fs.writeFileSync(path.join(serverPath, `${wrapperName}.mjs`), experimental?.streaming
+            ? [
+                `export const handler = awslambda.streamifyResponse(async (...args) => {`,
+                `  const { handler: rawHandler} = await import("./index.mjs");`,
+                `  return rawHandler(...args);`,
+                `});`,
+            ].join("\n")
+            : [
+                `export const handler = async (...args) => {`,
+                `  const { handler: rawHandler} = await import("./index.mjs");`,
+                `  return rawHandler(...args);`,
+                `};`,
+            ].join("\n"));
         return `${wrapperName}.handler`;
     }
     getRoutes() {

package/constructs/Script.d.ts

@@ -51,8 +51,7 @@ export interface ScriptProps {
         function?: FunctionProps;
     };
     /**
-     * Creates the function that runs when the Script is created.
-     *
+     * Specifies the function to be run once when the Script construct is created.
      * @example
      * ```js
      * new Script(stack, "Api", {
@@ -62,8 +61,11 @@ export interface ScriptProps {
      */
     onCreate?: FunctionDefinition;
     /**
-     * Creates the function that runs on every deploy after the Script is created
+     * Specifies the function to be run each time the Script construct is redeployed. If a version is provided,
+     * the function is only executed when the version changes.
      *
+     * Note that the `onUpdate` function is not run during the initial creation of the Script construct.
+     * For initial creation, use `onCreate`.
      * @example
      * ```js
      * new Script(stack, "Api", {
@@ -73,8 +75,8 @@ export interface ScriptProps {
      */
     onUpdate?: FunctionDefinition;
     /**
-     * Create the function that runs when the Script is deleted from the stack.
-     *
+     * Specifies the function to be run once when the Script construct is deleted from the stack or
+     * when the entire stack is removed from the app.
      * @example
      * ```js
      * new Script(stack, "Api", {

package/constructs/SsrSite.d.ts

@@ -1,14 +1,14 @@
 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, ErrorResponse } from "aws-cdk-lib/aws-cloudfront";
+import { ICachePolicy, IResponseHeadersPolicy, 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";
 import { NodeJSProps, FunctionProps } from "./Function.js";
 import { SsrFunction, SsrFunctionProps } from "./SsrFunction.js";
 import { EdgeFunction, EdgeFunctionProps } from "./EdgeFunction.js";
-import { BaseSiteFileOptions, BaseSiteReplaceProps, BaseSiteCdkDistributionProps } from "./BaseSite.js";
+import { BaseSiteFileOptions, BaseSiteFileOptionsDeprecated, BaseSiteReplaceProps, BaseSiteCdkDistributionProps } from "./BaseSite.js";
 import { Size } from "./util/size.js";
 import { Duration } from "./util/duration.js";
 import { Permissions } from "./util/permission.js";
@@ -54,6 +54,8 @@ export interface SsrDomainProps extends DistributionDomainProps {
 }
 export interface SsrSiteFileOptions extends BaseSiteFileOptions {
 }
+export interface SsrSiteFileOptionsDeprecated extends BaseSiteFileOptionsDeprecated {
+}
 export interface SsrSiteReplaceProps extends BaseSiteReplaceProps {
 }
 export interface SsrCdkDistributionProps extends BaseSiteCdkDistributionProps {
@@ -202,6 +204,93 @@ export interface SsrSiteProps {
          */
         url?: string;
     };
+    cache?: {
+        /**
+         * Character encoding for text based assets stored in the S3 cache (ex: html, css, js, etc.). If "none" is specified, no charset will be returned in header.
+         * @default utf-8
+         * @example
+         * ```js
+         * cache: {
+         *  textEncoding: "iso-8859-1"
+         * }
+         * ```
+         */
+        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
+         * cache: {
+         *   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
+         * @example
+         * ```js
+         * cache: {
+         *  versionedFilesTTL: "30 days"
+         * }
+         * ```
+         */
+        versionedFilesTTL?: number | Duration;
+        /**
+         * The header to use for versioned files (ex: `main-1234.css`) in the CDN cache. When specified, the `versionedFilesTTL` option is ignored.
+         * @default public,max-age=31536000,immutable
+         * @example
+         * ```js
+         * cache: {
+         *   versionedFilesCacheHeader: "public,max-age=31536000,immutable"
+         * }
+         * ```
+         */
+        versionedFilesCacheHeader?: string;
+        /**
+         * The TTL for non-versioned files (ex: `index.html`) in the CDN cache. Ignored when `nonVersionedFilesCacheHeader` is specified.
+         * @default 1 day
+         * @example
+         * ```js
+         * cache: {
+         *  nonVersionedFilesTTL: "4 hours"
+         * }
+         * ```
+         */
+        nonVersionedFilesTTL?: number | Duration;
+        /**
+         * The header to use for non-versioned files (ex: `index.html`) in the CDN cache. When specified, the `nonVersionedFilesTTL` option is ignored.
+         * @default public,max-age=0,s-maxage=86400,stale-while-revalidate=8640
+         * @example
+         * ```js
+         * cache: {
+         *   nonVersionedFilesCacheHeader: "public,max-age=0,no-cache"
+         * }
+         * ```
+         */
+        nonVersionedFilesCacheHeader?: string;
+        /**
+         * List of file options to specify cache control and content type for cached files. These file options are appended to the default file options so it's possible to override the default file options by specifying an overlapping file pattern.
+         * @example
+         * ```js
+         * cache: {
+         *   fileOptions: [
+         *     {
+         *       filters: [ { exclude: "*" }, { include: "*.zip" } ],
+         *       cacheControl: "private,no-cache,no-store,must-revalidate",
+         *       contentType: "application/zip",
+         *     },
+         *   ],
+         * }
+         */
+        fileOptions?: SsrSiteFileOptions[];
+    };
     /**
      * 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
@@ -251,11 +340,11 @@ export interface SsrSiteProps {
         server?: Pick<CdkFunctionProps, "layers" | "vpc" | "vpcSubnets" | "securityGroups" | "allowAllOutbound" | "allowPublicSubnet" | "architecture" | "logRetention"> & Pick<FunctionProps, "copyFiles">;
     };
     /**
-     * Pass in a list of file options to customize cache control and content type specific files.
-     *
+     * Pass in a list of file options to customize cache control and content type specific files. Specifying file options will bypass all default file options and only use the ones specified. Most configurations within the `cache` prop will be ignored.
+     * @deprecated Use `cache.fileOptions` instead. Note that the `cache.fileOptions` are appended to default file options, not a replacement as this prop was.
      * @default
-     * Versioned files cached for 1 year at the CDN and brower level.
-     * Unversioned files cached for 1 year at the CDN level, but not at the browser level.
+     * Versioned files cached for 1 year at the CDN and browser level.
+     * Nonversioned files cached for 1 day at the CDN level, but not at the browser level.
      * ```js
      * fileOptions: [
      *   {
@@ -301,9 +390,8 @@ export interface SsrSiteProps {
      *     cacheControl: "public,max-age=0,s-maxage=31536000,must-revalidate",
      *   },
      * ]
-     * ```
      */
-    fileOptions?: SsrSiteFileOptions[];
+    fileOptions?: SsrSiteFileOptionsDeprecated[];
 }
 export type SsrSiteNormalizedProps = SsrSiteProps & {
     path: Exclude<SsrSiteProps["path"], undefined>;
@@ -333,6 +421,7 @@ export declare abstract class SsrSite extends Construct implements SSTConstruct
     private serverFunctionForDev?;
     private distribution;
     constructor(scope: Construct, id: string, rawProps?: SsrSiteProps);
+    protected static buildDefaultServerCachePolicyProps(allowedHeaders: string[]): CachePolicyProps;
     /**
      * The CloudFront URL of the website.
      */

package/constructs/SsrSite.js

@@ -67,7 +67,7 @@ export class SsrSite extends Construct {
         const app = scope.node.root;
         const stack = Stack.of(this);
         const self = this;
-        const { path: sitePath, typesPath, buildCommand, runtime, timeout, memorySize, edge, regional, dev, nodejs, permissions, environment, bind, customDomain, waitForInvalidation, fileOptions, warm, cdk, } = props;
+        const { path: sitePath, typesPath, buildCommand, runtime, timeout, memorySize, edge, regional, dev, cache, nodejs, permissions, environment, bind, customDomain, waitForInvalidation, fileOptions, warm, cdk, } = props;
         this.doNotDeploy = !stack.isActive || (app.mode === "dev" && !dev?.deploy);
         validateSiteExists();
         validateTimeout();
@@ -96,7 +96,7 @@ export class SsrSite extends Construct {
         const edgeFunctions = createEdgeFunctions();
         const origins = createOrigins();
         const distribution = createCloudFrontDistribution();
-        distribution.createInvalidation(plan.buildId ?? generateBuildId());
+        createDistributionInvalidation();
         // Create Warmer
         createWarmer();
         this.bucket = bucket;
@@ -411,7 +411,7 @@ function handler(event) {
                 originPath: "/" + (props.originPath ?? ""),
             });
             const assets = createS3OriginAssets(props.copy);
-            const assetFileOptions = fileOptions || createS3OriginAssetFileOptions(props.copy);
+            const assetFileOptions = fileOptions || createS3OriginAssetFileOptions(props.copy, cache);
             const s3deployCR = createS3OriginDeployment(assets, assetFileOptions);
             s3DeployCRs.push(s3deployCR);
             return s3Origin;
@@ -562,27 +562,122 @@ function handler(event) {
             }
             return assets;
         }
-        function createS3OriginAssetFileOptions(copy) {
+        function createS3OriginAssetFileOptions(copy, cache) {
             const fileOptions = [];
-            for (const files of copy) {
+            const textEncoding = cache?.textEncoding ?? "UTF-8";
+            const nonVersionedFilesTTL = typeof cache?.nonVersionedFilesTTL === "number"
+                ? cache.nonVersionedFilesTTL
+                : toCdkDuration(cache?.nonVersionedFilesTTL ?? "1 day").toSeconds();
+            const staleWhileRevalidateTTL = Math.max(Math.floor(nonVersionedFilesTTL / 10), 30);
+            const nonVersionedFilesCacheHeader = cache?.nonVersionedFilesCacheHeader ??
+                `public,max-age=0,s-maxage=${nonVersionedFilesTTL},stale-while-revalidate=${staleWhileRevalidateTTL}`;
+            const versionedFilesTTL = typeof cache?.versionedFilesTTL === "number"
+                ? cache.versionedFilesTTL
+                : toCdkDuration(cache?.versionedFilesTTL ?? "365 days").toSeconds();
+            const versionedFilesCacheHeader = cache?.versionedFilesCacheHeader ??
+                `public,max-age=${versionedFilesTTL},immutable`;
+            const commonWebFileExtensions = {
+                txt: { mime: "text/plain", isText: true },
+                htm: { mime: "text/html", isText: true },
+                html: { mime: "text/html", isText: true },
+                xhtml: { mime: "application/xhtml+xml", isText: true },
+                css: { mime: "text/css", isText: true },
+                js: { mime: "text/javascript", isText: true },
+                mjs: { mime: "text/javascript", isText: true },
+                apng: { mime: "image/apng", isText: false },
+                avif: { mime: "image/avif", isText: false },
+                gif: { mime: "image/gif", isText: false },
+                jpeg: { mime: "image/jpeg", isText: false },
+                jpg: { mime: "image/jpeg", isText: false },
+                png: { mime: "image/png", isText: false },
+                svg: { mime: "image/svg+xml", isText: true },
+                bmp: { mime: "image/bmp", isText: false },
+                tiff: { mime: "image/tiff", isText: false },
+                webp: { mime: "image/webp", isText: false },
+                ico: { mime: "image/vnd.microsoft.icon", isText: false },
+                eot: { mime: "application/vnd.ms-fontobject", isText: false },
+                ttf: { mime: "font/ttf", isText: false },
+                otf: { mime: "font/otf", isText: false },
+                woff: { mime: "font/woff", isText: false },
+                woff2: { mime: "font/woff2", isText: false },
+                json: { mime: "application/json", isText: true },
+                jsonld: { mime: "application/ld+json", isText: true },
+                xml: { mime: "application/xml", isText: true },
+                pdf: { mime: "application/pdf", isText: false },
+                zip: { mime: "application/zip", isText: false },
+            };
+            copy.forEach((files) => {
                 if (!files.cached)
-                    continue;
-                const filesPath = path.join(sitePath, files.from);
-                for (const item of fs.readdirSync(filesPath)) {
-                    const itemPath = path.join(filesPath, item);
-                    const isDir = fs.statSync(itemPath).isDirectory();
+                    return;
+                for (const [extension, contentType] of Object.entries(commonWebFileExtensions)) {
+                    // Create a file option for: common extension + unversioned files
+                    fileOptions.push({
+                        filters: [
+                            { exclude: "*" },
+                            { include: `${path.posix.join(files.to, "*")}.${extension}` },
+                            ...(files.versionedSubDir
+                                ? [
+                                    {
+                                        exclude: path.posix.join(files.to, files.versionedSubDir, "*"),
+                                    },
+                                ]
+                                : []),
+                        ],
+                        cacheControl: nonVersionedFilesCacheHeader,
+                        contentType: `${contentType.mime}${contentType.isText && textEncoding !== "none"
+                            ? `;charset=${textEncoding}`
+                            : ""}`,
+                    });
+                    // Create a file option for: common extension + versioned files
+                    if (files.versionedSubDir) {
+                        fileOptions.push({
+                            filters: [
+                                { exclude: "*" },
+                                {
+                                    include: path.posix.join(files.to, files.versionedSubDir, `*.${extension}`),
+                                },
+                            ],
+                            cacheControl: versionedFilesCacheHeader,
+                            contentType: `${contentType.mime}${contentType.isText && textEncoding !== "none"
+                                ? `;charset=${textEncoding}`
+                                : ""}`,
+                        });
+                    }
+                }
+                // Create a file option for: other extensions + unversioned files
+                fileOptions.push({
+                    filters: [
+                        { include: "*" },
+                        ...(files.versionedSubDir
+                            ? [
+                                {
+                                    exclude: path.posix.join(files.to, files.versionedSubDir, "*"),
+                                },
+                            ]
+                            : []),
+                        ...Object.entries(commonWebFileExtensions).map(([ext]) => ({
+                            exclude: `*.${ext}`,
+                        })),
+                    ],
+                    cacheControl: nonVersionedFilesCacheHeader,
+                });
+                // Create a file option for: other extensions + versioned files
+                if (files.versionedSubDir) {
                     fileOptions.push({
-                        exclude: "*",
-                        include: path.posix.join(files.to, item, isDir ? "*" : ""),
-                        cacheControl: item === files.versionedSubDir
-                            ? // Versioned files will be cached for 1 year (immutable) both at
-                                // the CDN and browser level.
-                                "public,max-age=31536000,immutable"
-                            : // Un-versioned files will be cached for 1 year at the CDN level.
-                                // But not at the browser level. CDN cache will be invalidated on deploy.
-                                "public,max-age=0,s-maxage=31536000,must-revalidate",
+                        filters: [
+                            {
+                                include: path.posix.join(files.to, files.versionedSubDir, "*"),
+                            },
+                            ...Object.entries(commonWebFileExtensions).map(([ext]) => ({
+                                exclude: `*.${ext}`,
+                            })),
+                        ],
+                        cacheControl: versionedFilesCacheHeader,
                     });
                 }
+            });
+            if (cache?.fileOptions) {
+                fileOptions.push(...cache.fileOptions);
             }
             return fileOptions;
         }
@@ -622,18 +717,25 @@ function handler(event) {
                         ObjectKey: asset.s3ObjectKey,
                     })),
                     DestinationBucketName: bucket.bucketName,
-                    FileOptions: (fileOptions || []).map(({ exclude, include, cacheControl, contentType }) => {
-                        if (typeof exclude === "string") {
-                            exclude = [exclude];
-                        }
-                        if (typeof include === "string") {
-                            include = [include];
-                        }
+                    FileOptions: (fileOptions || []).map((o) => {
+                        const { filters, cacheControl, contentType, contentEncoding } = o;
+                        const { include, exclude } = o;
                         return [
-                            ...exclude.map((per) => ["--exclude", per]),
-                            ...include.map((per) => ["--include", per]),
-                            ["--cache-control", cacheControl],
+                            ...(typeof exclude === "string" ? [exclude] : exclude ?? [])
+                                .map((entry) => ["--exclude", entry])
+                                .flat(2),
+                            ...(typeof include === "string" ? [include] : include ?? [])
+                                .map((entry) => ["--include", entry])
+                                .flat(2),
+                            ...(filters || [])
+                                .map((filter) => Object.entries(filter).map(([key, value]) => [
+                                `--${key}`,
+                                value,
+                            ]))
+                                .flat(2),
+                            cacheControl ? ["--cache-control", cacheControl] : [],
                             contentType ? ["--content-type", contentType] : [],
+                            contentEncoding ? ["--content-encoding", contentEncoding] : [],
                         ].flat();
                     }),
                     ReplaceValues: getS3ContentReplaceValues(),
@@ -656,19 +758,7 @@ function handler(event) {
             const allowedHeaders = plan.cachePolicyAllowedHeaders || [];
             singletonCachePolicy =
                 singletonCachePolicy ??
-                    new CachePolicy(self, "ServerCache", {
-                        queryStringBehavior: CacheQueryStringBehavior.all(),
-                        headerBehavior: allowedHeaders.length > 0
-                            ? CacheHeaderBehavior.allowList(...allowedHeaders)
-                            : CacheHeaderBehavior.none(),
-                        cookieBehavior: CacheCookieBehavior.none(),
-                        defaultTtl: CdkDuration.days(0),
-                        maxTtl: CdkDuration.days(365),
-                        minTtl: CdkDuration.days(0),
-                        enableAcceptEncodingBrotli: true,
-                        enableAcceptEncodingGzip: true,
-                        comment: "SST server response cache policy",
-                    });
+                    new CachePolicy(self, "ServerCache", SsrSite.buildDefaultServerCachePolicyProps(allowedHeaders));
             return singletonCachePolicy;
         }
         function useServerBehaviorOriginRequestPolicy() {
@@ -705,34 +795,91 @@ function handler(event) {
             });
             return replaceValues;
         }
-        function generateBuildId() {
+        function createDistributionInvalidation() {
+            const cdnInvalidationStrategy = cache?.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;
+            }
             // 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");
             if (s3Origin?.type !== "s3")
-                return "unchanged";
-            const cachedS3Files = s3Origin.copy.find((item) => item.cached);
-            if (!cachedS3Files)
-                return "unchanged";
-            // 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.
-            const globOptions = {
-                dot: true,
-                nodir: true,
-                follow: true,
-                cwd: path.resolve(sitePath, cachedS3Files.from),
-            };
-            const files = glob.sync("**", globOptions);
-            const hash = crypto.createHash("sha1");
-            for (const file of files) {
-                hash.update(file);
+                return;
+            const cachedS3Files = s3Origin.copy.filter((file) => file.cached);
+            if (cachedS3Files.length === 0)
+                return;
+            // Build invalidation paths
+            const invalidationPaths = [];
+            if (cdnInvalidationStrategy === "versioned") {
+                cachedS3Files.forEach((item) => {
+                    if (!item.versionedSubDir)
+                        return;
+                    invalidationPaths.push(path.posix.join("/", item.to, item.versionedSubDir, "*"));
+                });
             }
+            if (invalidationPaths.length === 0)
+                invalidationPaths.push("/*");
+            // 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.
+                const globOptions = {
+                    dot: true,
+                    nodir: true,
+                    follow: true,
+                    cwd: path.resolve(sitePath, item.from),
+                };
+                // For versioned files, use file path for digest since file version in name should change on content change
+                if (item.versionedSubDir) {
+                    glob
+                        .sync("**", {
+                        ...globOptions,
+                        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") {
+                    glob
+                        .sync("**", {
+                        ...globOptions,
+                        ignore: item.versionedSubDir
+                            ? [path.posix.join(item.versionedSubDir, "**")]
+                            : undefined,
+                    })
+                        .forEach((filePath) => hash.update(fs.readFileSync(path.resolve(sitePath, item.from, filePath))));
+                }
+            });
             const buildId = hash.digest("hex");
             Logger.debug(`Generated build ID ${buildId}`);
-            return buildId;
+            distribution.createInvalidation(buildId, invalidationPaths);
         }
     }
+    static buildDefaultServerCachePolicyProps(allowedHeaders) {
+        return {
+            queryStringBehavior: CacheQueryStringBehavior.all(),
+            headerBehavior: allowedHeaders.length > 0
+                ? CacheHeaderBehavior.allowList(...allowedHeaders)
+                : CacheHeaderBehavior.none(),
+            cookieBehavior: CacheCookieBehavior.none(),
+            defaultTtl: CdkDuration.days(0),
+            maxTtl: CdkDuration.days(365),
+            minTtl: CdkDuration.days(0),
+            enableAcceptEncodingBrotli: true,
+            enableAcceptEncodingGzip: true,
+            comment: "SST server response cache policy",
+        };
+    }
     /**
      * The CloudFront URL of the website.
      */

package/constructs/StaticSite.d.ts

@@ -2,7 +2,7 @@ import { Construct } from "constructs";
 import { Bucket, BucketProps, IBucket } from "aws-cdk-lib/aws-s3";
 import { IDistribution } from "aws-cdk-lib/aws-cloudfront";
 import { DistributionDomainProps } from "./Distribution.js";
-import { BaseSiteFileOptions, BaseSiteReplaceProps, BaseSiteCdkDistributionProps } from "./BaseSite.js";
+import { BaseSiteFileOptions, BaseSiteReplaceProps, BaseSiteCdkDistributionProps, BaseSiteFileOptionsDeprecated } from "./BaseSite.js";
 import { SSTConstruct } from "./Construct.js";
 import { FunctionBindingProps } from "./util/functionBinding.js";
 export interface StaticSiteProps {
@@ -69,18 +69,15 @@ export interface StaticSiteProps {
     buildOutput?: string;
     /**
      * Pass in a list of file options to configure cache control for different files. Behind the scenes, the `StaticSite` construct uses a combination of the `s3 cp` and `s3 sync` commands to upload the website content to the S3 bucket. An `s3 cp` command is run for each file option block, and the options are passed in as the command options.
-     *
      * @default No cache control for HTML files, and a 1 year cache control for JS/CSS files.
      * ```js
      * [
      *   {
-     *     exclude: "*",
-     *     include: "*.html",
+     *     filters: [{ exclude: "*" }, { include: "*.html" }],
      *     cacheControl: "max-age=0,no-cache,no-store,must-revalidate",
      *   },
      *   {
-     *     exclude: "*",
-     *     include: ["*.js", "*.css"],
+     *     filters: [{ exclude: "*" }, { include: "*.js" }, { include: "*.css" }],
      *     cacheControl: "max-age=31536000,public,immutable",
      *   },
      * ]
@@ -90,14 +87,13 @@ export interface StaticSiteProps {
      * new StaticSite(stack, "Site", {
      *   buildOutput: "dist",
      *   fileOptions: [{
-     *     exclude: "*",
-     *     include: "*.js",
+     *     filters: [{ exclude: "*" }, { include: "*.js" }],
      *     cacheControl: "max-age=31536000,public,immutable",
      *   }]
      * });
      * ```
      */
-    fileOptions?: StaticSiteFileOptions[];
+    fileOptions?: StaticSiteFileOptions[] | StaticSiteFileOptionsDeprecated[];
     /**
      * Pass in a list of placeholder values to be replaced in the website content. For example, the follow configuration:
      *
@@ -269,6 +265,8 @@ export interface StaticSiteDomainProps extends DistributionDomainProps {
 }
 export interface StaticSiteFileOptions extends BaseSiteFileOptions {
 }
+export interface StaticSiteFileOptionsDeprecated extends BaseSiteFileOptionsDeprecated {
+}
 export interface StaticSiteReplaceProps extends BaseSiteReplaceProps {
 }
 export interface StaticSiteCdkDistributionProps extends BaseSiteCdkDistributionProps {

package/constructs/StaticSite.js

@@ -296,15 +296,13 @@ interface ImportMeta {
         }
     }
     createS3Deployment(cliLayer, assets, filenamesAsset) {
-        const fileOptions = this.props.fileOptions || [
+        const fileOptions = this.props.fileOptions ?? [
             {
-                exclude: "*",
-                include: "*.html",
+                filters: [{ exclude: "*" }, { include: "*.html" }],
                 cacheControl: "max-age=0,no-cache,no-store,must-revalidate",
             },
             {
-                exclude: "*",
-                include: ["*.js", "*.css"],
+                filters: [{ exclude: "*" }, { include: "*.js" }, { include: "*.css" }],
                 cacheControl: "max-age=31536000,public,immutable",
             },
         ];
@@ -348,18 +346,25 @@ interface ImportMeta {
                     BucketName: filenamesAsset.s3BucketName,
                     ObjectKey: filenamesAsset.s3ObjectKey,
                 },
-                FileOptions: (fileOptions || []).map(({ exclude, include, cacheControl, contentType }) => {
-                    if (typeof exclude === "string") {
-                        exclude = [exclude];
-                    }
-                    if (typeof include === "string") {
-                        include = [include];
-                    }
+                FileOptions: (fileOptions || []).map((o) => {
+                    const { filters, cacheControl, contentType, contentEncoding } = o;
+                    const { include, exclude } = o;
                     return [
-                        ...exclude.map((per) => ["--exclude", per]),
-                        ...include.map((per) => ["--include", per]),
-                        ["--cache-control", cacheControl],
+                        ...(typeof exclude === "string" ? [exclude] : exclude ?? [])
+                            .map((entry) => ["--exclude", entry])
+                            .flat(2),
+                        ...(typeof include === "string" ? [include] : include ?? [])
+                            .map((entry) => ["--include", entry])
+                            .flat(2),
+                        ...(filters || [])
+                            .map((filter) => Object.entries(filter).map(([key, value]) => [
+                            `--${key}`,
+                            value,
+                        ]))
+                            .flat(2),
+                        cacheControl ? ["--cache-control", cacheControl] : [],
                         contentType ? ["--content-type", contentType] : [],
+                        contentEncoding ? ["--content-encoding", contentEncoding] : [],
                     ].flat();
                 }),
                 ReplaceValues: this.getS3ContentReplaceValues(),

package/package.json

@@ -1,7 +1,7 @@
 {
   "sideEffects": false,
   "name": "sst",
-  "version": "2.29.2",
+  "version": "2.30.2",
   "bin": {
     "sst": "cli/sst.js"
   },
@@ -119,7 +119,7 @@
     "@types/ws": "^8.5.3",
     "@types/yargs": "^17.0.13",
     "archiver": "^5.3.1",
-    "astro-sst": "2.29.2",
+    "astro-sst": "2.30.2",
     "tsx": "^3.12.1",
     "typescript": "^5.2.2",
     "vitest": "^0.33.0"

package/runtime/handlers.js

@@ -13,6 +13,7 @@ import { useJavaHandler } from "./handlers/java.js";
 import { usePythonHandler } from "./handlers/python.js";
 import { useRustHandler } from "./handlers/rust.js";
 import { lazy } from "../util/lazy.js";
+import { Semaphore } from "../util/semaphore.js";
 export const useRuntimeHandlers = lazy(() => {
     const handlers = [
         useNodeHandler(),
@@ -104,9 +105,12 @@ export const useRuntimeHandlers = lazy(() => {
             const promise = task();
             pendingBuilds.set(functionID, promise);
             Logger.debug("Building function", functionID);
-            const r = await promise;
-            pendingBuilds.delete(functionID);
-            return r;
+            try {
+                return await promise;
+            }
+            finally {
+                pendingBuilds.delete(functionID);
+            }
         },
     };
     return result;
@@ -156,30 +160,3 @@ export const useFunctionBuilder = lazy(() => {
     });
     return result;
 });
-class Semaphore {
-    queue = [];
-    locked = 0;
-    maxLocks;
-    constructor(maxLocks = 1) {
-        this.maxLocks = maxLocks;
-    }
-    lock() {
-        return new Promise((resolve) => {
-            const unlock = () => {
-                this.locked--;
-                const next = this.queue.shift();
-                if (next) {
-                    this.locked++;
-                    next(unlock);
-                }
-            };
-            if (this.locked < this.maxLocks) {
-                this.locked++;
-                resolve(unlock);
-            }
-            else {
-                this.queue.push(unlock);
-            }
-        });
-    }
-}

package/stacks/synth.js

@@ -5,6 +5,8 @@ import * as contextproviders from "sst-aws-cdk/lib/context-providers/index.js";
 import path from "path";
 import { VisibleError } from "../error.js";
 import fs from "fs/promises";
+import { Semaphore } from "../util/semaphore.js";
+const sem = new Semaphore(1);
 export async function synth(opts) {
     Logger.debug("Synthesizing stacks...");
     const { App } = await import("../constructs/App.js");
@@ -13,6 +15,7 @@ export async function synth(opts) {
     const project = useProject();
     const cwd = process.cwd();
     process.chdir(project.paths.root);
+    const unlock = await sem.lock();
     try {
         return await synthInRoot();
     }
@@ -20,6 +23,7 @@ export async function synth(opts) {
         throw e;
     }
     finally {
+        unlock();
         process.chdir(cwd);
     }
     async function synthInRoot() {
@@ -30,15 +34,6 @@ export async function synth(opts) {
         };
         await fs.rm(opts.buildDir, { recursive: true, force: true });
         await fs.mkdir(opts.buildDir, { recursive: true });
-        /*
-      console.log(JSON.stringify(cfg.context));
-      const executable = new CloudExecutable({
-        sdkProvider: await useAWSProvider(),
-        configuration: cfg,
-        synthesizer: async () => app.synth() as any
-      });
-      const { assembly } = await executable.synthesize(true);
-      */
         const cfg = new Configuration();
         await cfg.load();
         let previous = new Set();

package/util/semaphore.d.ts

@@ -0,0 +1,7 @@
+export declare class Semaphore {
+    private queue;
+    private locked;
+    private maxLocks;
+    constructor(maxLocks?: number);
+    lock(): Promise<() => void>;
+}

package/util/semaphore.js

@@ -0,0 +1,27 @@
+export class Semaphore {
+    queue = [];
+    locked = 0;
+    maxLocks;
+    constructor(maxLocks = 1) {
+        this.maxLocks = maxLocks;
+    }
+    lock() {
+        return new Promise((resolve) => {
+            const unlock = () => {
+                this.locked--;
+                const next = this.queue.shift();
+                if (next) {
+                    this.locked++;
+                    next(unlock);
+                }
+            };
+            if (this.locked < this.maxLocks) {
+                this.locked++;
+                resolve(unlock);
+            }
+            else {
+                this.queue.push(unlock);
+            }
+        });
+    }
+}