sst 2.26.10 → 2.27.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 { BUILD_META_FILE_NAME } from "astro-sst/build-meta";
+import { SsrSite, } from "./SsrSite.js";
+import { AllowedMethods } from "aws-cdk-lib/aws-cloudfront";
 /**
  * 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"> {
@@ -47,6 +47,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 +60,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?: {
@@ -140,13 +135,16 @@ export declare class NextjsSite extends SsrSite {
             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;
@@ -164,3 +162,4 @@ export declare class NextjsSite extends SsrSite {
         type: "NextjsSite";
     };
 }
+export {};

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

@@ -4,7 +4,7 @@ import { SSTConstruct } from "./Construct.js";
 import { Permissions } from "./util/permission.js";
 import { FunctionBindingProps } from "./util/functionBinding.js";
 import { IVpc } from "aws-cdk-lib/aws-ec2";
-import { Cluster, ContainerDefinitionOptions, CpuArchitecture, FargateServiceProps } from "aws-cdk-lib/aws-ecs";
+import { Cluster, ContainerDefinitionOptions, CpuArchitecture, FargateService, FargateTaskDefinition, FargateServiceProps } from "aws-cdk-lib/aws-ecs";
 import { RetentionDays } from "aws-cdk-lib/aws-logs";
 import { ApplicationTargetGroupProps } from "aws-cdk-lib/aws-elasticloadbalancingv2";
 declare const supportedCpus: {
@@ -394,6 +394,7 @@ export declare class Service extends Construct implements SSTConstruct {
     private cluster;
     private container;
     private taskDefinition;
+    private service;
     private distribution?;
     constructor(scope: Construct, id: string, props?: ServiceProps);
     /**
@@ -411,6 +412,8 @@ export declare class Service extends Construct implements SSTConstruct {
     get cdk(): {
         vpc: IVpc;
         cluster: Cluster;
+        fargateService: FargateService;
+        taskDefinition: FargateTaskDefinition;
         distribution: import("aws-cdk-lib/aws-cloudfront").IDistribution | undefined;
         hostedZone: import("aws-cdk-lib/aws-route53").IHostedZone | undefined;
         certificate: import("aws-cdk-lib/aws-certificatemanager").ICertificate | undefined;

package/constructs/Service.js

@@ -145,6 +145,7 @@ export class Service extends Construct {
     cluster;
     container;
     taskDefinition;
+    service;
     distribution;
     constructor(scope, id, props) {
         super(scope, id);
@@ -168,7 +169,9 @@ export class Service extends Construct {
         useServices().add(stack.stackName, id, this.props);
         if (this.doNotDeploy) {
             // @ts-expect-error
-            this.vpc = this.cluster = this.container = this.taskDefinition = null;
+            this.vpc = this.cluster = null;
+            // @ts-expect-error
+            this.service = this.container = this.taskDefinition = null;
             // @ts-expect-error
             this.distribution = null;
             this.devFunction = this.createDevFunction();
@@ -184,6 +187,7 @@ export class Service extends Construct {
         this.distribution = this.createDistribution(alb);
         this.vpc = vpc;
         this.cluster = cluster;
+        this.service = service;
         this.container = container;
         this.taskDefinition = taskDefinition;
         this.bindForService(props?.bind || []);
@@ -244,6 +248,8 @@ export class Service extends Construct {
         return {
             vpc: this.vpc,
             cluster: this.cluster,
+            fargateService: this.service,
+            taskDefinition: this.taskDefinition,
             distribution: this.distribution?.cdk.distribution,
             hostedZone: this.distribution?.cdk.hostedZone,
             certificate: this.distribution?.cdk.certificate,

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.10",
+  "version": "2.27.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.27.0",
     "tsx": "^3.12.1",
     "typescript": "^5.2.2",
     "vitest": "^0.33.0"

package/project.d.ts

@@ -57,6 +57,7 @@ interface Project {
     metafile: Metafile;
     stacks: SSTConfig["stacks"];
 }
+export declare function setProject(p: Project): void;
 export declare function useProject(): Project;
 interface GlobalOptions {
     profile?: string;

package/project.js

@@ -13,6 +13,9 @@ const DEFAULTS = {
     ssmPrefix: undefined,
 };
 let project;
+export function setProject(p) {
+    project = p;
+}
 export function useProject() {
     if (!project)
         throw new Error("Project not initialized");

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",