sst 2.22.11 → 2.23.1

package/constructs/BaseSite.d.ts

@@ -1,81 +1,10 @@
-import { IHostedZone } from "aws-cdk-lib/aws-route53";
 import { ErrorResponse, DistributionProps, BehaviorOptions, IOrigin } from "aws-cdk-lib/aws-cloudfront";
-import { ICertificate } from "aws-cdk-lib/aws-certificatemanager";
 export interface BaseSiteFileOptions {
     exclude: string | string[];
     include: string | string[];
     cacheControl: string;
     contentType?: string;
 }
-/**
- * The customDomain for this website. SST supports domains that are hosted either on [Route 53](https://aws.amazon.com/route53/) or externally.
- *
- * Note that you can also migrate externally hosted domains to Route 53 by [following this guide](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/MigratingDNS.html).
- *
- * @example
- * ```js
- * new StaticSite(this, "Site", {
- *   path: "path/to/src",
- *   customDomain: "domain.com",
- * });
- * ```
- *
- * @example
- * ```js
- * new StaticSite(this, "Site", {
- *   path: "path/to/src",
- *   customDomain: {
- *     domainName: "domain.com",
- *     domainAlias: "www.domain.com",
- *     hostedZone: "domain.com",
- *   }
- * });
- * ```
- */
-export interface BaseSiteDomainProps {
-    /**
-     * The domain to be assigned to the website URL (ie. domain.com).
-     *
-     * Supports domains that are hosted either on [Route 53](https://aws.amazon.com/route53/) or externally.
-     */
-    domainName: string;
-    /**
-     * An alternative domain to be assigned to the website URL. Visitors to the alias will be redirected to the main domain. (ie. `www.domain.com`).
-     *
-     * Use this to create a `www.` version of your domain and redirect visitors to the root domain.
-     * @default no alias configured
-     */
-    domainAlias?: string;
-    /**
-     * The hosted zone in Route 53 that contains the domain. By default, SST will look for a hosted zone matching the domainName that's passed in.
-     *
-     * Set this option if SST cannot find the hosted zone in Route 53.
-     * @default same as the `domainName`
-     */
-    hostedZone?: string;
-    /**
-     * Specify additional names that should route to the Cloudfront Distribution. Note, certificates for these names will not be automatically generated so the `certificate` option must be specified.
-     * @default `[]`
-     */
-    alternateNames?: string[];
-    /**
-     * Set this option if the domain is not hosted on Amazon Route 53.
-     * @default `false`
-     */
-    isExternalDomain?: boolean;
-    cdk?: {
-        /**
-         * Import the underlying Route 53 hosted zone.
-         */
-        hostedZone?: IHostedZone;
-        /**
-         * Import the certificate for the domain. By default, SST will create a certificate with the domain name. The certificate will be created in the `us-east-1`(N. Virginia) region as required by AWS CloudFront.
-         *
-         * Set this option if you have an existing certificate in the `us-east-1` region in AWS Certificate Manager you want to use.
-         */
-        certificate?: ICertificate;
-    };
-}
 export interface BaseSiteEnvironmentOutputsInfo {
     path: string;
     stack: string;

package/constructs/Distribution.d.ts

@@ -0,0 +1,143 @@
+import { Construct, IConstruct } from "constructs";
+import { CustomResource } from "aws-cdk-lib/core";
+import { IHostedZone } from "aws-cdk-lib/aws-route53";
+import { DistributionProps as CdkDistributionProps, IDistribution } from "aws-cdk-lib/aws-cloudfront";
+import { ICertificate } from "aws-cdk-lib/aws-certificatemanager";
+/**
+ * The customDomain for this website. SST supports domains that are hosted either on [Route 53](https://aws.amazon.com/route53/) or externally.
+ *
+ * Note that you can also migrate externally hosted domains to Route 53 by [following this guide](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/MigratingDNS.html).
+ *
+ * @example
+ * ```js
+ * new StaticSite(this, "Site", {
+ *   path: "path/to/src",
+ *   customDomain: "domain.com",
+ * });
+ * ```
+ *
+ * @example
+ * ```js
+ * new StaticSite(this, "Site", {
+ *   path: "path/to/src",
+ *   customDomain: {
+ *     domainName: "domain.com",
+ *     domainAlias: "www.domain.com",
+ *     hostedZone: "domain.com",
+ *   }
+ * });
+ * ```
+ */
+export interface DistributionDomainProps {
+    /**
+     * The domain to be assigned to the website URL (ie. domain.com).
+     *
+     * Supports domains that are hosted either on [Route 53](https://aws.amazon.com/route53/) or externally.
+     */
+    domainName: string;
+    /**
+     * An alternative domain to be assigned to the website URL. Visitors to the alias will be redirected to the main domain. (ie. `www.domain.com`).
+     *
+     * Use this to create a `www.` version of your domain and redirect visitors to the root domain.
+     * @default no alias configured
+     */
+    domainAlias?: string;
+    /**
+     * The hosted zone in Route 53 that contains the domain. By default, SST will look for a hosted zone matching the domainName that's passed in.
+     *
+     * Set this option if SST cannot find the hosted zone in Route 53.
+     * @default same as the `domainName`
+     */
+    hostedZone?: string;
+    /**
+     * Specify additional names that should route to the Cloudfront Distribution. Note, certificates for these names will not be automatically generated so the `certificate` option must be specified.
+     * @default `[]`
+     */
+    alternateNames?: string[];
+    /**
+     * Set this option if the domain is not hosted on Amazon Route 53.
+     * @default `false`
+     */
+    isExternalDomain?: boolean;
+    cdk?: {
+        /**
+         * Import the underlying Route 53 hosted zone.
+         */
+        hostedZone?: IHostedZone;
+        /**
+         * Import the certificate for the domain. By default, SST will create a certificate with the domain name. The certificate will be created in the `us-east-1`(N. Virginia) region as required by AWS CloudFront.
+         *
+         * Set this option if you have an existing certificate in the `us-east-1` region in AWS Certificate Manager you want to use.
+         */
+        certificate?: ICertificate;
+    };
+}
+export interface DistributionProps {
+    /**
+     * The customDomain for this website. SST supports domains that are hosted
+     * either on [Route 53](https://aws.amazon.com/route53/) or externally.
+     *
+     * Note that you can also migrate externally hosted domains to Route 53 by
+     * [following this guide](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/MigratingDNS.html).
+     *
+     * @example
+     * ```js
+     * customDomain: "domain.com",
+     * ```
+     *
+     * ```js
+     * customDomain: {
+     *   domainName: "domain.com",
+     *   domainAlias: "www.domain.com",
+     *   hostedZone: "domain.com"
+     * },
+     * ```
+     */
+    customDomain?: string | DistributionDomainProps;
+    /**
+     * The SSR function is deployed to Lambda in a single region. Alternatively, you can enable this option to deploy to Lambda@Edge.
+     * @default false
+     */
+    /**
+     * While deploying, SST waits for the CloudFront cache invalidation process to finish. This ensures that the new content will be served once the deploy command finishes. However, this process can sometimes take more than 5 mins. For non-prod environments it might make sense to pass in `false`. That'll skip waiting for the cache to invalidate and speed up the deploy process.
+     * @default false
+     */
+    waitForInvalidation?: boolean;
+    scopeOverride?: IConstruct;
+    cdk: {
+        distribution: CdkDistributionProps | IDistribution;
+    };
+}
+export declare class Distribution extends Construct {
+    private scope;
+    private props;
+    private distribution;
+    private hostedZone?;
+    private certificate?;
+    constructor(scope: Construct, id: string, props: DistributionProps);
+    /**
+     * The CloudFront URL of the website.
+     */
+    get url(): string;
+    /**
+     * If the custom domain is enabled, this is the URL of the website with the
+     * custom domain.
+     */
+    get customDomainUrl(): string | undefined;
+    /**
+     * The internally created CDK resources.
+     */
+    get cdk(): {
+        distribution: IDistribution;
+        hostedZone: IHostedZone | undefined;
+        certificate: ICertificate | undefined;
+    };
+    createInvalidation(buildId?: string): CustomResource;
+    private validateCloudFrontDistributionSettings;
+    private validateCustomDomainSettings;
+    private lookupHostedZone;
+    private createCertificate;
+    private createDistribution;
+    private buildDistributionDomainNames;
+    private createRoute53Records;
+}

package/constructs/Distribution.js

@@ -0,0 +1,260 @@
+import { Construct } from "constructs";
+import { CustomResource } from "aws-cdk-lib/core";
+import { Effect, Policy, PolicyStatement } from "aws-cdk-lib/aws-iam";
+import { HostedZone, ARecord, AaaaRecord, RecordTarget, } from "aws-cdk-lib/aws-route53";
+import { Distribution as CdkDistribution, } from "aws-cdk-lib/aws-cloudfront";
+import { CloudFrontTarget } from "aws-cdk-lib/aws-route53-targets";
+import { Stack } from "./Stack.js";
+import { isCDKConstruct } from "./Construct.js";
+import { HttpsRedirect } from "./cdk/website-redirect.js";
+import { DnsValidatedCertificate } from "./cdk/dns-validated-certificate.js";
+export class Distribution extends Construct {
+    scope;
+    props;
+    distribution;
+    hostedZone;
+    certificate;
+    constructor(scope, id, props) {
+        super(scope, id);
+        // Override scope
+        // note: this is intended to be used internally by SST to make constructs
+        //       backwards compatible when the hirechical structure of the constructs
+        //       changes. When the hirerchical structure changes, the child AWS
+        //       resources' logical ID will change. And CloudFormation will recreate
+        //       them.
+        this.scope = props.scopeOverride || this;
+        this.props = props;
+        const isImportedCloudFrontDistribution = (distribution) => {
+            return distribution !== undefined && isCDKConstruct(distribution);
+        };
+        // cdk.distribution is an imported construct
+        if (isImportedCloudFrontDistribution(props.cdk?.distribution)) {
+            this.distribution = props.cdk?.distribution;
+            return;
+        }
+        this.validateCustomDomainSettings();
+        this.validateCloudFrontDistributionSettings();
+        this.hostedZone = this.lookupHostedZone();
+        this.certificate = this.createCertificate();
+        this.distribution = this.createDistribution();
+        this.createRoute53Records();
+    }
+    /**
+     * The CloudFront URL of the website.
+     */
+    get url() {
+        return `https://${this.distribution.distributionDomainName}`;
+    }
+    /**
+     * If the custom domain is enabled, this is the URL of the website with the
+     * custom domain.
+     */
+    get customDomainUrl() {
+        const { customDomain } = this.props;
+        if (!customDomain)
+            return;
+        if (typeof customDomain === "string") {
+            return `https://${customDomain}`;
+        }
+        else {
+            return `https://${customDomain.domainName}`;
+        }
+    }
+    /**
+     * The internally created CDK resources.
+     */
+    get cdk() {
+        return {
+            distribution: this.distribution,
+            hostedZone: this.hostedZone,
+            certificate: this.certificate,
+        };
+    }
+    createInvalidation(buildId) {
+        const stack = Stack.of(this);
+        const policy = new Policy(this.scope, "CloudFrontInvalidatorPolicy", {
+            statements: [
+                new PolicyStatement({
+                    effect: Effect.ALLOW,
+                    actions: [
+                        "cloudfront:GetInvalidation",
+                        "cloudfront:CreateInvalidation",
+                    ],
+                    resources: [
+                        `arn:${stack.partition}:cloudfront::${stack.account}:distribution/${this.distribution.distributionId}`,
+                    ],
+                }),
+            ],
+        });
+        stack.customResourceHandler.role?.attachInlinePolicy(policy);
+        const resource = new CustomResource(this.scope, "CloudFrontInvalidator", {
+            serviceToken: stack.customResourceHandler.functionArn,
+            resourceType: "Custom::CloudFrontInvalidator",
+            properties: {
+                buildId: buildId || Date.now().toString(),
+                distributionId: this.distribution.distributionId,
+                paths: ["/*"],
+                waitForInvalidation: this.props.waitForInvalidation,
+            },
+        });
+        resource.node.addDependency(policy);
+        return resource;
+    }
+    validateCloudFrontDistributionSettings() {
+        const { cdk } = this.props;
+        if (!cdk?.distribution)
+            return;
+        if (cdk.distribution.certificate) {
+            throw new Error(`Do not configure the "cfDistribution.certificate". Use the "customDomain" to configure the domain certificate.`);
+        }
+        if (cdk.distribution.domainNames) {
+            throw new Error(`Do not configure the "cfDistribution.domainNames". Use the "customDomain" to configure the domain name.`);
+        }
+    }
+    validateCustomDomainSettings() {
+        const { customDomain } = this.props;
+        if (!customDomain) {
+            return;
+        }
+        if (typeof customDomain === "string") {
+            return;
+        }
+        if (customDomain.isExternalDomain === true) {
+            if (!customDomain.cdk?.certificate) {
+                throw new Error(`A valid certificate is required when "isExternalDomain" is set to "true".`);
+            }
+            if (customDomain.domainAlias) {
+                throw new Error(`Domain alias is only supported for domains hosted on Amazon Route 53. Do not set the "customDomain.domainAlias" when "isExternalDomain" is enabled.`);
+            }
+            if (customDomain.hostedZone) {
+                throw new Error(`Hosted zones can only be configured for domains hosted on Amazon Route 53. Do not set the "customDomain.hostedZone" when "isExternalDomain" is enabled.`);
+            }
+        }
+    }
+    lookupHostedZone() {
+        const { customDomain } = this.props;
+        // Skip if customDomain is not configured
+        if (!customDomain) {
+            return;
+        }
+        let hostedZone;
+        if (typeof customDomain === "string") {
+            hostedZone = HostedZone.fromLookup(this.scope, "HostedZone", {
+                domainName: customDomain,
+            });
+        }
+        else if (customDomain.cdk?.hostedZone) {
+            hostedZone = customDomain.cdk.hostedZone;
+        }
+        else if (typeof customDomain.hostedZone === "string") {
+            hostedZone = HostedZone.fromLookup(this.scope, "HostedZone", {
+                domainName: customDomain.hostedZone,
+            });
+        }
+        else if (typeof customDomain.domainName === "string") {
+            // Skip if domain is not a Route53 domain
+            if (customDomain.isExternalDomain === true) {
+                return;
+            }
+            hostedZone = HostedZone.fromLookup(this.scope, "HostedZone", {
+                domainName: customDomain.domainName,
+            });
+        }
+        else {
+            hostedZone = customDomain.hostedZone;
+        }
+        return hostedZone;
+    }
+    createCertificate() {
+        const { customDomain } = this.props;
+        if (!customDomain) {
+            return;
+        }
+        let acmCertificate;
+        // HostedZone is set for Route 53 domains
+        if (this.hostedZone) {
+            if (typeof customDomain === "string") {
+                acmCertificate = new DnsValidatedCertificate(this.scope, "Certificate", {
+                    domainName: customDomain,
+                    hostedZone: this.hostedZone,
+                    region: "us-east-1",
+                });
+            }
+            else if (customDomain.cdk?.certificate) {
+                acmCertificate = customDomain.cdk.certificate;
+            }
+            else {
+                acmCertificate = new DnsValidatedCertificate(this.scope, "Certificate", {
+                    domainName: customDomain.domainName,
+                    hostedZone: this.hostedZone,
+                    region: "us-east-1",
+                });
+            }
+        }
+        // HostedZone is NOT set for non-Route 53 domains
+        else {
+            if (typeof customDomain !== "string") {
+                acmCertificate = customDomain.cdk?.certificate;
+            }
+        }
+        return acmCertificate;
+    }
+    createDistribution() {
+        const { cdk } = this.props;
+        return new CdkDistribution(this.scope, "Distribution", {
+            ...cdk?.distribution,
+            domainNames: this.buildDistributionDomainNames(),
+            certificate: this.certificate,
+        });
+    }
+    buildDistributionDomainNames() {
+        const { customDomain } = this.props;
+        const domainNames = [];
+        if (!customDomain) {
+            // no domain
+        }
+        else if (typeof customDomain === "string") {
+            domainNames.push(customDomain);
+        }
+        else {
+            domainNames.push(customDomain.domainName);
+            if (customDomain.alternateNames) {
+                if (!customDomain.cdk?.certificate)
+                    throw new Error("Certificates for alternate domains cannot be automatically created. Please specify certificate to use");
+                domainNames.push(...customDomain.alternateNames);
+            }
+        }
+        return domainNames;
+    }
+    createRoute53Records() {
+        const { customDomain } = this.props;
+        if (!customDomain || !this.hostedZone) {
+            return;
+        }
+        let recordName;
+        let domainAlias;
+        if (typeof customDomain === "string") {
+            recordName = customDomain;
+        }
+        else {
+            recordName = customDomain.domainName;
+            domainAlias = customDomain.domainAlias;
+        }
+        // Create DNS record
+        const recordProps = {
+            recordName,
+            zone: this.hostedZone,
+            target: RecordTarget.fromAlias(new CloudFrontTarget(this.distribution)),
+        };
+        new ARecord(this.scope, "AliasRecord", recordProps);
+        new AaaaRecord(this.scope, "AliasRecordAAAA", recordProps);
+        // Create Alias redirect record
+        if (domainAlias) {
+            new HttpsRedirect(this.scope, "Redirect", {
+                zone: this.hostedZone,
+                recordNames: [domainAlias],
+                targetDomain: recordName,
+            });
+        }
+    }
+}

package/constructs/Metadata.d.ts

@@ -27,6 +27,8 @@ import type { NextjsSite as SlsNextjsSite } from "./deprecated/NextjsSite.js";
 export type SlsNextjsMetadata = ExtractMetadata<SlsNextjsSite>;
 import type { Queue } from "./Queue.js";
 export type QueueMetadata = ExtractMetadata<Queue>;
+import type { Service } from "./Service.js";
+export type ServiceMetadata = ExtractMetadata<Service>;
 import type { StaticSite } from "./StaticSite.js";
 export type StaticSiteMetadata = ExtractMetadata<StaticSite>;
 import type { Table } from "./Table.js";
@@ -54,5 +56,5 @@ export type SvelteKitSiteMetadata = ExtractMetadata<SvelteKitSite>;
 import type { SolidStartSite } from "./SolidStartSite.js";
 export type SolidStartSiteMetadata = ExtractMetadata<SolidStartSite>;
 export type SSRSiteMetadata = NextjsSiteMetadata | AstroSiteMetadata | RemixSiteMetadata | SolidStartSiteMetadata | SvelteKitSiteMetadata;
-export type Metadata = ApiMetadata | ApiGatewayV1ApiMetadata | CognitoMetadata | AppSyncApiMetadata | BucketMetadata | CronMetadata | EventBusMetadata | FunctionMetadata | KinesisStreamMetadata | SlsNextjsMetadata | QueueMetadata | StaticSiteMetadata | TableMetadata | TopicMetadata | WebSocketApiMetadata | RDSMetadata | AuthMetadata | ScriptMetadata | JobMetadata | SSRSiteMetadata;
+export type Metadata = ApiMetadata | ApiGatewayV1ApiMetadata | CognitoMetadata | AppSyncApiMetadata | BucketMetadata | CronMetadata | EventBusMetadata | FunctionMetadata | KinesisStreamMetadata | SlsNextjsMetadata | QueueMetadata | StaticSiteMetadata | TableMetadata | TopicMetadata | WebSocketApiMetadata | RDSMetadata | AuthMetadata | ScriptMetadata | JobMetadata | SSRSiteMetadata | ServiceMetadata;
 export {};

package/constructs/NextjsSite.d.ts

@@ -1,6 +1,7 @@
 import { Construct } from "constructs";
 import { FunctionProps } from "aws-cdk-lib/aws-lambda";
-import { Distribution, CachePolicy } from "aws-cdk-lib/aws-cloudfront";
+import { CachePolicy } from "aws-cdk-lib/aws-cloudfront";
+import { Distribution } from "./Distribution.js";
 import { SsrFunction } from "./SsrFunction.js";
 import { EdgeFunction } from "./EdgeFunction.js";
 import { SsrSite, SsrSiteProps } from "./SsrSite.js";
@@ -60,9 +61,9 @@ export declare class NextjsSite extends SsrSite {
     protected createFunctionForEdge(): EdgeFunction;
     private createImageOptimizationFunction;
     private createWarmer;
-    protected buildServerCachePolicy(): CachePolicy;
     protected createCloudFrontDistributionForRegional(): Distribution;
     protected createCloudFrontDistributionForEdge(): Distribution;
+    protected buildServerCachePolicy(): CachePolicy;
     private buildImageBehavior;
     protected generateBuildId(): string;
     getConstructMetadata(): {

package/constructs/NextjsSite.js

@@ -4,13 +4,14 @@ import { Fn, Duration as CdkDuration, RemovalPolicy, CustomResource, } from "aws
 import { Effect, Policy, PolicyStatement } from "aws-cdk-lib/aws-iam";
 import { RetentionDays } from "aws-cdk-lib/aws-logs";
 import { Code, Runtime, Architecture, Function as CdkFunction, FunctionUrlAuthType, } from "aws-cdk-lib/aws-lambda";
-import { Distribution, ViewerProtocolPolicy, AllowedMethods, CachedMethods, } from "aws-cdk-lib/aws-cloudfront";
+import { ViewerProtocolPolicy, AllowedMethods, CachedMethods, } from "aws-cdk-lib/aws-cloudfront";
 import { HttpOrigin } 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 { Queue } from "aws-cdk-lib/aws-sqs";
 import { SqsEventSource } from "aws-cdk-lib/aws-lambda-event-sources";
 import { Stack } from "./Stack.js";
+import { Distribution } from "./Distribution.js";
 import { SsrFunction } from "./SsrFunction.js";
 import { EdgeFunction } from "./EdgeFunction.js";
 import { SsrSite } from "./SsrSite.js";
@@ -128,13 +129,13 @@ export class NextjsSite extends SsrSite {
             timeout: CdkDuration.seconds(25),
             architecture: Architecture.ARM_64,
             environment: {
-                BUCKET_NAME: this.cdk.bucket.bucketName,
+                BUCKET_NAME: this.bucket.bucketName,
                 BUCKET_KEY_PREFIX: "_assets",
             },
             initialPolicy: [
                 new PolicyStatement({
                     actions: ["s3:GetObject"],
-                    resources: [this.cdk.bucket.arnForObjects("*")],
+                    resources: [this.bucket.arnForObjects("*")],
                 }),
             ],
         });
@@ -202,15 +203,6 @@ export class NextjsSite extends SsrSite {
         });
         resource.node.addDependency(policy);
     }
