sst 2.30.3 → 2.31.0

package/constructs/BaseSite.d.ts

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

package/constructs/NextjsSite.d.ts

@@ -1,8 +1,11 @@
 import { Construct } from "constructs";
+import { Duration as CdkDuration } from "aws-cdk-lib/core";
 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 { PolicyStatement } from "aws-cdk-lib/aws-iam";
+import { RetentionDays } from "aws-cdk-lib/aws-logs";
 import { CachePolicyProps } from "aws-cdk-lib/aws-cloudfront";
 export interface NextjsSiteProps extends Omit<SsrSiteProps, "nodejs"> {
     /**
@@ -14,6 +17,17 @@ export interface NextjsSiteProps extends Omit<SsrSiteProps, "nodejs"> {
      * ```
      */
     openNextVersion?: string;
+    /**
+     * How the logs are stored in CloudWatch
+     * - "combined" - Logs from all routes are stored in the same log group.
+     * - "per-route" - Logs from each route are stored in a separate log group.
+     * @default "combined"
+     * @example
+     * ```js
+     * logging: "per-route",
+     * ```
+     */
+    logging?: "combined" | "per-route";
     imageOptimization?: {
         /**
          * The amount of memory in MB allocated for image optimization function.
@@ -109,6 +123,7 @@ type NextjsSiteNormalizedProps = NextjsSiteProps & SsrSiteNormalizedProps;
  */
 export declare class NextjsSite extends SsrSite {
     props: NextjsSiteNormalizedProps;
+    private routes?;
     constructor(scope: Construct, id: string, props?: NextjsSiteProps);
     static buildDefaultServerCachePolicyProps(): CachePolicyProps;
     protected plan(bucket: Bucket): {
@@ -122,14 +137,64 @@ export declare class NextjsSite extends SsrSite {
             edgeServer: {
                 constructId: string;
                 function: {
-                    description: string;
-                    bundle: string;
+                    layers: import("aws-cdk-lib/aws-lambda").ILayerVersion[] | undefined;
                     handler: string;
-                    environment: {
-                        CACHE_BUCKET_NAME: string;
-                        CACHE_BUCKET_KEY_PREFIX: string;
-                        CACHE_BUCKET_REGION: string;
-                    };
+                    bundle?: string | undefined;
+                    runtime?: "nodejs14.x" | "nodejs16.x" | "nodejs18.x" | undefined;
+                    timeout?: number | `${number} second` | `${number} seconds` | `${number} minute` | `${number} minutes` | `${number} hour` | `${number} hours` | `${number} day` | `${number} days` | undefined;
+                    memorySize?: number | `${number} MB` | `${number} GB` | undefined;
+                    permissions?: import("./index.js").Permissions | undefined;
+                    environment?: Record<string, string> | undefined;
+                    bind?: import("./Construct.js").SSTConstruct[] | undefined;
+                    nodejs?: import("./Function.js").NodeJSProps | undefined;
+                    copyFiles?: import("./Function.js").FunctionCopyFilesProps[] | undefined;
+                    logRetention?: RetentionDays | undefined;
+                    functionName?: string | undefined;
+                    tracing?: import("aws-cdk-lib/aws-lambda").Tracing | undefined;
+                    architecture?: Architecture | undefined;
+                    description?: string | undefined;
+                    ephemeralStorageSize?: import("aws-cdk-lib/core").Size | undefined;
+                    initialPolicy?: PolicyStatement[] | undefined;
+                    role?: import("aws-cdk-lib/aws-iam").IRole | undefined;
+                    vpc?: import("aws-cdk-lib/aws-ec2").IVpc | undefined;
+                    vpcSubnets?: import("aws-cdk-lib/aws-ec2").SubnetSelection | undefined;
+                    securityGroups?: import("aws-cdk-lib/aws-ec2").ISecurityGroup[] | undefined;
+                    allowAllOutbound?: boolean | undefined;
+                    deadLetterQueueEnabled?: boolean | undefined;
+                    deadLetterQueue?: import("aws-cdk-lib/aws-sqs").IQueue | undefined;
+                    deadLetterTopic?: import("aws-cdk-lib/aws-sns").ITopic | undefined;
+                    snapStart?: import("aws-cdk-lib/aws-lambda").SnapStartConf | undefined;
+                    profiling?: boolean | undefined;
+                    profilingGroup?: import("aws-cdk-lib/aws-codeguruprofiler").IProfilingGroup | undefined;
+                    insightsVersion?: import("aws-cdk-lib/aws-lambda").LambdaInsightsVersion | undefined;
+                    adotInstrumentation?: import("aws-cdk-lib/aws-lambda").AdotInstrumentationConfig | undefined;
+                    paramsAndSecrets?: import("aws-cdk-lib/aws-lambda").ParamsAndSecretsLayerVersion | undefined;
+                    reservedConcurrentExecutions?: number | undefined;
+                    events?: import("aws-cdk-lib/aws-lambda").IEventSource[] | undefined;
+                    logRetentionRole?: import("aws-cdk-lib/aws-iam").IRole | undefined;
+                    logRetentionRetryOptions?: import("aws-cdk-lib/aws-lambda").LogRetentionRetryOptions | undefined;
+                    currentVersionOptions?: import("aws-cdk-lib/aws-lambda").VersionOptions | undefined;
+                    filesystem?: import("aws-cdk-lib/aws-lambda").FileSystem | undefined;
+                    allowPublicSubnet?: boolean | undefined;
+                    environmentEncryption?: import("aws-cdk-lib/aws-kms").IKey | undefined;
+                    codeSigningConfig?: import("aws-cdk-lib/aws-lambda").ICodeSigningConfig | undefined;
+                    runtimeManagementMode?: import("aws-cdk-lib/aws-lambda").RuntimeManagementMode | undefined;
+                    onFailure?: import("aws-cdk-lib/aws-lambda").IDestination | undefined;
+                    onSuccess?: import("aws-cdk-lib/aws-lambda").IDestination | undefined;
+                    maxEventAge?: CdkDuration | undefined;
+                    retryAttempts?: number | undefined;
+                } | {
+                    layers: import("aws-cdk-lib/aws-lambda").ILayerVersion[] | undefined;
+                    handler: string;
+                    bundle?: string | undefined;
+                    runtime?: "nodejs14.x" | "nodejs16.x" | "nodejs18.x" | undefined;
+                    timeout?: number | `${number} second` | `${number} seconds` | `${number} minute` | `${number} minutes` | `${number} hour` | `${number} hours` | `${number} day` | `${number} days` | undefined;
+                    memorySize?: number | `${number} MB` | `${number} GB` | undefined;
+                    permissions?: import("./index.js").Permissions | undefined;
+                    environment?: Record<string, string> | undefined;
+                    bind?: import("./Construct.js").SSTConstruct[] | undefined;
+                    nodejs?: import("./Function.js").NodeJSProps | undefined;
+                    scopeOverride?: import("constructs").IConstruct | undefined;
                 };
             };
         } | undefined;
@@ -169,14 +234,64 @@ export declare class NextjsSite extends SsrSite {
                 type: "function";
                 constructId: string;
                 function: {
-                    description: string;
-                    bundle: string;
+                    layers: import("aws-cdk-lib/aws-lambda").ILayerVersion[] | undefined;
                     handler: string;
-                    environment: {
-                        CACHE_BUCKET_NAME: string;
-                        CACHE_BUCKET_KEY_PREFIX: string;
-                        CACHE_BUCKET_REGION: string;
-                    };
+                    bundle?: string | undefined;
+                    runtime?: "nodejs14.x" | "nodejs16.x" | "nodejs18.x" | undefined;
+                    timeout?: number | `${number} second` | `${number} seconds` | `${number} minute` | `${number} minutes` | `${number} hour` | `${number} hours` | `${number} day` | `${number} days` | undefined;
+                    memorySize?: number | `${number} MB` | `${number} GB` | undefined;
+                    permissions?: import("./index.js").Permissions | undefined;
+                    environment?: Record<string, string> | undefined;
+                    bind?: import("./Construct.js").SSTConstruct[] | undefined;
+                    nodejs?: import("./Function.js").NodeJSProps | undefined;
+                    copyFiles?: import("./Function.js").FunctionCopyFilesProps[] | undefined;
+                    logRetention?: RetentionDays | undefined;
+                    functionName?: string | undefined;
+                    tracing?: import("aws-cdk-lib/aws-lambda").Tracing | undefined;
+                    architecture?: Architecture | undefined;
+                    description?: string | undefined;
+                    ephemeralStorageSize?: import("aws-cdk-lib/core").Size | undefined;
+                    initialPolicy?: PolicyStatement[] | undefined;
+                    role?: import("aws-cdk-lib/aws-iam").IRole | undefined;
+                    vpc?: import("aws-cdk-lib/aws-ec2").IVpc | undefined;
+                    vpcSubnets?: import("aws-cdk-lib/aws-ec2").SubnetSelection | undefined;
+                    securityGroups?: import("aws-cdk-lib/aws-ec2").ISecurityGroup[] | undefined;
+                    allowAllOutbound?: boolean | undefined;
+                    deadLetterQueueEnabled?: boolean | undefined;
+                    deadLetterQueue?: import("aws-cdk-lib/aws-sqs").IQueue | undefined;
+                    deadLetterTopic?: import("aws-cdk-lib/aws-sns").ITopic | undefined;
+                    snapStart?: import("aws-cdk-lib/aws-lambda").SnapStartConf | undefined;
+                    profiling?: boolean | undefined;
+                    profilingGroup?: import("aws-cdk-lib/aws-codeguruprofiler").IProfilingGroup | undefined;
+                    insightsVersion?: import("aws-cdk-lib/aws-lambda").LambdaInsightsVersion | undefined;
+                    adotInstrumentation?: import("aws-cdk-lib/aws-lambda").AdotInstrumentationConfig | undefined;
+                    paramsAndSecrets?: import("aws-cdk-lib/aws-lambda").ParamsAndSecretsLayerVersion | undefined;
+                    reservedConcurrentExecutions?: number | undefined;
+                    events?: import("aws-cdk-lib/aws-lambda").IEventSource[] | undefined;
+                    logRetentionRole?: import("aws-cdk-lib/aws-iam").IRole | undefined;
+                    logRetentionRetryOptions?: import("aws-cdk-lib/aws-lambda").LogRetentionRetryOptions | undefined;
+                    currentVersionOptions?: import("aws-cdk-lib/aws-lambda").VersionOptions | undefined;
+                    filesystem?: import("aws-cdk-lib/aws-lambda").FileSystem | undefined;
+                    allowPublicSubnet?: boolean | undefined;
+                    environmentEncryption?: import("aws-cdk-lib/aws-kms").IKey | undefined;
+                    codeSigningConfig?: import("aws-cdk-lib/aws-lambda").ICodeSigningConfig | undefined;
+                    runtimeManagementMode?: import("aws-cdk-lib/aws-lambda").RuntimeManagementMode | undefined;
+                    onFailure?: import("aws-cdk-lib/aws-lambda").IDestination | undefined;
+                    onSuccess?: import("aws-cdk-lib/aws-lambda").IDestination | undefined;
+                    maxEventAge?: CdkDuration | undefined;
+                    retryAttempts?: number | undefined;
+                } | {
+                    layers: import("aws-cdk-lib/aws-lambda").ILayerVersion[] | undefined;
+                    handler: string;
+                    bundle?: string | undefined;
+                    runtime?: "nodejs14.x" | "nodejs16.x" | "nodejs18.x" | undefined;
+                    timeout?: number | `${number} second` | `${number} seconds` | `${number} minute` | `${number} minutes` | `${number} hour` | `${number} hours` | `${number} day` | `${number} days` | undefined;
+                    memorySize?: number | `${number} MB` | `${number} GB` | undefined;
+                    permissions?: import("./index.js").Permissions | undefined;
+                    environment?: Record<string, string> | undefined;
+                    bind?: import("./Construct.js").SSTConstruct[] | undefined;
+                    nodejs?: import("./Function.js").NodeJSProps | undefined;
+                    scopeOverride?: import("constructs").IConstruct | undefined;
                 };
                 streaming: boolean | undefined;
             } | undefined;
@@ -203,8 +318,12 @@ export declare class NextjsSite extends SsrSite {
         type: "NextjsSite";
         data: {
             routes: {
-                route: string;
-            }[] | undefined;
+                logGroupPrefix: string;
+                data: {
+                    route: string;
+                    logGroupPath: string;
+                }[];
+            } | undefined;
             mode: "placeholder" | "deployed";
             path: string;
             runtime: "nodejs14.x" | "nodejs16.x" | "nodejs18.x";
@@ -215,8 +334,15 @@ export declare class NextjsSite extends SsrSite {
             secrets: string[];
         };
     };
-    private wrapHandler;
-    private getRoutes;
+    private wrapServerFunction;
+    private useRoutes;
     private getBuildId;
+    private isPerRouteLoggingEnabled;
+    private disableDefaultLogging;
+    private static buildCloudWatchRouteName;
+    private static buildCloudWatchRouteHash;
+    static _test: {
+        buildCloudWatchRouteName: typeof NextjsSite.buildCloudWatchRouteName;
+    };
 }
 export {};

package/constructs/NextjsSite.js

@@ -1,7 +1,8 @@
 import fs from "fs";
 import path from "path";
+import crypto from "crypto";
 import { Duration as CdkDuration, RemovalPolicy, CustomResource, } from "aws-cdk-lib/core";
-import { Code, Runtime, Function as CdkFunction, Architecture, } from "aws-cdk-lib/aws-lambda";
+import { Code, Runtime, Function as CdkFunction, Architecture, LayerVersion, } from "aws-cdk-lib/aws-lambda";
 import { AttributeType, Billing, TableV2 as Table, } from "aws-cdk-lib/aws-dynamodb";
 import { Provider } from "aws-cdk-lib/custom-resources";
 import { Queue } from "aws-cdk-lib/aws-sqs";
@@ -9,9 +10,10 @@ import { SqsEventSource } from "aws-cdk-lib/aws-lambda-event-sources";
 import { Stack } from "./Stack.js";
 import { SsrSite } from "./SsrSite.js";
 import { toCdkSize } from "./util/size.js";
-import { PolicyStatement } from "aws-cdk-lib/aws-iam";
+import { Effect, Policy, PolicyStatement } from "aws-cdk-lib/aws-iam";
 import { RetentionDays } from "aws-cdk-lib/aws-logs";
 import { VisibleError } from "../error.js";
+const LAYER_VERSION = "2";
 const DEFAULT_OPEN_NEXT_VERSION = "2.2.4";
 const DEFAULT_CACHE_POLICY_ALLOWED_HEADERS = [
     "accept",
@@ -32,13 +34,11 @@ const DEFAULT_CACHE_POLICY_ALLOWED_HEADERS = [
  * ```
  */
 export class NextjsSite extends SsrSite {
+    routes;
     constructor(scope, id, props) {
-        const { streaming, disableDynamoDBCache, disableIncrementalCache } = {
-            streaming: false,
-            disableDynamoDBCache: false,
-            disableIncrementalCache: false,
-            ...props?.experimental,
-        };
+        const streaming = props?.experimental?.streaming ?? false;
+        const disableDynamoDBCache = props?.experimental?.disableDynamoDBCache ?? false;
+        const disableIncrementalCache = props?.experimental?.disableIncrementalCache ?? false;
         super(scope, id, {
             buildCommand: [
                 "npx",
@@ -55,6 +55,9 @@ export class NextjsSite extends SsrSite {
             ].join(" "),
             ...props,
         });
+        if (this.isPerRouteLoggingEnabled()) {
+            this.disableDefaultLogging();
+        }
         if (!disableIncrementalCache) {
             this.createRevalidationQueue();
             if (!disableDynamoDBCache) {
@@ -67,16 +70,16 @@ export class NextjsSite extends SsrSite {
     }
     plan(bucket) {
         const { path: sitePath, edge, experimental, imageOptimization, } = this.props;
-        const serverConfig = {
+        const serverConfig = this.wrapServerFunction({
             description: "Next.js server",
             bundle: path.join(sitePath, ".open-next", "server-function"),
-            handler: this.wrapHandler(),
+            handler: "index.handler",
             environment: {
                 CACHE_BUCKET_NAME: bucket.bucketName,
                 CACHE_BUCKET_KEY_PREFIX: "_cache",
                 CACHE_BUCKET_REGION: Stack.of(this).region,
             },
-        };
+        });
         return this.validatePlan({
             cloudFrontFunctions: {
                 serverCfFunction: {
@@ -289,50 +292,100 @@ export class NextjsSite extends SsrSite {
             type: "NextjsSite",
             data: {
                 ...metadata.data,
-                routes: this.props.edge || this.doNotDeploy ? undefined : this.getRoutes(),
+                routes: this.isPerRouteLoggingEnabled()
+                    ? {
+                        logGroupPrefix: `/sst/lambda/${this.serverFunction.functionName}`,
+                        data: this.useRoutes().map(({ route, logGroupPath }) => ({
+                            route,
+                            logGroupPath,
+                        })),
+                    }
+                    : undefined,
             },
         };
     }
-    wrapHandler() {
-        const { path: sitePath, experimental } = this.props;
+    wrapServerFunction(config) {
+        const { path: sitePath, experimental, cdk } = this.props;
+        const stack = Stack.of(this);
         const wrapperName = "nextjssite-index";
         const serverPath = path.join(sitePath, ".open-next", "server-function");
+        const injections = [];
+        if (this.isPerRouteLoggingEnabled()) {
+            injections.push(`
+      const routeData = ${JSON.stringify(this.useRoutes())}.find(({ regex }) => event.rawPath.match(new RegExp(regex)));
+      if (routeData) {
+        console.log("::sst::" + JSON.stringify({
+          action:"log.split",
+          properties: {
+            logGroupName:"/sst/lambda/" + context.functionName + routeData.logGroupPath,
+          },
+        }));
+      }`);
+        }
         fs.writeFileSync(path.join(serverPath, `${wrapperName}.mjs`), experimental?.streaming
             ? [
-                `export const handler = awslambda.streamifyResponse(async (...args) => {`,
+                `export const handler = awslambda.streamifyResponse(async (event, context) => {`,
+                ...injections,
                 `  const { handler: rawHandler} = await import("./index.mjs");`,
-                `  return rawHandler(...args);`,
+                `  return rawHandler(event, context);`,
                 `});`,
             ].join("\n")
             : [
-                `export const handler = async (...args) => {`,
+                `export const handler = async (event, context) => {`,
+                ...injections,
                 `  const { handler: rawHandler} = await import("./index.mjs");`,
-                `  return rawHandler(...args);`,
+                `  return rawHandler(event, context);`,
                 `};`,
             ].join("\n"));
-        return `${wrapperName}.handler`;
+        return {
+            ...config,
+            layers: this.isPerRouteLoggingEnabled()
+                ? [
+                    LayerVersion.fromLayerVersionArn(this, "SSTExtension", cdk?.server?.architecture?.name === Architecture.X86_64.name
+                        ? `arn:aws:lambda:${stack.region}:226609089145:layer:sst-extension-amd64:${LAYER_VERSION}`
+                        : `arn:aws:lambda:${stack.region}:226609089145:layer:sst-extension-arm64:${LAYER_VERSION}`),
+                ]
+                : undefined,
+            handler: `${wrapperName}.handler`,
+        };
     }
-    getRoutes() {
+    useRoutes() {
+        if (this.routes)
+            return this.routes;
         const id = this.node.id;
         const { path: sitePath } = this.props;
         try {
             const content = JSON.parse(fs
                 .readFileSync(path.join(sitePath, ".next/routes-manifest.json"))
                 .toString());
-            return [
+            this.routes = [
                 ...[...content.dynamicRoutes, ...content.staticRoutes]
-                    .map(({ page }) => ({
-                    route: page,
-                }))
+                    .map(({ page, regex }) => {
+                    const cwRoute = NextjsSite.buildCloudWatchRouteName(page);
+                    const cwHash = NextjsSite.buildCloudWatchRouteHash(page);
+                    return {
+                        route: page,
+                        regex,
+                        logGroupPath: `/${cwHash}${cwRoute}`,
+                    };
+                })
                     .sort((a, b) => a.route.localeCompare(b.route)),
                 ...(content.dataRoutes || [])
-                    .map(({ page }) => ({
-                    route: page.endsWith("/")
+                    .map(({ page, dataRouteRegex }) => {
+                    const routeDisplayName = page.endsWith("/")
                         ? `/_next/data/BUILD_ID${page}index.json`
-                        : `/_next/data/BUILD_ID${page}.json`,
-                }))
+                        : `/_next/data/BUILD_ID${page}.json`;
+                    const cwRoute = NextjsSite.buildCloudWatchRouteName(routeDisplayName);
+                    const cwHash = NextjsSite.buildCloudWatchRouteHash(`data:${page}`);
+                    return {
+                        route: routeDisplayName,
+                        regex: dataRouteRegex,
+                        logGroupPath: `/${cwHash}${cwRoute}`,
+                    };
+                })
                     .sort((a, b) => a.route.localeCompare(b.route)),
             ];
+            return this.routes;
         }
         catch (e) {
             console.error(e);
@@ -343,4 +396,43 @@ export class NextjsSite extends SsrSite {
         const { path: sitePath } = this.props;
         return fs.readFileSync(path.join(sitePath, ".next/BUILD_ID")).toString();
     }
+    isPerRouteLoggingEnabled() {
+        return (!this.doNotDeploy &&
+            !this.props.edge &&
+            this.props.logging === "per-route");
+    }
+    disableDefaultLogging() {
+        // Note: keep default logs enabled
+        return;
+        const stack = Stack.of(this);
+        const server = this.serverFunction;
+        const policy = new Policy(this, "DisableLoggingPolicy", {
+            statements: [
+                new PolicyStatement({
+                    effect: Effect.DENY,
+                    actions: [
+                        "logs:CreateLogGroup",
+                        "logs:CreateLogStream",
+                        "logs:PutLogEvents",
+                    ],
+                    resources: [
+                        `arn:aws:logs:${stack.region}:${stack.account}:log-group:/aws/lambda/${server.functionName}`,
+                        `arn:aws:logs:${stack.region}:${stack.account}:log-group:/aws/lambda/${server.functionName}:*`,
+                    ],
+                }),
+            ],
+        });
+        server.role?.attachInlinePolicy(policy);
+    }
+    static buildCloudWatchRouteName(route) {
+        return route.replace(/[^a-zA-Z0-9_\-/.#]/g, "");
+    }
+    static buildCloudWatchRouteHash(route) {
+        const hash = crypto.createHash("sha256");
+        hash.update(route);
+        return hash.digest("hex").substring(0, 8);
+    }
+    static _test = {
+        buildCloudWatchRouteName: NextjsSite.buildCloudWatchRouteName,
+    };
 }

package/constructs/RDS.js

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

package/constructs/SsrSite.d.ts

@@ -8,7 +8,7 @@ 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, BaseSiteFileOptionsFilter, BaseSiteFileOptionsDeprecated, BaseSiteReplaceProps, BaseSiteCdkDistributionProps } from "./BaseSite.js";
+import { BaseSiteFileOptions, BaseSiteReplaceProps, BaseSiteCdkDistributionProps } from "./BaseSite.js";
 import { Size } from "./util/size.js";
 import { Duration } from "./util/duration.js";
 import { Permissions } from "./util/permission.js";
@@ -52,12 +52,7 @@ export interface SsrSiteNodeJSProps extends NodeJSProps {
 }
 export interface SsrDomainProps extends DistributionDomainProps {
 }
-export interface SsrSiteFileOptionsFilter extends BaseSiteFileOptionsFilter {
-}
 export interface SsrSiteFileOptions extends BaseSiteFileOptions {
-    filters: SsrSiteFileOptionsFilter[];
-}
-export interface SsrSiteFileOptionsDeprecated extends BaseSiteFileOptionsDeprecated {
 }
 export interface SsrSiteReplaceProps extends BaseSiteReplaceProps {
 }
@@ -207,18 +202,18 @@ export interface SsrSiteProps {
          */
         url?: string;
     };
-    cache?: {
+    assets?: {
         /**
-         * 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.
+         * 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
-         * cache: {
-         *  textEncoding: "iso-8859-1"
+         * assets: {
+         *   textEncoding: "iso-8859-1"
          * }
          * ```
          */
-        textEncoding?: "UTF-8" | "ISO-8859-1" | "Windows-1252" | "ASCII" | "none";
+        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.
@@ -228,7 +223,7 @@ export interface SsrSiteProps {
          * @default all
          * @example
          * ```js
-         * cache: {
+         * assets: {
          *   cdnInvalidationStrategy: "versioned"
          * }
          * ```
@@ -239,8 +234,8 @@ export interface SsrSiteProps {
          * @default 1 year
          * @example
          * ```js
-         * cache: {
-         *  versionedFilesTTL: "30 days"
+         * assets: {
+         *   versionedFilesTTL: "30 days"
          * }
          * ```
          */
@@ -250,7 +245,7 @@ export interface SsrSiteProps {
          * @default public,max-age=31536000,immutable
          * @example
          * ```js
-         * cache: {
+         * assets: {
          *   versionedFilesCacheHeader: "public,max-age=31536000,immutable"
          * }
          * ```
@@ -261,8 +256,8 @@ export interface SsrSiteProps {
          * @default 1 day
          * @example
          * ```js
-         * cache: {
-         *  nonVersionedFilesTTL: "4 hours"
+         * assets: {
+         *   nonVersionedFilesTTL: "4 hours"
          * }
          * ```
          */
@@ -272,7 +267,7 @@ export interface SsrSiteProps {
          * @default public,max-age=0,s-maxage=86400,stale-while-revalidate=8640
          * @example
          * ```js
-         * cache: {
+         * assets: {
          *   nonVersionedFilesCacheHeader: "public,max-age=0,no-cache"
          * }
          * ```
@@ -282,10 +277,10 @@ export interface SsrSiteProps {
          * 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: {
+         * assets: {
          *   fileOptions: [
          *     {
-         *       filters: [ { exclude: "*" }, { include: "*.zip" } ],
+         *       files: "**\/*.zip",
          *       cacheControl: "private,no-cache,no-store,must-revalidate",
          *       contentType: "application/zip",
          *     },
@@ -294,6 +289,10 @@ export interface SsrSiteProps {
          * ```
          */
         fileOptions?: SsrSiteFileOptions[];
+        /**
+         * @internal
+         */
+        _uploadConcurrency?: number;
     };
     /**
      * 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.
@@ -343,59 +342,6 @@ export interface SsrSiteProps {
         responseHeadersPolicy?: IResponseHeadersPolicy;
         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. 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 browser level.
-     * Nonversioned files cached for 1 day at the CDN level, but not at the browser level.
-     * ```js
-     * fileOptions: [
-     *   {
-     *     exclude: "*",
-     *     include: "{versioned_directory}/*",
-     *     cacheControl: "public,max-age=31536000,immutable",
-     *   },
-     *   {
-     *     exclude: "*",
-     *     include: "[{non_versioned_file1}, {non_versioned_file2}, ...]",
-     *     cacheControl: "public,max-age=0,s-maxage=31536000,must-revalidate",
-     *   },
-     *   {
-     *     exclude: "*",
-     *     include: "[{non_versioned_dir_1}/*, {non_versioned_dir_2}/*, ...]",
-     *     cacheControl: "public,max-age=0,s-maxage=31536000,must-revalidate",
-     *   },
-     * ]
-     * ```
-     *
-     * @example
-     * ```js
-     * fileOptions: [
-     *   {
-     *     exclude: "*",
-     *     include: "{versioned_directory}/*.css",
-     *     cacheControl: "public,max-age=31536000,immutable",
-     *     contentType: "text/css; charset=UTF-8",
-     *   },
-     *   {
-     *     exclude: "*",
-     *     include: "{versioned_directory}/*.js",
-     *     cacheControl: "public,max-age=31536000,immutable",
-     *   },
-     *   {
-     *     exclude: "*",
-     *     include: "[{non_versioned_file1}, {non_versioned_file2}, ...]",
-     *     cacheControl: "public,max-age=0,s-maxage=31536000,must-revalidate",
-     *   },
-     *   {
-     *     exclude: "*",
-     *     include: "[{non_versioned_dir_1}/*, {non_versioned_dir_2}/*, ...]",
-     *     cacheControl: "public,max-age=0,s-maxage=31536000,must-revalidate",
-     *   },
-     * ]
-     */
-    fileOptions?: SsrSiteFileOptionsDeprecated[];
 }
 export type SsrSiteNormalizedProps = SsrSiteProps & {
     path: Exclude<SsrSiteProps["path"], undefined>;