sst 2.30.4 → 2.32.0

package/constructs/SsrSite.js

@@ -1,7 +1,7 @@
 import path from "path";
 import url from "url";
 import fs from "fs";
-import glob from "glob";
+import { globSync } from "glob";
 import crypto from "crypto";
 import spawn from "cross-spawn";
 import { execSync } from "child_process";
@@ -12,7 +12,6 @@ import { Effect, Role, Policy, PolicyStatement, AccountPrincipal, ServicePrincip
 import { Function as CdkFunction, Code, Runtime, FunctionUrlAuthType, InvokeMode, } from "aws-cdk-lib/aws-lambda";
 import { Asset } from "aws-cdk-lib/aws-s3-assets";
 import { ViewerProtocolPolicy, AllowedMethods, CachedMethods, LambdaEdgeEventType, CachePolicy, CacheQueryStringBehavior, CacheHeaderBehavior, CacheCookieBehavior, OriginRequestPolicy, Function as CfFunction, FunctionCode as CfFunctionCode, FunctionEventType as CfFunctionEventType, } from "aws-cdk-lib/aws-cloudfront";
-import { AwsCliLayer } from "aws-cdk-lib/lambda-layer-awscli";
 import { S3Origin, HttpOrigin, OriginGroup, } from "aws-cdk-lib/aws-cloudfront-origins";
 import { Rule, Schedule } from "aws-cdk-lib/aws-events";
 import { LambdaFunction } from "aws-cdk-lib/aws-events-targets";
@@ -56,21 +55,26 @@ export class SsrSite extends Construct {
         const props = {
             path: ".",
             typesPath: ".",
-            waitForInvalidation: false,
             runtime: "nodejs18.x",
             timeout: "10 seconds",
             memorySize: "1024 MB",
             ...rawProps,
+            invalidation: {
+                wait: rawProps?.waitForInvalidation,
+                paths: "all",
+                ...rawProps?.invalidation,
+            },
         };
         this.id = id;
         this.props = props;
         const app = scope.node.root;
         const stack = Stack.of(this);
         const self = this;
-        const { path: sitePath, typesPath, buildCommand, runtime, timeout, memorySize, edge, regional, dev, cache, nodejs, permissions, environment, bind, customDomain, waitForInvalidation, fileOptions, warm, cdk, } = props;
+        const { path: sitePath, typesPath, buildCommand, runtime, timeout, memorySize, edge, regional, dev, assets, nodejs, permissions, environment, bind, customDomain, invalidation, warm, cdk, } = props;
         this.doNotDeploy = !stack.isActive || (app.mode === "dev" && !dev?.deploy);
         validateSiteExists();
         validateTimeout();
+        validateDeprecatedFileOptions();
         writeTypesFile(typesPath);
         useSites().add(stack.stackName, id, this.constructor.name, props);
         if (this.doNotDeploy) {
@@ -82,7 +86,6 @@ export class SsrSite extends Construct {
         }
         let s3DeployCRs = [];
         let ssrFunctions = [];
-        let singletonAwsCliLayer;
         let singletonUrlSigner;
         let singletonCachePolicy;
         let singletonOriginRequestPolicy;
@@ -110,7 +113,7 @@ export class SsrSite extends Construct {
         app.registerTypes(this);
         function validateSiteExists() {
             if (!fs.existsSync(sitePath)) {
-                throw new Error(`No site found at "${path.resolve(sitePath)}"`);
+                throw new VisibleError(`No site found at "${path.resolve(sitePath)}"`);
             }
         }
         function validateTimeout() {
@@ -119,9 +122,15 @@ export class SsrSite extends Construct {
                 : toCdkDuration(timeout).toSeconds();
             const limit = edge ? 30 : 180;
             if (num > limit) {
-                throw new Error(edge
-                    ? `Timeout must be less than or equal to 30 seconds when the "edge" flag is enabled.`
-                    : `Timeout must be less than or equal to 180 seconds.`);
+                throw new VisibleError(edge
+                    ? `In the "${id}" construct, timeout must be less than or equal to 30 seconds when the "edge" flag is enabled.`
+                    : `In the "${id}" construct, timeout must be less than or equal to 180 seconds.`);
+            }
+        }
+        function validateDeprecatedFileOptions() {
+            // @ts-expect-error
+            if (props.fileOptions) {
+                throw new VisibleError(`In the "${id}" construct, the "fileOptions" property has been replaced by "assets.fileOptions". More details on upgrading - https://docs.sst.dev/upgrade-guide#upgrade-to-v2310`);
             }
         }
         function writeTypesFile(typesPath) {
@@ -254,7 +263,6 @@ export class SsrSite extends Construct {
             const distribution = new Distribution(self, "CDN", {
                 scopeOverride: self,
                 customDomain,
-                waitForInvalidation,
                 cdk: {
                     distribution: {
                         // these values can be overwritten
@@ -411,8 +419,7 @@ function handler(event) {
                 originPath: "/" + (props.originPath ?? ""),
             });
             const assets = createS3OriginAssets(props.copy);
-            const assetFileOptions = fileOptions || createS3OriginAssetFileOptions(props.copy, cache);
-            const s3deployCR = createS3OriginDeployment(assets, assetFileOptions);
+            const s3deployCR = createS3OriginDeployment(props.copy, assets);
             s3DeployCRs.push(s3deployCR);
             return s3Origin;
         }
@@ -562,185 +569,44 @@ function handler(event) {
             }
             return assets;
         }
-        function createS3OriginAssetFileOptions(copy, cache) {
-            const fileOptions = [];
-            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)
-                    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({
-                        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;
-        }
-        function createS3OriginDeployment(assets, fileOptions) {
-            // Create a Lambda function that will be doing the uploading
-            const uploader = new CdkFunction(self, "S3Uploader", {
-                code: Code.fromAsset(path.join(__dirname, "../support/base-site-custom-resource")),
-                layers: [useAwsCliLayer()],
-                runtime: Runtime.PYTHON_3_11,
-                handler: "s3-upload.handler",
-                timeout: CdkDuration.minutes(15),
-                memorySize: 1024,
-            });
-            bucket.grantReadWrite(uploader);
-            assets.forEach((asset) => asset.grantRead(uploader));
-            // Create the custom resource function
-            const handler = new CdkFunction(self, "S3Handler", {
-                code: Code.fromAsset(path.join(__dirname, "../support/base-site-custom-resource")),
-                layers: [useAwsCliLayer()],
-                runtime: Runtime.PYTHON_3_11,
-                handler: "s3-handler.handler",
-                timeout: CdkDuration.minutes(15),
-                memorySize: 1024,
-                environment: {
-                    UPLOADER_FUNCTION_NAME: uploader.functionName,
-                },
+        function createS3OriginDeployment(copy, s3Assets) {
+            const policy = new Policy(self, "S3UploaderPolicy", {
+                statements: [
+                    new PolicyStatement({
+                        effect: Effect.ALLOW,
+                        actions: ["lambda:InvokeFunction"],
+                        resources: [stack.customResourceHandler.functionArn],
+                    }),
+                    new PolicyStatement({
+                        effect: Effect.ALLOW,
+                        actions: ["s3:ListBucket", "s3:PutObject", "s3:DeleteObject"],
+                        resources: [bucket.bucketArn, `${bucket.bucketArn}/*`],
+                    }),
+                    new PolicyStatement({
+                        effect: Effect.ALLOW,
+                        actions: ["s3:GetObject"],
+                        resources: [`${s3Assets[0].bucket.bucketArn}/*`],
+                    }),
+                ],
             });
-            bucket.grantReadWrite(handler);
-            uploader.grantInvoke(handler);
-            // Create custom resource
-            return new CustomResource(self, "S3Deployment", {
-                serviceToken: handler.functionArn,
-                resourceType: "Custom::SSTBucketDeployment",
+            stack.customResourceHandler.role?.attachInlinePolicy(policy);
+            const resource = new CustomResource(self, "S3Uploader", {
+                serviceToken: stack.customResourceHandler.functionArn,
+                resourceType: "Custom::S3Uploader",
                 properties: {
-                    Sources: assets.map((asset) => ({
-                        BucketName: asset.s3BucketName,
-                        ObjectKey: asset.s3ObjectKey,
+                    sources: s3Assets.map((s3Asset) => ({
+                        bucketName: s3Asset.s3BucketName,
+                        objectKey: s3Asset.s3ObjectKey,
                     })),
-                    DestinationBucketName: bucket.bucketName,
-                    FileOptions: (fileOptions || []).map((o) => {
-                        const { filters, cacheControl, contentType, contentEncoding } = o;
-                        const { include, exclude } = o;
-                        return [
-                            ...(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(),
+                    destinationBucketName: bucket.bucketName,
+                    concurrency: assets?._uploadConcurrency,
+                    textEncoding: assets?.textEncoding ?? "utf-8",
+                    fileOptions: getS3FileOptions(copy),
+                    replaceValues: getS3ContentReplaceValues(),
                 },
             });
+            resource.node.addDependency(policy);
+            return resource;
         }
         function useFunctionUrlSigningFunction() {
             singletonUrlSigner =
@@ -768,10 +634,40 @@ function handler(event) {
                     OriginRequestPolicy.fromOriginRequestPolicyId(self, "ServerOriginRequestPolicy", "b689b0a8-53d0-40ab-baf2-68738e2966ac");
             return singletonOriginRequestPolicy;
         }
-        function useAwsCliLayer() {
-            singletonAwsCliLayer =
-                singletonAwsCliLayer ?? new AwsCliLayer(self, "AwsCliLayer");
-            return singletonAwsCliLayer;
+        function getS3FileOptions(copy) {
+            const fileOptions = [];
+            const nonVersionedFilesTTL = typeof assets?.nonVersionedFilesTTL === "number"
+                ? assets.nonVersionedFilesTTL
+                : toCdkDuration(assets?.nonVersionedFilesTTL ?? "1 day").toSeconds();
+            const staleWhileRevalidateTTL = Math.max(Math.floor(nonVersionedFilesTTL / 10), 30);
+            const versionedFilesTTL = typeof assets?.versionedFilesTTL === "number"
+                ? assets.versionedFilesTTL
+                : toCdkDuration(assets?.versionedFilesTTL ?? "365 days").toSeconds();
+            copy.forEach(({ cached, to, versionedSubDir }) => {
+                if (!cached)
+                    return;
+                // Create a default file option for: unversioned files
+                fileOptions.push({
+                    files: "**",
+                    ignore: versionedSubDir
+                        ? path.posix.join(to, versionedSubDir, "**")
+                        : undefined,
+                    cacheControl: assets?.nonVersionedFilesCacheHeader ??
+                        `public,max-age=0,s-maxage=${nonVersionedFilesTTL},stale-while-revalidate=${staleWhileRevalidateTTL}`,
+                });
+                // Create a default file option for: versioned files
+                if (versionedSubDir) {
+                    fileOptions.push({
+                        files: path.posix.join(to, versionedSubDir, "**"),
+                        cacheControl: assets?.versionedFilesCacheHeader ??
+                            `public,max-age=${versionedFilesTTL},immutable`,
+                    });
+                }
+            });
+            if (assets?.fileOptions) {
+                fileOptions.push(...assets.fileOptions);
+            }
+            return fileOptions;
         }
         function getS3ContentReplaceValues() {
             const replaceValues = [];
@@ -796,18 +692,7 @@ function handler(event) {
             return replaceValues;
         }
         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;
-            }
+            const paths = invalidation.paths;
             // We will generate a hash based on the contents of the S3 files with cache enabled.
             // This will be used to determine if we need to invalidate our CloudFront cache.
             const s3Origin = Object.values(plan.origins).find((origin) => origin.type === "s3");
@@ -818,51 +703,64 @@ function handler(event) {
                 return;
             // Build invalidation paths
             const invalidationPaths = [];
-            if (cdnInvalidationStrategy === "versioned") {
+            if (paths === "none") {
+            }
+            else if (paths === "all") {
+                invalidationPaths.push("/*");
+            }
+            else if (paths === "versioned") {
                 cachedS3Files.forEach((item) => {
                     if (!item.versionedSubDir)
                         return;
                     invalidationPaths.push(path.posix.join("/", item.to, item.versionedSubDir, "*"));
                 });
             }
+            else {
+                invalidationPaths.push(...paths);
+            }
             if (invalidationPaths.length === 0)
-                invalidationPaths.push("/*");
+                return;
             // Build build ID
-            const hash = crypto.createHash("md5");
-            cachedS3Files.forEach((item) => {
-                // The below options are needed to support following symlinks when building zip files:
-                // - nodir: This will prevent symlinks themselves from being copied into the zip.
-                // - follow: This will follow symlinks and copy the files within.
-                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))));
-                }
+            let invalidationBuildId;
+            if (plan.buildId) {
+                invalidationBuildId = plan.buildId;
+            }
+            else {
+                const hash = crypto.createHash("md5");
+                cachedS3Files.forEach((item) => {
+                    // The below options are needed to support following symlinks when building zip files:
+                    // - nodir: This will prevent symlinks themselves from being copied into the zip.
+                    // - follow: This will follow symlinks and copy the files within.
+                    // For versioned files, use file path for digest since file version in name should change on content change
+                    if (item.versionedSubDir) {
+                        globSync("**", {
+                            dot: true,
+                            nodir: true,
+                            follow: true,
+                            cwd: path.resolve(sitePath, item.from, item.versionedSubDir),
+                        }).forEach((filePath) => hash.update(filePath));
+                    }
+                    // For non-versioned files, use file content for digest
+                    if (paths !== "versioned") {
+                        globSync("**", {
+                            ignore: item.versionedSubDir
+                                ? [path.posix.join(item.versionedSubDir, "**")]
+                                : undefined,
+                            dot: true,
+                            nodir: true,
+                            follow: true,
+                            cwd: path.resolve(sitePath, item.from),
+                        }).forEach((filePath) => hash.update(fs.readFileSync(path.resolve(sitePath, item.from, filePath))));
+                    }
+                });
+                invalidationBuildId = hash.digest("hex");
+                Logger.debug(`Generated build ID ${invalidationBuildId}`);
+            }
+            distribution.createInvalidation({
+                version: invalidationBuildId,
+                paths: invalidationPaths,
+                wait: invalidation.wait,
             });
-            const buildId = hash.digest("hex");
-            Logger.debug(`Generated build ID ${buildId}`);
-            distribution.createInvalidation(buildId, invalidationPaths);
         }
     }
     static buildDefaultServerCachePolicyProps(allowedHeaders) {

package/constructs/StaticSite.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, BaseSiteFileOptionsFilter, BaseSiteReplaceProps, BaseSiteCdkDistributionProps, BaseSiteFileOptionsDeprecated } from "./BaseSite.js";
+import { BaseSiteFileOptions, BaseSiteReplaceProps, BaseSiteCdkDistributionProps } from "./BaseSite.js";
 import { SSTConstruct } from "./Construct.js";
 import { FunctionBindingProps } from "./util/functionBinding.js";
 export interface StaticSiteProps {
@@ -67,33 +67,6 @@ 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
-     * [
-     *   {
-     *     filters: [{ exclude: "*" }, { include: "*.html" }],
-     *     cacheControl: "max-age=0,no-cache,no-store,must-revalidate",
-     *   },
-     *   {
-     *     filters: [{ exclude: "*" }, { include: "*.js" }, { include: "*.css" }],
-     *     cacheControl: "max-age=31536000,public,immutable",
-     *   },
-     * ]
-     * ```
-     * @example
-     * ```js
-     * new StaticSite(stack, "Site", {
-     *   buildOutput: "dist",
-     *   fileOptions: [{
-     *     filters: [{ exclude: "*" }, { include: "*.js" }],
-     *     cacheControl: "max-age=31536000,public,immutable",
-     *   }]
-     * });
-     * ```
-     */
-    fileOptions?: StaticSiteFileOptions[] | StaticSiteFileOptionsDeprecated[];
     /**
      * Pass in a list of placeholder values to be replaced in the website content. For example, the follow configuration:
      *
@@ -169,6 +142,50 @@ export interface StaticSiteProps {
      * ```
      */
     purgeFiles?: boolean;
+    assets?: {
+        /**
+         * Character encoding for text based assets uploaded to S3 (ex: html, css, js, etc.). If "none" is specified, no charset will be returned in header.
+         * @default utf-8
+         * @example
+         * ```js
+         * assets: {
+         *   textEncoding: "iso-8859-1"
+         * }
+         * ```
+         */
+        textEncoding?: "utf-8" | "iso-8859-1" | "windows-1252" | "ascii" | "none";
+        /**
+         * 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
+         * assets: {
+         *   fileOptions: [
+         *     {
+         *       files: "**",
+         *       cacheControl: "max-age=0,no-cache,no-store,must-revalidate",
+         *     },
+         *     {
+         *       files: "**\/*.{js,css}",
+         *       cacheControl: "max-age=31536000,public,immutable",
+         *     },
+         *   ],
+         * }
+         * ```
+         * @example
+         * ```js
+         * assets: {
+         *   fileOptions: [
+         *     {
+         *       files: "**\/*.zip",
+         *       cacheControl: "private,no-cache,no-store,must-revalidate",
+         *       contentType: "application/zip",
+         *     },
+         *   ],
+         * }
+         * ```
+         */
+        fileOptions?: StaticSiteFileOptions[];
+    };
     dev?: {
         /**
          * When running `sst dev, site is not deployed. This is to ensure `sst dev` can start up quickly.
@@ -263,12 +280,7 @@ export interface StaticSiteProps {
 }
 export interface StaticSiteDomainProps extends DistributionDomainProps {
 }
-export interface StaticSiteFileOptionsFilter extends BaseSiteFileOptionsFilter {
-}
 export interface StaticSiteFileOptions extends BaseSiteFileOptions {
-    filters: StaticSiteFileOptionsFilter[];
-}
-export interface StaticSiteFileOptionsDeprecated extends BaseSiteFileOptionsDeprecated {
 }
 export interface StaticSiteReplaceProps extends BaseSiteReplaceProps {
 }
@@ -327,6 +339,7 @@ export declare class StaticSite extends Construct implements SSTConstruct {
     };
     /** @internal */
     getFunctionBinding(): FunctionBindingProps;
+    private validateDeprecatedFileOptions;
     private generateViteTypes;
     private buildApp;
     private createS3Assets;