-    buildServerCachePolicy() {
-        return super.buildServerCachePolicy([
-            "accept",
-            "rsc",
-            "next-router-prefetch",
-            "next-router-state-tree",
-            "next-url",
-        ]);
-    }
     createCloudFrontDistributionForRegional() {
         /**
          * Next.js requests
@@ -261,49 +253,66 @@ export class NextjsSite extends SsrSite {
          *    - Cache-Control: public, max-age=0, must-revalidate
          *    - x-vercel-cache: MISS
          */
-        const { cdk } = this.props;
+        const { customDomain, cdk } = this.props;
         const cfDistributionProps = cdk?.distribution || {};
         const cachePolicy = cdk?.serverCachePolicy ?? this.buildServerCachePolicy();
         const serverBehavior = this.buildDefaultBehaviorForRegional(cachePolicy);
-        return new Distribution(this, "Distribution", {
-            // these values can be overwritten by cfDistributionProps
-            defaultRootObject: "",
-            // Override props.
-            ...cfDistributionProps,
-            // these values can NOT be overwritten by cfDistributionProps
-            domainNames: this.buildDistributionDomainNames(),
-            certificate: this.cdk.certificate,
-            defaultBehavior: serverBehavior,
-            additionalBehaviors: {
-                "api/*": serverBehavior,
-                "_next/data/*": serverBehavior,
-                "_next/image*": this.buildImageBehavior(cachePolicy),
-                ...(cfDistributionProps.additionalBehaviors || {}),
+        return new Distribution(this, "CDN", {
+            scopeOverride: this,
+            customDomain,
+            cdk: {
+                distribution: {
+                    // these values can be overwritten by cfDistributionProps
+                    defaultRootObject: "",
+                    // Override props.
+                    ...cfDistributionProps,
+                    // these values can NOT be overwritten by cfDistributionProps
+                    defaultBehavior: serverBehavior,
+                    additionalBehaviors: {
+                        "api/*": serverBehavior,
+                        "_next/data/*": serverBehavior,
+                        "_next/image*": this.buildImageBehavior(cachePolicy),
+                        ...(cfDistributionProps.additionalBehaviors || {}),
+                    },
+                },
             },
         });
     }
     createCloudFrontDistributionForEdge() {
-        const { cdk } = this.props;
+        const { customDomain, cdk } = this.props;
         const cfDistributionProps = cdk?.distribution || {};
         const cachePolicy = cdk?.serverCachePolicy ?? this.buildServerCachePolicy();
         const serverBehavior = this.buildDefaultBehaviorForEdge(cachePolicy);
-        return new Distribution(this, "Distribution", {
-            // these values can be overwritten by cfDistributionProps
-            defaultRootObject: "",
-            // Override props.
-            ...cfDistributionProps,
-            // these values can NOT be overwritten by cfDistributionProps
-            domainNames: this.buildDistributionDomainNames(),
-            certificate: this.cdk.certificate,
-            defaultBehavior: serverBehavior,
-            additionalBehaviors: {
-                "api/*": serverBehavior,
-                "_next/data/*": serverBehavior,
-                "_next/image*": this.buildImageBehavior(cachePolicy),
-                ...(cfDistributionProps.additionalBehaviors || {}),
+        return new Distribution(this, "CDN", {
+            scopeOverride: this,
+            customDomain,
+            cdk: {
+                distribution: {
+                    // these values can be overwritten by cfDistributionProps
+                    defaultRootObject: "",
+                    // Override props.
+                    ...cfDistributionProps,
+                    // these values can NOT be overwritten by cfDistributionProps
+                    defaultBehavior: serverBehavior,
+                    additionalBehaviors: {
+                        "api/*": serverBehavior,
+                        "_next/data/*": serverBehavior,
+                        "_next/image*": this.buildImageBehavior(cachePolicy),
+                        ...(cfDistributionProps.additionalBehaviors || {}),
+                    },
+                },
             },
         });
     }
+    buildServerCachePolicy() {
+        return super.buildServerCachePolicy([
+            "accept",
+            "rsc",
+            "next-router-prefetch",
+            "next-router-state-tree",
+            "next-url",
+        ]);
+    }
     buildImageBehavior(cachePolicy) {
         const { cdk } = this.props;
         const imageFn = this.createImageOptimizationFunction();