sst 2.29.0 → 2.30.1

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.0",
+  "version": "2.30.1",
   "bin": {
     "sst": "cli/sst.js"
   },
@@ -87,7 +87,7 @@
     "ora": "^6.1.2",
     "react": "18.2.0",
     "remeda": "^1.3.0",
-    "sst-aws-cdk": "2.91.0",
+    "sst-aws-cdk": "2.95.1",
     "tree-kill": "^1.2.2",
     "undici": "^5.12.0",
     "uuid": "^9.0.0",
@@ -119,7 +119,7 @@
     "@types/ws": "^8.5.3",
     "@types/yargs": "^17.0.13",
     "archiver": "^5.3.1",
-    "astro-sst": "2.29.0",
+    "astro-sst": "2.30.1",
     "tsx": "^3.12.1",
     "typescript": "^5.2.2",
     "vitest": "^0.33.0"