sst 2.26.11 → 2.28.0

package/constructs/AstroSite.d.ts

@@ -1,4 +1,44 @@
-import { SsrSite } from "./SsrSite.js";
+import { SsrSite, SsrSiteNormalizedProps, SsrSiteProps } from "./SsrSite.js";
+import { AllowedMethods } from "aws-cdk-lib/aws-cloudfront";
+import { Construct } from "constructs";
+export interface AstroSiteProps extends SsrSiteProps {
+    regional?: SsrSiteProps["regional"] & {
+        /**
+         * List all routes that will be handling non-GET requests. For example, routes like form submissions, logins, and API endpoints.
+         *
+         * Route patterns are case sensitive. And the following wildcard characters can be used:
+         *   - "*" matches 0 or more characters.
+         *   - "?" matches exactly 1 character.
+         *
+         * Matched routes will be handled directly by the server function.
+         * @default true
+         * @example
+         * ```js
+         * regional: {
+         *   serverRoutes: [
+         *     "feedback", // Feedback page which requires POST method
+         *     "login",    // Login page which requires POST method
+         *     "user/*",   // Directory of user routes which are all SSR
+         *     "api/*"     // Directory of API endpoints which require all methods
+         *   ]
+         * }
+         * ```
+         */
+        serverRoutes?: string[];
+        /**
+         * Supports [streaming](https://docs.astro.build/en/guides/server-side-rendering/#using-streaming-to-improve-page-performance) responses.
+         * @default true
+         * @example
+         * ```js
+         * regional: {
+         *   streaming: false,
+         * }
+         * ```
+         */
+        streaming?: boolean;
+    };
+}
+type AstroSiteNormalizedProps = AstroSiteProps & SsrSiteNormalizedProps;
 /**
  * The `AstroSite` construct is a higher level CDK construct that makes it easy to create a Astro app.
  * @example
@@ -11,55 +51,56 @@ import { SsrSite } from "./SsrSite.js";
  * ```
  */
 export declare class AstroSite extends SsrSite {
-    protected typesPath: string;
+    props: AstroSiteNormalizedProps;
+    constructor(scope: Construct, id: string, props?: AstroSiteProps);
+    private static getBuildMeta;
+    private static getCFRoutingFunction;
     protected plan(): {
-        cloudFrontFunctions?: {
-            serverCfFunction: {
-                constructId: string;
-                injections: string[];
-            };
-        } | undefined;
-        edgeFunctions?: {
-            edgeServer: {
-                constructId: string;
-                function: {
-                    description: string;
-                    handler: string;
-                    scopeOverride: AstroSite;
-                };
-            };
-        } | undefined;
-        origins: {
-            s3: {
-                type: "s3";
-                copy: {
-                    from: string;
-                    to: string;
-                    cached: true;
-                    versionedSubDir: string;
-                }[];
-            };
-            regionalServer?: {
-                type: "function";
-                constructId: string;
-                function: {
-                    description: string;
-                    handler: string;
-                };
-                streaming: true;
-            } | undefined;
-        };
+        cloudFrontFunctions?: Record<string, {
+            constructId: string;
+            injections: string[];
+        }> | undefined;
+        edgeFunctions?: Record<string, {
+            constructId: string;
+            function: import("./EdgeFunction.js").EdgeFunctionProps;
+        }> | undefined;
+        origins: Record<string, {
+            type: "function";
+            constructId: string;
+            function: import("./SsrFunction.js").SsrFunctionProps;
+            streaming?: boolean | undefined;
+        } | {
+            type: "image-optimization-function";
+            function: import("aws-cdk-lib/aws-lambda").FunctionProps;
+        } | {
+            type: "s3";
+            originPath?: string | undefined;
+            copy: {
+                from: string;
+                to: string;
+                cached: boolean;
+                versionedSubDir?: string | undefined;
+            }[];
+        } | {
+            type: "group";
+            primaryOriginName: string;
+            fallbackOriginName: string;
+            fallbackStatusCodes?: number[] | undefined;
+        }>;
         behaviors: {
             cacheType: "server" | "static";
             pattern?: string | undefined;
-            origin: "s3" | "regionalServer";
-            cfFunction?: "serverCfFunction" | undefined;
-            edgeFunction?: "edgeServer" | undefined;
+            origin: string;
+            allowedMethods?: AllowedMethods | undefined;
+            cfFunction?: string | undefined;
+            edgeFunction?: string | undefined;
         }[];
+        errorResponses?: import("aws-cdk-lib/aws-cloudfront").ErrorResponse[] | undefined;
         cachePolicyAllowedHeaders?: string[] | undefined;
         buildId?: string | undefined;
         warmerConfig?: {
             function: string;
+            schedule?: import("aws-cdk-lib/aws-events").Schedule | undefined;
         } | undefined;
     };
     getConstructMetadata(): {
@@ -76,3 +117,4 @@ export declare class AstroSite extends SsrSite {
         type: "AstroSite";
     };
 }
+export {};

package/constructs/AstroSite.js

@@ -1,6 +1,8 @@
-import fs from "fs";
-import path from "path";
-import { SsrSite } from "./SsrSite.js";
+import { readFileSync, existsSync, readdirSync, statSync } from "fs";
+import { join } from "path";
+import { SsrSite, } from "./SsrSite.js";
+import { AllowedMethods } from "aws-cdk-lib/aws-cloudfront";
+const BUILD_META_FILE_NAME = "sst.buildMeta.json";
 /**
  * The `AstroSite` construct is a higher level CDK construct that makes it easy to create a Astro app.
  * @example
@@ -13,79 +15,181 @@ import { SsrSite } from "./SsrSite.js";
  * ```
  */
 export class AstroSite extends SsrSite {
-    typesPath = "src";
+    constructor(scope, id, props) {
+        super(scope, id, {
+            ...props,
+            typesPath: props?.typesPath ?? "src",
+            fileOptions: props?.fileOptions ?? [
+                {
+                    exclude: "*",
+                    include: "*.css",
+                    cacheControl: "public,max-age=0,s-maxage=31536000,must-revalidate",
+                    contentType: "text/css; charset=UTF-8",
+                },
+                {
+                    exclude: "*",
+                    include: "*.js",
+                    cacheControl: "public,max-age=0,s-maxage=31536000,must-revalidate",
+                    contentType: "application/javascript; charset=UTF-8",
+                },
+                {
+                    exclude: "*",
+                    include: "*.html",
+                    cacheControl: "public,max-age=0,s-maxage=31536000,must-revalidate",
+                    contentType: "text/html; charset=UTF-8",
+                },
+            ],
+            regional: {
+                streaming: props?.regional?.streaming ?? true,
+                ...props?.regional,
+            },
+        });
+    }
+    static getBuildMeta(filePath) {
+        if (!existsSync(filePath)) {
+            throw new Error(`Could not find build meta file at ${filePath}. Update your 'astro-sst' package version and rebuild your Astro site.`);
+        }
+        return JSON.parse(readFileSync(filePath, "utf-8"));
+    }
+    static getCFRoutingFunction({ routes, pageResolution, }) {
+        const serializedRoutes = "[\n" +
+            routes
+                .map((route) => {
+                return `    {route: "${route.route}", pattern: ${route.pattern}, type: "${route.type}", ${typeof route.prerender !== "undefined"
+                    ? `prerender: ${route.prerender}, `
+                    : ``}${route.redirectPath ? `redirectPath: "${route.redirectPath}", ` : ""}${route.redirectStatus
+                    ? `redirectStatus: ${route.redirectStatus}`
+                    : ""} }`;
+            })
+                .join(",\n") +
+            "\n  ]";
+        return `  // AstroSite CF Routing Function
+  var astroRoutes = ${serializedRoutes};
+  var matchedRoute = astroRoutes.find((route) => route.pattern.test(request.uri));
+  if (matchedRoute) {
+    if (matchedRoute.type === "redirect") {
+      var redirectPath = matchedRoute.redirectPath;
+      matchedRoute.pattern.exec(request.uri).forEach((match, index) => {
+        redirectPath = redirectPath.replace(\`\\\${\${index}}\`, match);
+      });
+      var statusCode = matchedRoute.redirectStatus || 308;
+      return {
+        statusCode,
+        headers: { location: { value: redirectPath } },
+      };
+    } else if (matchedRoute.type === "page" && matchedRoute.prerender) {
+      ${pageResolution === "file"
+            ? `request.uri = request.uri === "/" ? "/index.html" : request.uri.replace(/\\/?$/, ".html");`
+            : `request.uri = request.uri.replace(/\\/?$/, "/index.html");`}
+    }
+  }
+  // End AstroSite CF Routing Function`;
+    }
     plan() {
-        const { path: sitePath, edge } = this.props;
+        const { path: sitePath, edge, regional } = this.props;
+        const buildMeta = AstroSite.getBuildMeta(join(sitePath, "dist", BUILD_META_FILE_NAME));
         const serverConfig = {
             description: "Server handler for Astro",
-            handler: path.join(sitePath, "dist", "server", "entry.handler"),
+            handler: join(sitePath, "dist", "server", "entry.handler"),
         };
-        return this.validatePlan({
+        const plan = {
             cloudFrontFunctions: {
                 serverCfFunction: {
                     constructId: "CloudFrontFunction",
-                    injections: [this.useCloudFrontFunctionHostHeaderInjection()],
+                    injections: [
+                        this.useCloudFrontFunctionHostHeaderInjection(),
+                        ...(!edge ? [AstroSite.getCFRoutingFunction(buildMeta)] : []),
+                    ],
                 },
             },
-            edgeFunctions: edge
-                ? {
-                    edgeServer: {
-                        constructId: "Server",
-                        function: {
-                            scopeOverride: this,
-                            ...serverConfig,
-                        },
-                    },
-                }
-                : undefined,
             origins: {
-                ...(edge
-                    ? {}
-                    : {
-                        regionalServer: {
-                            type: "function",
-                            constructId: "ServerFunction",
-                            function: serverConfig,
-                            streaming: true,
-                        },
-                    }),
-                s3: {
+                staticsServer: {
                     type: "s3",
                     copy: [
                         {
-                            from: "dist/client",
+                            from: buildMeta.clientBuildOutputDir,
                             to: "",
                             cached: true,
-                            versionedSubDir: "assets",
+                            versionedSubDir: buildMeta.clientBuildVersionedSubDir,
                         },
                     ],
                 },
             },
-            behaviors: [
-                edge
-                    ? {
-                        cacheType: "server",
-                        cfFunction: "serverCfFunction",
-                        edgeFunction: "edgeServer",
-                        origin: "s3",
-                    }
-                    : {
-                        cacheType: "server",
-                        cfFunction: "serverCfFunction",
-                        origin: "regionalServer",
+            behaviors: [],
+            errorResponses: [],
+        };
+        if (edge) {
+            plan.edgeFunctions = {
+                edgeServer: {
+                    constructId: "Server",
+                    function: {
+                        scopeOverride: this,
+                        ...serverConfig,
                     },
-                // create 1 behaviour for each top level asset file/folder
-                ...fs.readdirSync(path.join(sitePath, "dist/client")).map((item) => ({
-                    cacheType: "static",
-                    pattern: fs
-                        .statSync(path.join(sitePath, "dist/client", item))
-                        .isDirectory()
-                        ? `${item}/*`
-                        : item,
-                    origin: "s3",
-                })),
-            ],
-        });
+                },
+            };
+            plan.behaviors.push({
+                cacheType: "server",
+                cfFunction: "serverCfFunction",
+                edgeFunction: "edgeServer",
+                origin: "staticsServer",
+            }, ...readdirSync(join(sitePath, buildMeta.clientBuildOutputDir)).map((item) => ({
+                cacheType: "static",
+                pattern: statSync(join(sitePath, buildMeta.clientBuildOutputDir, item)).isDirectory()
+                    ? `${item}/*`
+                    : item,
+                origin: "staticsServer",
+            })));
+            plan.behaviors.push({
+                cacheType: "server",
+                cfFunction: "serverCfFunction",
+                edgeFunction: "edgeServer",
+                origin: "staticsServer",
+            }, ...readdirSync(join(sitePath, buildMeta.clientBuildOutputDir)).map((item) => ({
+                cacheType: "static",
+                pattern: statSync(join(sitePath, buildMeta.clientBuildOutputDir, item)).isDirectory()
+                    ? `${item}/*`
+                    : item,
+                origin: "staticsServer",
+            })));
+        }
+        else {
+            plan.origins.regionalServer = {
+                type: "function",
+                constructId: "ServerFunction",
+                function: serverConfig,
+                streaming: regional?.streaming,
+            };
+            plan.origins.fallthroughServer = {
+                type: "group",
+                primaryOriginName: "staticsServer",
+                fallbackOriginName: "regionalServer",
+                fallbackStatusCodes: [403, 404],
+            };
+            plan.behaviors.push({
+                cacheType: "server",
+                cfFunction: "serverCfFunction",
+                origin: "fallthroughServer",
+                allowedMethods: AllowedMethods.ALLOW_GET_HEAD_OPTIONS,
+            }, {
+                cacheType: "static",
+                pattern: `${buildMeta.clientBuildVersionedSubDir}/*`,
+                origin: "staticsServer",
+            }, ...(regional?.serverRoutes ?? []).map((route) => ({
+                cacheType: "server",
+                pattern: route,
+                origin: "regionalServer",
+            })));
+            const notFoundRoute = buildMeta.routes.find(({ route, type }) => route.match(/^\/404\/?$/) && type === "page");
+            if (notFoundRoute) {
+                plan.errorResponses?.push({
+                    httpStatus: 404,
+                    responsePagePath: "/404.html",
+                    responseHttpStatus: 404,
+                });
+            }
+        }
+        return this.validatePlan(plan);
     }
     getConstructMetadata() {
         return {

package/constructs/NextjsSite.d.ts

@@ -1,6 +1,6 @@
 import { Construct } from "constructs";
 import { Runtime, FunctionProps, Architecture } from "aws-cdk-lib/aws-lambda";
-import { SsrSite, SsrSiteProps } from "./SsrSite.js";
+import { SsrSite, SsrSiteNormalizedProps, SsrSiteProps } from "./SsrSite.js";
 import { Size } from "./util/size.js";
 import { Bucket } from "aws-cdk-lib/aws-s3";
 export interface NextjsSiteProps extends Omit<SsrSiteProps, "nodejs"> {
@@ -10,11 +10,49 @@ export interface NextjsSiteProps extends Omit<SsrSiteProps, "nodejs"> {
          * @default 1024 MB
          * @example
          * ```js
-         * memorySize: "512 MB",
+         * imageOptimization: {
+         *   memorySize: "512 MB",
+         * }
          * ```
          */
         memorySize?: number | Size;
     };
+    experimental?: {
+        /**
+         * Enable streaming. Currently an experimental feature in OpenNext.
+         * @default false
+         * @example
+         * ```js
+         * experimental: {
+         *   streaming: true,
+         * }
+         * ```
+         */
+        streaming?: boolean;
+        /**
+         * Disabling incremental cache will cause the entire page to be revalidated on each request. This can result in ISR and SSG pages to be in an inconsistent state. Specify this option if you are using SSR pages only.
+         *
+         * Note that it is possible to disable incremental cache while leaving on-demand revalidation enabled.
+         * @default false
+         * @example
+         * ```js
+         * experimental: {
+         *   disableIncrementalCache: true,
+         * }
+         */
+        disableIncrementalCache?: boolean;
+        /**
+         * Disabling DynamoDB cache will cause on-demand revalidation by path (`revalidatePath`) and by cache tag (`revalidateTag`) to fail silently.
+         * @default false
+         * @example
+         * ```js
+         * experimental: {
+         *   disableDynamoDBCache: true,
+         * }
+         * ```
+         */
+        disableDynamoDBCache?: boolean;
+    };
     cdk?: SsrSiteProps["cdk"] & {
         revalidation?: Pick<FunctionProps, "vpc" | "vpcSubnets">;
         /**
@@ -47,6 +85,7 @@ export interface NextjsSiteProps extends Omit<SsrSiteProps, "nodejs"> {
         serverCachePolicy?: NonNullable<SsrSiteProps["cdk"]>["serverCachePolicy"];
     };
 }
+type NextjsSiteNormalizedProps = NextjsSiteProps & SsrSiteNormalizedProps;
 /**
  * The `NextjsSite` construct is a higher level CDK construct that makes it easy to create a Next.js app.
  * @example
@@ -59,13 +98,7 @@ export interface NextjsSiteProps extends Omit<SsrSiteProps, "nodejs"> {
  * ```
  */
 export declare class NextjsSite extends SsrSite {
-    protected props: NextjsSiteProps & {
-        path: Exclude<NextjsSiteProps["path"], undefined>;
-        runtime: Exclude<NextjsSiteProps["runtime"], undefined>;
-        timeout: Exclude<NextjsSiteProps["timeout"], undefined>;
-        memorySize: Exclude<NextjsSiteProps["memorySize"], undefined>;
-        waitForInvalidation: Exclude<NextjsSiteProps["waitForInvalidation"], undefined>;
-    };
+    props: NextjsSiteNormalizedProps;
     constructor(scope: Construct, id: string, props?: NextjsSiteProps);
     protected plan(bucket: Bucket): {
         cloudFrontFunctions?: {
@@ -134,22 +167,27 @@ export declare class NextjsSite extends SsrSite {
                         CACHE_BUCKET_REGION: string;
                     };
                 };
+                streaming: boolean | undefined;
             } | undefined;
         };
         behaviors: {
             cacheType: "server" | "static";
             pattern?: string | undefined;
             origin: "s3" | "regionalServer" | "imageOptimizer";
+            allowedMethods?: import("aws-cdk-lib/aws-cloudfront").AllowedMethods | undefined;
             cfFunction?: "serverCfFunction" | undefined;
             edgeFunction?: "edgeServer" | undefined;
         }[];
+        errorResponses?: import("aws-cdk-lib/aws-cloudfront").ErrorResponse[] | undefined;
         cachePolicyAllowedHeaders?: string[] | undefined;
         buildId?: string | undefined;
         warmerConfig?: {
             function: string;
+            schedule?: import("aws-cdk-lib/aws-events").Schedule | undefined;
         } | undefined;
     };
-    protected createRevalidation(): void;
+    private createRevalidationQueue;
+    private createRevalidationTable;
     getConstructMetadata(): {
         data: {
             mode: "placeholder" | "deployed";
@@ -164,3 +202,4 @@ export declare class NextjsSite extends SsrSite {
         type: "NextjsSite";
     };
 }
+export {};

package/constructs/NextjsSite.js

@@ -1,12 +1,16 @@
 import fs from "fs";
 import path from "path";
-import { Duration as CdkDuration } from "aws-cdk-lib/core";
+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 { 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";
 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 { RetentionDays } from "aws-cdk-lib/aws-logs";
 /**
  * The `NextjsSite` construct is a higher level CDK construct that makes it easy to create a Next.js app.
  * @example
@@ -20,14 +24,34 @@ import { toCdkSize } from "./util/size.js";
  */
 export class NextjsSite extends SsrSite {
     constructor(scope, id, props) {
+        const { streaming, disableDynamoDBCache, disableIncrementalCache } = {
+            streaming: false,
+            disableDynamoDBCache: false,
+            disableIncrementalCache: false,
+            ...props?.experimental,
+        };
         super(scope, id, {
-            buildCommand: "npx --yes open-next@2.1.5 build",
+            buildCommand: [
+                "npx --yes open-next@2.2.1 build",
+                ...(streaming ? ["--streaming"] : []),
+                ...(disableDynamoDBCache
+                    ? ["--dangerously-disable-dynamodb-cache"]
+                    : []),
+                ...(disableIncrementalCache
+                    ? ["--dangerously-disable-incremental-cache"]
+                    : []),
+            ].join(" "),
             ...props,
         });
-        this.createRevalidation();
+        if (!disableIncrementalCache) {
+            this.createRevalidationQueue();
+            if (!disableDynamoDBCache) {
+                this.createRevalidationTable();
+            }
+        }
     }
     plan(bucket) {
-        const { path: sitePath, edge, imageOptimization } = this.props;
+        const { path: sitePath, edge, experimental, imageOptimization, } = this.props;
         const serverConfig = {
             description: "Next.js server",
             bundle: path.join(sitePath, ".open-next", "server-function"),
@@ -61,6 +85,7 @@ export class NextjsSite extends SsrSite {
                             type: "function",
                             constructId: "ServerFunction",
                             function: serverConfig,
+                            streaming: experimental?.streaming,
                         },
                     }),
                 imageOptimizer: {
@@ -172,10 +197,11 @@ export class NextjsSite extends SsrSite {
             },
         });
     }
-    createRevalidation() {
+    createRevalidationQueue() {
         if (!this.serverFunction)
             return;
         const { cdk } = this.props;
+        const server = this.serverFunction;
         const queue = new Queue(this, "RevalidationQueue", {
             fifo: true,
             receiveMessageWaitTime: CdkDuration.seconds(20),
@@ -190,10 +216,64 @@ export class NextjsSite extends SsrSite {
         });
         consumer.addEventSource(new SqsEventSource(queue, { batchSize: 5 }));
         // Allow server to send messages to the queue
+        server.addEnvironment("REVALIDATION_QUEUE_URL", queue.queueUrl);
+        server.addEnvironment("REVALIDATION_QUEUE_REGION", Stack.of(this).region);
+        queue.grantSendMessages(server.role);
+    }
+    createRevalidationTable() {
+        if (!this.serverFunction)
+            return;
+        const { path: sitePath } = this.props;
         const server = this.serverFunction;
-        server?.addEnvironment("REVALIDATION_QUEUE_URL", queue.queueUrl);
-        server?.addEnvironment("REVALIDATION_QUEUE_REGION", Stack.of(this).region);
-        queue.grantSendMessages(server?.role);
+        const table = new Table(this, "RevalidationTable", {
+            partitionKey: { name: "tag", type: AttributeType.STRING },
+            sortKey: { name: "path", type: AttributeType.STRING },
+            pointInTimeRecovery: true,
+            billing: Billing.onDemand(),
+            globalSecondaryIndexes: [
+                {
+                    indexName: "revalidate",
+                    partitionKey: { name: "path", type: AttributeType.STRING },
+                    sortKey: { name: "revalidatedAt", type: AttributeType.NUMBER },
+                },
+            ],
+            removalPolicy: RemovalPolicy.DESTROY,
+        });
+        server?.addEnvironment("CACHE_DYNAMO_TABLE", table.tableName);
+        table.grantReadWriteData(server.role);
+        const dynamodbProviderPath = path.join(sitePath, ".open-next", "dynamodb-provider");
+        if (fs.existsSync(dynamodbProviderPath)) {
+            const insertFn = new CdkFunction(this, "RevalidationInsertFunction", {
+                description: "Next.js revalidation data insert",
+                handler: "index.handler",
+                code: Code.fromAsset(dynamodbProviderPath),
+                runtime: Runtime.NODEJS_18_X,
+                timeout: CdkDuration.minutes(15),
+                initialPolicy: [
+                    new PolicyStatement({
+                        actions: [
+                            "dynamodb:BatchWriteItem",
+                            "dynamodb:PutItem",
+                            "dynamodb:DescribeTable",
+                        ],
+                        resources: [table.tableArn],
+                    }),
+                ],
+                environment: {
+                    CACHE_DYNAMO_TABLE: table.tableName,
+                },
+            });
+            const provider = new Provider(this, "RevalidationProvider", {
+                onEventHandler: insertFn,
+                logRetention: RetentionDays.ONE_DAY,
+            });
+            new CustomResource(this, "RevalidationResource", {
+                serviceToken: provider.serviceToken,
+                properties: {
+                    version: Date.now().toString(),
+                },
+            });
+        }
     }
     getConstructMetadata() {
         return {

package/constructs/RemixSite.d.ts

@@ -69,13 +69,16 @@ export declare class RemixSite extends SsrSite {
             cacheType: "server" | "static";
             pattern?: string | undefined;
             origin: "s3" | "regionalServer";
+            allowedMethods?: import("aws-cdk-lib/aws-cloudfront").AllowedMethods | undefined;
             cfFunction?: "serverCfFunction" | "staticCfFunction" | undefined;
             edgeFunction?: "edgeServer" | undefined;
         }[];
+        errorResponses?: import("aws-cdk-lib/aws-cloudfront").ErrorResponse[] | undefined;
         cachePolicyAllowedHeaders?: string[] | undefined;
         buildId?: string | undefined;
         warmerConfig?: {
             function: string;
+            schedule?: import("aws-cdk-lib/aws-events").Schedule | undefined;
         } | undefined;
     };
     protected getServerModuleFormat(): "cjs" | "esm";

package/constructs/Service.d.ts

@@ -1,4 +1,5 @@
 import { Construct } from "constructs";
+import { DistributionProps } from "aws-cdk-lib/aws-cloudfront";
 import { DistributionDomainProps } from "./Distribution.js";
 import { SSTConstruct } from "./Construct.js";
 import { Permissions } from "./util/permission.js";
@@ -18,6 +19,8 @@ declare const supportedCpus: {
 };
 export interface ServiceDomainProps extends DistributionDomainProps {
 }
+export interface ServiceCdkDistributionProps extends Omit<DistributionProps, "defaultBehavior"> {
+}
 export interface ServiceProps {
     /**
      * Path to the directory where the app is located.
@@ -272,7 +275,7 @@ export interface ServiceProps {
     };
     cdk?: {
         /**
-         * By default, SST creates a CloudFront distribution. Set this to `false` to skip creating the distribution.
+         * By default, SST creates a CloudFront distribution. Pass in a value to override the default settings this construct uses to create the CDK `Distribution` internally. Alternatively, set this to `false` to skip creating the distribution.
          * @default true
          * @example
          * ```js
@@ -283,7 +286,7 @@ export interface ServiceProps {
          * }
          * ```
          */
-        cloudfrontDistribution?: boolean;
+        cloudfrontDistribution?: boolean | ServiceCdkDistributionProps;
         /**
          * By default, SST creates an Application Load Balancer to distribute requests across containers. Set this to `false` to skip creating the load balancer.
          * @default true

package/constructs/Service.js

@@ -517,6 +517,9 @@ export class Service extends Construct {
                         cachePolicy,
                         originRequestPolicy: OriginRequestPolicy.ALL_VIEWER,
                     },
+                    ...(cdk?.cloudfrontDistribution === true
+                        ? {}
+                        : cdk?.cloudfrontDistribution),
                 },
             },
         });

package/constructs/SolidStartSite.d.ts

@@ -51,13 +51,16 @@ export declare class SolidStartSite extends SsrSite {
             cacheType: "server" | "static";
             pattern?: string | undefined;
             origin: "s3" | "regionalServer";
+            allowedMethods?: import("aws-cdk-lib/aws-cloudfront").AllowedMethods | undefined;
             cfFunction?: "serverCfFunction" | undefined;
             edgeFunction?: "edgeServer" | undefined;
         }[];
+        errorResponses?: import("aws-cdk-lib/aws-cloudfront").ErrorResponse[] | undefined;
         cachePolicyAllowedHeaders?: string[] | undefined;
         buildId?: string | undefined;
         warmerConfig?: {
             function: string;
+            schedule?: import("aws-cdk-lib/aws-events").Schedule | undefined;
         } | undefined;
     };
     getConstructMetadata(): {

package/constructs/SsrFunction.js

@@ -32,9 +32,9 @@ export class SsrFunction extends Construct {
         super(scope, id);
         this.id = id;
         this.props = {
-            ...props,
             timeout: 10,
             memorySize: 1024,
+            ...props,
             environment: props.environment || {},
             permissions: props.permissions || [],
         };

package/constructs/SsrSite.d.ts

@@ -1,7 +1,8 @@
 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, IDistribution } from "aws-cdk-lib/aws-cloudfront";
+import { ICachePolicy, IResponseHeadersPolicy, AllowedMethods, 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";
@@ -40,6 +41,13 @@ type S3OriginConfig = {
         versionedSubDir?: string;
     }[];
 };
+type OriginGroupConfig = {
+    type: "group";
+    primaryOriginName: string;
+    fallbackOriginName: string;
+    fallbackStatusCodes?: number[];
+};
+export type Plan = ReturnType<SsrSite["validatePlan"]>;
 export interface SsrSiteNodeJSProps extends NodeJSProps {
 }
 export interface SsrDomainProps extends DistributionDomainProps {
@@ -68,6 +76,11 @@ export interface SsrSiteProps {
      * @default "."
      */
     path?: string;
+    /**
+     * Path relative to the app location where the type definitions are located.
+     * @default "."
+     */
+    typesPath?: string;
     /**
      * The command for building the website
      * @default `npm run build`
@@ -292,8 +305,9 @@ export interface SsrSiteProps {
      */
     fileOptions?: SsrSiteFileOptions[];
 }
-type SsrSiteNormalizedProps = SsrSiteProps & {
+export type SsrSiteNormalizedProps = SsrSiteProps & {
     path: Exclude<SsrSiteProps["path"], undefined>;
+    typesPath: Exclude<SsrSiteProps["typesPath"], undefined>;
     runtime: Exclude<SsrSiteProps["runtime"], undefined>;
     timeout: Exclude<SsrSiteProps["timeout"], undefined>;
     memorySize: Exclude<SsrSiteProps["memorySize"], undefined>;
@@ -314,7 +328,6 @@ export declare abstract class SsrSite extends Construct implements SSTConstruct
     readonly id: string;
     protected props: SsrSiteNormalizedProps;
     protected doNotDeploy: boolean;
-    protected typesPath: string;
     protected bucket: Bucket;
     protected serverFunction?: EdgeFunction | SsrFunction;
     private serverFunctionForDev?;
@@ -335,7 +348,7 @@ export declare abstract class SsrSite extends Construct implements SSTConstruct
     get cdk(): {
         function: import("aws-cdk-lib/aws-lambda").IFunction | CdkFunction | undefined;
         bucket: Bucket;
-        distribution: IDistribution;
+        distribution: import("aws-cdk-lib/aws-cloudfront").IDistribution;
         hostedZone: import("aws-cdk-lib/aws-route53").IHostedZone | undefined;
         certificate: import("aws-cdk-lib/aws-certificatemanager").ICertificate | undefined;
     } | undefined;
@@ -367,7 +380,7 @@ export declare abstract class SsrSite extends Construct implements SSTConstruct
     getFunctionBinding(): FunctionBindingProps;
     protected useCloudFrontFunctionHostHeaderInjection(): string;
     protected abstract plan(bucket: Bucket): ReturnType<typeof this.validatePlan>;
-    protected validatePlan<CloudFrontFunctions extends Record<string, CloudFrontFunctionConfig>, EdgeFunctions extends Record<string, EdgeFunctionConfig>, Origins extends Record<string, FunctionOriginConfig | ImageOptimizationFunctionOriginConfig | S3OriginConfig>>(input: {
+    protected validatePlan<CloudFrontFunctions extends Record<string, CloudFrontFunctionConfig>, EdgeFunctions extends Record<string, EdgeFunctionConfig>, Origins extends Record<string, FunctionOriginConfig | ImageOptimizationFunctionOriginConfig | S3OriginConfig | OriginGroupConfig>>(input: {
         cloudFrontFunctions?: CloudFrontFunctions;
         edgeFunctions?: EdgeFunctions;
         origins: Origins;
@@ -375,13 +388,16 @@ export declare abstract class SsrSite extends Construct implements SSTConstruct
             cacheType: "server" | "static";
             pattern?: string;
             origin: keyof Origins;
+            allowedMethods?: AllowedMethods;
             cfFunction?: keyof CloudFrontFunctions;
             edgeFunction?: keyof EdgeFunctions;
         }[];
+        errorResponses?: ErrorResponse[];
         cachePolicyAllowedHeaders?: string[];
         buildId?: string;
         warmerConfig?: {
             function: string;
+            schedule?: Schedule;
         };
     }): {
         cloudFrontFunctions?: CloudFrontFunctions | undefined;
@@ -391,13 +407,16 @@ export declare abstract class SsrSite extends Construct implements SSTConstruct
             cacheType: "server" | "static";
             pattern?: string;
             origin: keyof Origins;
+            allowedMethods?: AllowedMethods;
             cfFunction?: keyof CloudFrontFunctions;
             edgeFunction?: keyof EdgeFunctions;
         }[];
+        errorResponses?: ErrorResponse[] | undefined;
         cachePolicyAllowedHeaders?: string[] | undefined;
         buildId?: string | undefined;
         warmerConfig?: {
             function: string;
+            schedule?: Schedule | undefined;
         } | undefined;
     };
 }

package/constructs/SsrSite.js

@@ -13,7 +13,7 @@ import { Function as CdkFunction, Code, Runtime, FunctionUrlAuthType, InvokeMode
 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 } from "aws-cdk-lib/aws-cloudfront-origins";
+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";
 import { Stack } from "./Stack.js";
@@ -47,7 +47,6 @@ export class SsrSite extends Construct {
     id;
     props;
     doNotDeploy;
-    typesPath = ".";
     bucket;
     serverFunction;
     serverFunctionForDev;
@@ -56,6 +55,7 @@ export class SsrSite extends Construct {
         super(scope, rawProps?.cdk?.id || id);
         const props = {
             path: ".",
+            typesPath: ".",
             waitForInvalidation: false,
             runtime: "nodejs18.x",
             timeout: "10 seconds",
@@ -67,11 +67,11 @@ export class SsrSite extends Construct {
         const app = scope.node.root;
         const stack = Stack.of(this);
         const self = this;
-        const { path: sitePath, 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, nodejs, permissions, environment, bind, customDomain, waitForInvalidation, fileOptions, warm, cdk, } = props;
         this.doNotDeploy = !stack.isActive || (app.mode === "dev" && !dev?.deploy);
         validateSiteExists();
         validateTimeout();
-        writeTypesFile(this.typesPath);
+        writeTypesFile(typesPath);
         useSites().add(stack.stackName, id, this.constructor.name, props);
         if (this.doNotDeploy) {
             // @ts-expect-error
@@ -211,13 +211,13 @@ export class SsrSite extends Construct {
                 return;
             // Create warmer function
             const warmer = new CdkFunction(self, "WarmerFunction", {
-                description: "Next.js warmer",
+                description: "SSR warmer",
                 code: Code.fromAsset(plan.warmerConfig?.function ??
                     path.join(__dirname, "../support/ssr-warmer")),
                 runtime: Runtime.NODEJS_18_X,
                 handler: "index.handler",
                 timeout: CdkDuration.minutes(15),
-                memorySize: 1024,
+                memorySize: 128,
                 environment: {
                     FUNCTION_NAME: ssrFunctions[0].functionName,
                     CONCURRENCY: warm.toString(),
@@ -226,7 +226,7 @@ export class SsrSite extends Construct {
             ssrFunctions[0].grantInvoke(warmer);
             // Create cron job
             new Rule(self, "WarmerRule", {
-                schedule: Schedule.rate(CdkDuration.minutes(5)),
+                schedule: plan.warmerConfig?.schedule ?? Schedule.rate(CdkDuration.minutes(5)),
                 targets: [new LambdaFunction(warmer, { retryAttempts: 0 })],
             });
             // Create custom resource to prewarm on deploy
@@ -272,6 +272,7 @@ export class SsrSite extends Construct {
                             }, {}),
                             ...(cdk?.distribution?.additionalBehaviors || {}),
                         },
+                        errorResponses: plan.errorResponses,
                     },
                 },
             });
@@ -300,7 +301,7 @@ export class SsrSite extends Construct {
                 return {
                     origin,
                     viewerProtocolPolicy: ViewerProtocolPolicy.REDIRECT_TO_HTTPS,
-                    allowedMethods: AllowedMethods.ALLOW_GET_HEAD_OPTIONS,
+                    allowedMethods: behavior.allowedMethods ?? AllowedMethods.ALLOW_GET_HEAD_OPTIONS,
                     cachedMethods: CachedMethods.CACHE_GET_HEAD_OPTIONS,
                     compress: true,
                     cachePolicy: CachePolicy.CACHING_OPTIMIZED,
@@ -319,7 +320,7 @@ export class SsrSite extends Construct {
                 return {
                     viewerProtocolPolicy: ViewerProtocolPolicy.REDIRECT_TO_HTTPS,
                     origin,
-                    allowedMethods: AllowedMethods.ALLOW_ALL,
+                    allowedMethods: behavior.allowedMethods ?? AllowedMethods.ALLOW_ALL,
                     cachedMethods: CachedMethods.CACHE_GET_HEAD_OPTIONS,
                     compress: true,
                     cachePolicy: cdk?.serverCachePolicy ?? useServerBehaviorCachePolicy(),
@@ -405,99 +406,120 @@ function handler(event) {
             });
             return functions;
         }
+        function createS3Origin(props) {
+            const s3Origin = new S3Origin(bucket, {
+                originPath: "/" + (props.originPath ?? ""),
+            });
+            const assets = createS3OriginAssets(props.copy);
+            const assetFileOptions = fileOptions || createS3OriginAssetFileOptions(props.copy);
+            const s3deployCR = createS3OriginDeployment(assets, assetFileOptions);
+            s3DeployCRs.push(s3deployCR);
+            return s3Origin;
+        }
+        function createFunctionOrigin(props) {
+            const fn = new SsrFunction(self, props.constructId, {
+                runtime,
+                timeout,
+                memorySize,
+                bind,
+                permissions,
+                ...props.function,
+                nodejs: {
+                    format: "esm",
+                    ...nodejs,
+                    ...props.function.nodejs,
+                    esbuild: {
+                        ...nodejs?.esbuild,
+                        ...props.function.nodejs?.esbuild,
+                    },
+                },
+                environment: {
+                    ...environment,
+                    ...props.function.environment,
+                },
+                ...cdk?.server,
+            });
+            ssrFunctions.push(fn);
+            bucket.grantReadWrite(fn?.role);
+            const fnUrl = fn.addFunctionUrl({
+                authType: regional?.enableServerUrlIamAuth
+                    ? FunctionUrlAuthType.AWS_IAM
+                    : FunctionUrlAuthType.NONE,
+                invokeMode: props.streaming
+                    ? InvokeMode.RESPONSE_STREAM
+                    : InvokeMode.BUFFERED,
+            });
+            if (regional?.enableServerUrlIamAuth) {
+                useFunctionUrlSigningFunction().attachPermissions([
+                    new PolicyStatement({
+                        actions: ["lambda:InvokeFunctionUrl"],
+                        resources: [fn.functionArn],
+                    }),
+                ]);
+            }
+            return new HttpOrigin(Fn.parseDomainName(fnUrl.url), {
+                readTimeout: typeof timeout === "string"
+                    ? toCdkDuration(timeout)
+                    : CdkDuration.seconds(timeout),
+            });
+        }
+        function createOriginGroup(props, origins) {
+            return new OriginGroup({
+                primaryOrigin: origins[props.primaryOriginName],
+                fallbackOrigin: origins[props.fallbackOriginName],
+                fallbackStatusCodes: props.fallbackStatusCodes,
+            });
+        }
+        function createImageOptimizationFunctionOrigin(props) {
+            const fn = new CdkFunction(self, `ImageFunction`, {
+                currentVersionOptions: {
+                    removalPolicy: RemovalPolicy.DESTROY,
+                },
+                logRetention: RetentionDays.THREE_DAYS,
+                timeout: CdkDuration.seconds(25),
+                initialPolicy: [
+                    new PolicyStatement({
+                        actions: ["s3:GetObject"],
+                        resources: [bucket.arnForObjects("*")],
+                    }),
+                ],
+                ...props.function,
+            });
+            const fnUrl = fn.addFunctionUrl({
+                authType: regional?.enableServerUrlIamAuth
+                    ? FunctionUrlAuthType.AWS_IAM
+                    : FunctionUrlAuthType.NONE,
+            });
+            if (regional?.enableServerUrlIamAuth) {
+                useFunctionUrlSigningFunction().attachPermissions([
+                    new PolicyStatement({
+                        actions: ["lambda:InvokeFunctionUrl"],
+                        resources: [fn.functionArn],
+                    }),
+                ]);
+            }
+            return new HttpOrigin(Fn.parseDomainName(fnUrl.url));
+        }
         function createOrigins() {
             const origins = {};
+            // Create non-group origins
             Object.entries(plan.origins ?? {}).forEach(([name, props]) => {
-                if (!props)
-                    return;
-                // S3 Origin
-                if (props.type === "s3") {
-                    origins[name] = new S3Origin(bucket, {
-                        originPath: "/" + (props.originPath ?? ""),
-                    });
-                    const assets = createS3OriginAssets(props.copy);
-                    const assetFileOptions = fileOptions || createS3OriginAssetFileOptions(props.copy);
-                    const s3deployCR = createS3OriginDeployment(assets, assetFileOptions);
-                    s3DeployCRs.push(s3deployCR);
+                switch (props.type) {
+                    case "s3":
+                        origins[name] = createS3Origin(props);
+                        break;
+                    case "function":
+                        origins[name] = createFunctionOrigin(props);
+                        break;
+                    case "image-optimization-function":
+                        origins[name] = createImageOptimizationFunctionOrigin(props);
+                        break;
                 }
-                // Server Origin
-                else if (props.type === "function") {
-                    const fn = new SsrFunction(self, props.constructId, {
-                        runtime,
-                        timeout,
-                        memorySize,
-                        bind,
-                        permissions,
-                        ...props.function,
-                        nodejs: {
-                            format: "esm",
-                            ...nodejs,
-                            ...props.function.nodejs,
-                            esbuild: {
-                                ...nodejs?.esbuild,
-                                ...props.function.nodejs?.esbuild,
-                            },
-                        },
-                        environment: {
-                            ...environment,
-                            ...props.function.environment,
-                        },
-                        ...cdk?.server,
-                    });
-                    ssrFunctions.push(fn);
-                    bucket.grantReadWrite(fn?.role);
-                    const fnUrl = fn.addFunctionUrl({
-                        authType: regional?.enableServerUrlIamAuth
-                            ? FunctionUrlAuthType.AWS_IAM
-                            : FunctionUrlAuthType.NONE,
-                        invokeMode: props.streaming
-                            ? InvokeMode.RESPONSE_STREAM
-                            : undefined,
-                    });
-                    if (regional?.enableServerUrlIamAuth) {
-                        useFunctionUrlSigningFunction().attachPermissions([
-                            new PolicyStatement({
-                                actions: ["lambda:InvokeFunctionUrl"],
-                                resources: [fn.functionArn],
-                            }),
-                        ]);
-                    }
-                    origins[name] = new HttpOrigin(Fn.parseDomainName(fnUrl.url), {
-                        readTimeout: typeof timeout === "string"
-                            ? toCdkDuration(timeout)
-                            : CdkDuration.seconds(timeout),
-                    });
-                }
-                // Image Optimization Origin
-                else if (props.type === "image-optimization-function") {
-                    const fn = new CdkFunction(self, `ImageFunction`, {
-                        currentVersionOptions: {
-                            removalPolicy: RemovalPolicy.DESTROY,
-                        },
-                        logRetention: RetentionDays.THREE_DAYS,
-                        timeout: CdkDuration.seconds(25),
-                        initialPolicy: [
-                            new PolicyStatement({
-                                actions: ["s3:GetObject"],
-                                resources: [bucket.arnForObjects("*")],
-                            }),
-                        ],
-                        ...props.function,
-                    });
-                    const fnUrl = fn.addFunctionUrl({
-                        authType: regional?.enableServerUrlIamAuth
-                            ? FunctionUrlAuthType.AWS_IAM
-                            : FunctionUrlAuthType.NONE,
-                    });
-                    if (regional?.enableServerUrlIamAuth) {
-                        useFunctionUrlSigningFunction().attachPermissions([
-                            new PolicyStatement({
-                                actions: ["lambda:InvokeFunctionUrl"],
-                                resources: [fn.functionArn],
-                            }),
-                        ]);
-                    }
-                    origins[name] = new HttpOrigin(Fn.parseDomainName(fnUrl.url));
+            });
+            // Create group origins
+            Object.entries(plan.origins ?? {}).forEach(([name, props]) => {
+                if (props.type === "group") {
+                    origins[name] = createOriginGroup(props, origins);
                 }
             });
             return origins;

package/constructs/SvelteKitSite.d.ts

@@ -83,13 +83,16 @@ export declare class SvelteKitSite extends SsrSite {
             cacheType: "server" | "static";
             pattern?: string | undefined;
             origin: "s3" | "regionalServer";
+            allowedMethods?: import("aws-cdk-lib/aws-cloudfront").AllowedMethods | undefined;
             cfFunction?: "serverCfFunction" | undefined;
             edgeFunction?: "edgeServer" | undefined;
         }[];
+        errorResponses?: import("aws-cdk-lib/aws-cloudfront").ErrorResponse[] | undefined;
         cachePolicyAllowedHeaders?: string[] | undefined;
         buildId?: string | undefined;
         warmerConfig?: {
             function: string;
+            schedule?: import("aws-cdk-lib/aws-events").Schedule | undefined;
         } | undefined;
     };
     getConstructMetadata(): {

package/node/graphql/index.d.ts

@@ -9,7 +9,7 @@ export declare function GraphQLHandler<UserContext extends {}>(options: YogaServ
     headers: {
         [k: string]: string;
     };
-    body: string;
+    body: any;
     isBase64Encoded: boolean;
 }>;
 export {};

package/package.json

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

package/support/ssr-warmer/index.mjs

@@ -34178,15 +34178,13 @@ async function handler(_event, context) {
           new import_client_lambda.InvokeCommand({
             FunctionName: FUNCTION_NAME,
             InvocationType: "RequestResponse",
-            Payload: Buffer.from(
-              JSON.stringify({
-                type: "warmer",
-                warmerId,
-                index: i,
-                concurrency: CONCURRENCY,
-                delay: 75
-              })
-            )
+            Payload: JSON.stringify({
+              type: "warmer",
+              warmerId,
+              index: i,
+              concurrency: CONCURRENCY,
+              delay: 75
+            })
           })
         );
       } catch (e) {
@@ -34200,10 +34198,15 @@ async function handler(_event, context) {
       console.error(`failed to warm up #${i}:`, r?.Payload?.toString());
       return;
     }
-    const payload = JSON.parse(
-      Buffer.from(r.Payload).toString()
-    );
-    warmedServerIds.push(payload.serverId);
+    const payloadString = r.Payload.transformToString();
+    if (payloadString) {
+      const payload = JSON.parse(
+        r.Payload.transformToString()
+      );
+      warmedServerIds.push(payload.serverId);
+    } else {
+      warmedServerIds.push("unknown");
+    }
   });
   console.log({
     event: "warmer result",