cdk-nuxt 0.2.8 → 0.3.0

package/lib/stack/nuxt-app-stack.d.ts

@@ -2,44 +2,184 @@ import { Stack } from 'aws-cdk-lib';
 import { Construct } from 'constructs';
 import { IBucket } from "aws-cdk-lib/aws-s3";
 import { AppStackProps } from "./app-stack-props";
+import { NuxtConfig } from "./nuxt-config";
+/**
+ * Defines the props required for the {@see NuxtAppStack}.
+ */
 export interface NuxtAppStackProps extends AppStackProps {
+    /**
+     * The domain (without the protocol) at which the Nuxt app shall be publicly available.
+     * A DNS record will be automatically created in Route53 for the domain.
+     * This also supports subdomains.
+     * Examples: "example.com", "sub.example.com"
+     */
     readonly domain: string;
-    readonly globalTlsCertificateArn: string;
+    /**
+     * The id of the hosted zone to create a DNS record for the specified domain.
+     */
     readonly hostedZoneId: string;
+    /**
+     * The ARN of the certificate to use for the Nuxt app to make it accessible via HTTPS.
+     * The certificate must be issued for the specified domain in us-east-1 (global) regardless of the
+     * region used for the Nuxt app itself.
+     */
+    readonly globalTlsCertificateArn: string;
+    /**
+     * The nuxt.config.js of the Nuxt app.
+     */
+    readonly nuxtConfig: NuxtConfig;
 }
+/**
+ * Creates a lambda function that renders the Nuxt app and is publicly reachable via a specified domain.
+ */
 export declare class NuxtAppStack extends Stack {
+    /**
+     * The identifier prefix of the resources created by the stack.
+     *
+     * @private
+     */
     private readonly resourceIdPrefix;
+    /**
+     * The identifier for the current deployment that is used as S3 folder name
+     * to store the static assets of the Nuxt app.
+     *
+     * @private
+     */
     private readonly deploymentRevision;
+    /**
+     * The certificate to use for the Nuxt app to make it accessible via HTTPS.
+     *
+     * @private
+     */
     private readonly tlsCertificate;
+    /**
+     * The identity to use for accessing the deployment assets on S3.
+     *
+     * @private
+     */
     private readonly cdnAccessIdentity;
+    /**
+     * The S3 bucket where the deployment assets gets stored.
+     */
     staticAssetsBucket: IBucket;
-    private readonly layer;
+    /**
+     * The lambda function to render the Nuxt app on the server side.
+     *
+     * @private
+     */
     private readonly lambdaFunction;
+    /**
+     * The API gateway to make the lambda function to render the Nuxt app publicly available.
+     *
+     * @private
+     */
     private apiGateway;
-    private readonly httpsForwardingBehavior;
+    /**
+     * The configs for the static assets of the Nuxt app that shall be publicly available.
+     *
+     * @private
+     */
+    private staticAssetConfigs;
+    /**
+     * The cloudfront distribution to route incoming requests to the Nuxt lambda function (via the API gateway)
+     * or the S3 assets folder (with caching).
+     *
+     * @private
+     */
     private readonly cdn;
-    private readonly hostedZone;
     constructor(scope: Construct, id: string, props: NuxtAppStackProps);
+    /**
+     * Finds the certificate to use for providing HTTPS requests to our Nuxt app.
+     *
+     * @param props
+     * @private
+     */
     private findTlsCertificate;
+    /**
+     * Creates the identity to access our S3 deployment asset files via the cloudfront distribution.
+     *
+     * @private
+     */
     private createCdnAccessIdentity;
+    /**
+     * Creates the bucket to store the static deployment asset files of the Nuxt app.
+     *
+     * @private
+     */
     private createStaticAssetsBucket;
+    /**
+     * Creates a lambda layer with the node_modules required to render the Nuxt app on the server side.
+     *
+     * @private
+     */
     private createSsrLambdaLayer;
+    /**
+     * Creates the lambda function to render the Nuxt app.
+     *
+     * @private
+     */
     private createLambdaFunction;
+    /**
+     * Creates the API gateway to make the Nuxt app render lambda function publicly available.
+     *
+     * @private
+     */
     private createApiGateway;
-    private createHttpsForwardingBehavior;
     /**
-     * Eventhough we don't want to cache SSR requests, we still have to create a cache policy, in order to
+     * Creates the cloudfront distribution that routes incoming requests to the Nuxt lambda function (via the API gateway)
+     * or the S3 assets folder (with caching).
+     *
+     * @param props
+     * @private
+     */
+    private createCloudFrontDistribution;
+    /**
+     * Creates a behavior for the cloudfront distribution to route incoming requests to the Nuxt render lambda function (via API gateway).
+     * Additionally, this automatically redirects HTTP requests to HTTPS.
+     *
+     * @private
+     */
+    private createNuxtAppRouteBehavior;
+    /**
+     * Creates a cache policy for the Nuxt app route behavior of our cloudfront distribution.
+     * Eventhough we don't want to cache SSR requests, we still have to create this cache policy in order to
      * forward required cookies, query params and headers. This doesn't make any sense, because if nothing
      * is cached, one would expect, that anything would/could be forwarded, but anyway...
      */
     private createSsrCachePolicy;
-    private createCloudFrontDistribution;
-    private createStaticAssetBehaviors;
     /**
+     * Creates a behavior for the cloudfront distribution to route matching incoming requests for our static assets
+     * to the S3 bucket that holds these static assets.
+     *
+     * @private
+     */
+    private createStaticAssetsRouteBehavior;
+    /**
+     * Uploads the static assets of the Nuxt app as defined in {@see getNuxtAppStaticAssetConfigs} to the static assets S3 bucket.
      * In order to enable a zero-downtime deployment, we use a new subdirectory (revision) for every deployment.
-     * The previous versions are retained to allow clients to continue to work with an older revision.
+     * The previous versions are retained to allow clients to continue to work with an older revision but gets cleaned up
+     * after a specified period of time via the lambda function in the {@see NuxtAppAssetsCleanupStack}.
      */
     private configureDeployments;
+    /**
+     * Resolves the hosted zone at which the DNS records shall be created to access our Nuxt app on the internet.
+     *
+     * @param props
+     * @private
+     */
     private findHostedZone;
+    /**
+     * Creates the DNS records to access our Nuxt app on the internet via our custom domain.
+     *
+     * @param props
+     * @private
+     */
     private createDnsRecords;
+    /**
+     * Creates a scheduled rule to ping our Nuxt app lambda function every 5 minutes in order to keep it warm
+     * and speed up initial SSR requests.
+     *
+     * @private
+     */
+    private createPingRule;
 }

package/lib/stack/nuxt-app-stack.js

@@ -16,59 +16,90 @@ const aws_apigatewayv2_integrations_alpha_1 = require("@aws-cdk/aws-apigatewayv2
 const aws_apigatewayv2_alpha_1 = require("@aws-cdk/aws-apigatewayv2-alpha");
 const nuxt_app_static_assets_1 = require("./nuxt-app-static-assets");
 const fs = require("fs");
+const aws_events_1 = require("aws-cdk-lib/aws-events");
+const aws_events_targets_1 = require("aws-cdk-lib/aws-events-targets");
+/**
+ * Creates a lambda function that renders the Nuxt app and is publicly reachable via a specified domain.
+ */
 class NuxtAppStack extends aws_cdk_lib_1.Stack {
     constructor(scope, id, props) {
         super(scope, id, props);
         this.resourceIdPrefix = `${props.project}-${props.service}-${props.environment}`;
         this.deploymentRevision = new Date().toISOString();
+        this.staticAssetConfigs = (0, nuxt_app_static_assets_1.getNuxtAppStaticAssetConfigs)(props.nuxtConfig);
         this.tlsCertificate = this.findTlsCertificate(props);
         this.cdnAccessIdentity = this.createCdnAccessIdentity();
         this.staticAssetsBucket = this.createStaticAssetsBucket();
-        this.layer = this.createSsrLambdaLayer();
         this.lambdaFunction = this.createLambdaFunction();
         this.apiGateway = this.createApiGateway();
-        this.httpsForwardingBehavior = this.createHttpsForwardingBehavior();
         this.cdn = this.createCloudFrontDistribution(props);
         this.configureDeployments();
-        this.hostedZone = this.findHostedZone(props);
         this.createDnsRecords(props);
+        this.createPingRule();
     }
+    /**
+     * Finds the certificate to use for providing HTTPS requests to our Nuxt app.
+     *
+     * @param props
+     * @private
+     */
     findTlsCertificate(props) {
         return aws_certificatemanager_1.Certificate.fromCertificateArn(this, `${this.resourceIdPrefix}-tls-certificate`, props.globalTlsCertificateArn);
     }
+    /**
+     * Creates the identity to access our S3 deployment asset files via the cloudfront distribution.
+     *
+     * @private
+     */
     createCdnAccessIdentity() {
         const originAccessIdentityName = `${this.resourceIdPrefix}-cdn-s3-access`;
         return new aws_cloudfront_1.OriginAccessIdentity(this, originAccessIdentityName);
     }
+    /**
+     * Creates the bucket to store the static deployment asset files of the Nuxt app.
+     *
+     * @private
+     */
     createStaticAssetsBucket() {
         const bucketName = `${this.resourceIdPrefix}-assets`;
         const bucket = new aws_s3_1.Bucket(this, bucketName, {
             accessControl: aws_s3_1.BucketAccessControl.AUTHENTICATED_READ,
             blockPublicAccess: aws_s3_1.BlockPublicAccess.BLOCK_ALL,
             bucketName,
-            // the bucket and all of its objects can be deleted, because all the content is managed in this project
+            // The bucket and all of its objects can be deleted, because all the content is managed in this project
             removalPolicy: aws_cdk_lib_1.RemovalPolicy.DESTROY,
             autoDeleteObjects: true,
         });
         bucket.grantReadWrite(this.cdnAccessIdentity);
         return bucket;
     }
+    /**
+     * Creates a lambda layer with the node_modules required to render the Nuxt app on the server side.
+     *
+     * @private
+     */
     createSsrLambdaLayer() {
         const layerName = `${this.resourceIdPrefix}-ssr-layer`;
         return new aws_lambda_1.LayerVersion(this, layerName, {
             layerVersionName: layerName,
             code: aws_lambda_1.Code.fromAsset('.nuxt/cdk-deployment/layer'),
             compatibleRuntimes: [aws_lambda_1.Runtime.NODEJS_12_X],
-            description: `Contains node_modules required for server-side of ${this.resourceIdPrefix}.`,
+            description: `Provides the node_modules required for SSR of ${this.resourceIdPrefix}.`,
         });
     }
+    /**
+     * Creates the lambda function to render the Nuxt app.
+     *
+     * @private
+     */
     createLambdaFunction() {
         const funcName = `${this.resourceIdPrefix}-function`;
         return new aws_lambda_1.Function(this, funcName, {
             functionName: funcName,
+            description: `Renders the ${this.resourceIdPrefix} Nuxt app.`,
             runtime: aws_lambda_1.Runtime.NODEJS_12_X,
             architecture: aws_lambda_1.Architecture.ARM_64,
-            layers: [this.layer],
+            layers: [this.createSsrLambdaLayer()],
             handler: 'index.handler',
             code: aws_lambda_1.Code.fromAsset('.nuxt/cdk-deployment/src', {
                 exclude: ['**.svg', '**.ico', '**.png', '**.jpg', 'chunk.*.js*', 'bundle.*.js*', 'bundle.*.js*', 'sw.js*'],
@@ -76,15 +107,20 @@ class NuxtAppStack extends aws_cdk_lib_1.Stack {
             timeout: aws_cdk_lib_1.Duration.seconds(10),
             memorySize: 512,
             logRetention: aws_logs_1.RetentionDays.ONE_MONTH,
-            environment: {},
             allowPublicSubnet: false
         });
     }
+    /**
+     * Creates the API gateway to make the Nuxt app render lambda function publicly available.
+     *
+     * @private
+     */
     createApiGateway() {
         const lambdaIntegration = new aws_apigatewayv2_integrations_alpha_1.HttpLambdaIntegration(`${this.resourceIdPrefix}-lambda-integration`, this.lambdaFunction);
         const apiName = `${this.resourceIdPrefix}-api`;
         const apiGateway = new aws_apigatewayv2_alpha_1.HttpApi(this, apiName, {
             apiName,
+            description: `Connects the ${this.resourceIdPrefix} cloudfront distribution with the ${this.resourceIdPrefix} lambda function to make it publicly available.`,
             // The app does not allow any cross-origin access by purpose: the app should not be embeddable anywhere
             corsPreflight: undefined,
             defaultIntegration: lambdaIntegration,
@@ -96,7 +132,32 @@ class NuxtAppStack extends aws_cdk_lib_1.Stack {
         });
         return apiGateway;
     }
-    createHttpsForwardingBehavior() {
+    /**
+     * Creates the cloudfront distribution that routes incoming requests to the Nuxt lambda function (via the API gateway)
+     * or the S3 assets folder (with caching).
+     *
+     * @param props
+     * @private
+     */
+    createCloudFrontDistribution(props) {
+        const cdnName = `${this.resourceIdPrefix}-cdn`;
+        return new aws_cloudfront_1.Distribution(this, cdnName, {
+            domainNames: [props.domain],
+            comment: `${this.resourceIdPrefix}-redirect`,
+            minimumProtocolVersion: aws_cloudfront_1.SecurityPolicyProtocol.TLS_V1_2_2018,
+            certificate: this.tlsCertificate,
+            defaultBehavior: this.createNuxtAppRouteBehavior(),
+            additionalBehaviors: this.createStaticAssetsRouteBehavior(),
+            priceClass: aws_cloudfront_1.PriceClass.PRICE_CLASS_100, // Use only North America and Europe
+        });
+    }
+    /**
+     * Creates a behavior for the cloudfront distribution to route incoming requests to the Nuxt render lambda function (via API gateway).
+     * Additionally, this automatically redirects HTTP requests to HTTPS.
+     *
+     * @private
+     */
+    createNuxtAppRouteBehavior() {
         return {
             origin: new aws_cloudfront_origins_1.HttpOrigin(`${this.apiGateway.httpApiId}.execute-api.${this.region}.amazonaws.com`, {
                 connectionAttempts: 2,
@@ -112,15 +173,16 @@ class NuxtAppStack extends aws_cdk_lib_1.Stack {
         };
     }
     /**
-     * Eventhough we don't want to cache SSR requests, we still have to create a cache policy, in order to
+     * Creates a cache policy for the Nuxt app route behavior of our cloudfront distribution.
+     * Eventhough we don't want to cache SSR requests, we still have to create this cache policy in order to
      * forward required cookies, query params and headers. This doesn't make any sense, because if nothing
      * is cached, one would expect, that anything would/could be forwarded, but anyway...
      */
     createSsrCachePolicy() {
-        // The headers to pass to the app
+        // The headers to make accessible in our Nuxt app code
         const headers = [
             'User-Agent',
-            'Authorization',
+            'Authorization', // For authorization
         ];
         return new aws_cloudfront_1.CachePolicy(this, `${this.resourceIdPrefix}-cache-policy`, {
             cachePolicyName: `${this.resourceIdPrefix}-cdn-cache-policy`,
@@ -135,19 +197,13 @@ class NuxtAppStack extends aws_cdk_lib_1.Stack {
             enableAcceptEncodingGzip: true,
         });
     }
-    createCloudFrontDistribution(props) {
-        const cdnName = `${this.resourceIdPrefix}-cdn`;
-        return new aws_cloudfront_1.Distribution(this, cdnName, {
-            domainNames: [props.domain],
-            comment: `${this.resourceIdPrefix}-redirect`,
-            minimumProtocolVersion: aws_cloudfront_1.SecurityPolicyProtocol.TLS_V1_2_2018,
-            certificate: this.tlsCertificate,
-            defaultBehavior: this.httpsForwardingBehavior,
-            additionalBehaviors: this.createStaticAssetBehaviors(),
-            priceClass: aws_cloudfront_1.PriceClass.PRICE_CLASS_100,
-        });
-    }
-    createStaticAssetBehaviors() {
+    /**
+     * Creates a behavior for the cloudfront distribution to route matching incoming requests for our static assets
+     * to the S3 bucket that holds these static assets.
+     *
+     * @private
+     */
+    createStaticAssetsRouteBehavior() {
         const staticAssetsCacheConfig = {
             origin: new aws_cloudfront_origins_1.S3Origin(this.staticAssetsBucket, {
                 connectionAttempts: 2,
@@ -162,14 +218,16 @@ class NuxtAppStack extends aws_cdk_lib_1.Stack {
             viewerProtocolPolicy: aws_cloudfront_1.ViewerProtocolPolicy.REDIRECT_TO_HTTPS,
         };
         const rules = {};
-        nuxt_app_static_assets_1.NuxtAppStaticAssets.forEach(asset => {
+        this.staticAssetConfigs.forEach(asset => {
             rules[`${asset.target}${asset.pattern}`] = staticAssetsCacheConfig;
         });
         return rules;
     }
     /**
+     * Uploads the static assets of the Nuxt app as defined in {@see getNuxtAppStaticAssetConfigs} to the static assets S3 bucket.
      * In order to enable a zero-downtime deployment, we use a new subdirectory (revision) for every deployment.
-     * The previous versions are retained to allow clients to continue to work with an older revision.
+     * The previous versions are retained to allow clients to continue to work with an older revision but gets cleaned up
+     * after a specified period of time via the lambda function in the {@see NuxtAppAssetsCleanupStack}.
      */
     configureDeployments() {
         const defaultCacheConfig = [
@@ -178,7 +236,7 @@ class NuxtAppStack extends aws_cdk_lib_1.Stack {
             aws_s3_deployment_1.CacheControl.fromString('immutable'),
         ];
         // Returns a deployment for every configured static asset type to respect the different cache settings
-        return nuxt_app_static_assets_1.NuxtAppStaticAssets.filter(asset => fs.existsSync(asset.source)).map((asset, assetIndex) => {
+        return this.staticAssetConfigs.filter(asset => fs.existsSync(asset.source)).map((asset, assetIndex) => {
             var _a;
             return new aws_s3_deployment_1.BucketDeployment(this, `${this.resourceIdPrefix}-assets-deployment-${assetIndex}`, {
                 sources: [aws_s3_deployment_1.Source.asset(asset.source)],
@@ -193,28 +251,56 @@ class NuxtAppStack extends aws_cdk_lib_1.Stack {
             });
         });
     }
+    /**
+     * Resolves the hosted zone at which the DNS records shall be created to access our Nuxt app on the internet.
+     *
+     * @param props
+     * @private
+     */
     findHostedZone(props) {
         const domainParts = props.domain.split('.');
         return aws_route53_1.HostedZone.fromHostedZoneAttributes(this, `${this.resourceIdPrefix}-hosted-zone`, {
             hostedZoneId: props.hostedZoneId,
-            zoneName: domainParts[domainParts.length - 1],
+            zoneName: domainParts[domainParts.length - 1], // Support subdomains
         });
     }
+    /**
+     * Creates the DNS records to access our Nuxt app on the internet via our custom domain.
+     *
+     * @param props
+     * @private
+     */
     createDnsRecords(props) {
+        const hostedZone = this.findHostedZone(props);
         const dnsTarget = aws_route53_1.RecordTarget.fromAlias(new aws_route53_targets_1.CloudFrontTarget(this.cdn));
         // Create a record for IPv4
         new aws_route53_1.ARecord(this, `${this.resourceIdPrefix}-ipv4-record`, {
             recordName: props.domain,
-            zone: this.hostedZone,
+            zone: hostedZone,
             target: dnsTarget,
         });
         // Create a record for IPv6
         new aws_route53_1.AaaaRecord(this, `${this.resourceIdPrefix}-ipv6-record`, {
             recordName: props.domain,
-            zone: this.hostedZone,
+            zone: hostedZone,
             target: dnsTarget,
         });
     }
+    /**
+     * Creates a scheduled rule to ping our Nuxt app lambda function every 5 minutes in order to keep it warm
+     * and speed up initial SSR requests.
+     *
+     * @private
+     */
+    createPingRule() {
+        new aws_events_1.Rule(this, `${this.resourceIdPrefix}-pinger-rule`, {
+            ruleName: `${this.resourceIdPrefix}-pinger`,
+            description: `Pings the lambda function of the ${this.resourceIdPrefix} app every 5 minutes to keep it warm.`,
+            enabled: true,
+            schedule: aws_events_1.Schedule.rate(aws_cdk_lib_1.Duration.minutes(5)),
+            targets: [new aws_events_targets_1.LambdaFunction(this.lambdaFunction)],
+        });
+    }
 }
 exports.NuxtAppStack = NuxtAppStack;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nuxt-app-stack.js","sourceRoot":"","sources":["nuxt-app-stack.ts"],"names":[],"mappings":"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","sourcesContent":["import {Duration, RemovalPolicy, Stack, Tags} from 'aws-cdk-lib';\nimport { Construct } from 'constructs';\nimport {Certificate, ICertificate} from \"aws-cdk-lib/aws-certificatemanager\";\nimport {\n  AllowedMethods,\n  BehaviorOptions, CacheCookieBehavior,\n  CachedMethods, CacheHeaderBehavior,\n  CachePolicy, CacheQueryStringBehavior,\n  Distribution, ICachePolicy,\n  IOriginAccessIdentity, OriginAccessIdentity, OriginProtocolPolicy, PriceClass,\n  SecurityPolicyProtocol,\n  ViewerProtocolPolicy\n} from \"aws-cdk-lib/aws-cloudfront\";\nimport {Architecture, Code, LayerVersion, Runtime, Function} from \"aws-cdk-lib/aws-lambda\";\nimport {BlockPublicAccess, Bucket, BucketAccessControl, IBucket} from \"aws-cdk-lib/aws-s3\";\nimport {ARecord, AaaaRecord, HostedZone, IHostedZone, RecordTarget} from \"aws-cdk-lib/aws-route53\";\nimport {BucketDeployment, CacheControl, Source, StorageClass} from \"aws-cdk-lib/aws-s3-deployment\";\nimport {HttpOrigin, S3Origin} from \"aws-cdk-lib/aws-cloudfront-origins\";\nimport {CloudFrontTarget} from \"aws-cdk-lib/aws-route53-targets\";\nimport {HttpMethod} from \"aws-cdk-lib/aws-stepfunctions-tasks\";\nimport {RetentionDays} from \"aws-cdk-lib/aws-logs\";\nimport { HttpLambdaIntegration } from '@aws-cdk/aws-apigatewayv2-integrations-alpha';\nimport {HttpApi} from \"@aws-cdk/aws-apigatewayv2-alpha\";\nimport {NuxtAppStaticAssets} from \"./nuxt-app-static-assets\";\nimport {AppStackProps} from \"./app-stack-props\";\nimport * as fs from \"fs\";\n\nexport interface NuxtAppStackProps extends AppStackProps {\n  readonly domain: string;\n\n  // Used by the CDN, must be issued in us-east-1 (global)\n  readonly globalTlsCertificateArn: string;\n\n  readonly hostedZoneId: string;\n}\n\nexport class NuxtAppStack extends Stack {\n  private readonly resourceIdPrefix: string;\n  private readonly deploymentRevision: string;\n  private readonly tlsCertificate: ICertificate;\n  private readonly cdnAccessIdentity: IOriginAccessIdentity;\n  public staticAssetsBucket: IBucket;\n  private readonly layer: LayerVersion;\n  private readonly lambdaFunction: Function;\n  private apiGateway: HttpApi;\n  private readonly httpsForwardingBehavior: BehaviorOptions;\n  private readonly cdn: Distribution;\n  private readonly hostedZone: IHostedZone;\n\n  constructor(scope: Construct, id: string, props: NuxtAppStackProps) {\n    super(scope, id, props);\n\n    this.resourceIdPrefix = `${props.project}-${props.service}-${props.environment}`;\n    this.deploymentRevision = new Date().toISOString();\n    this.tlsCertificate = this.findTlsCertificate(props);\n    this.cdnAccessIdentity = this.createCdnAccessIdentity();\n    this.staticAssetsBucket = this.createStaticAssetsBucket();\n    this.layer = this.createSsrLambdaLayer();\n    this.lambdaFunction = this.createLambdaFunction();\n    this.apiGateway = this.createApiGateway();\n    this.httpsForwardingBehavior = this.createHttpsForwardingBehavior();\n    this.cdn = this.createCloudFrontDistribution(props);\n    this.configureDeployments();\n    this.hostedZone = this.findHostedZone(props);\n    this.createDnsRecords(props);\n  }\n\n  private findTlsCertificate(props: NuxtAppStackProps): ICertificate {\n    return Certificate.fromCertificateArn(this, `${this.resourceIdPrefix}-tls-certificate`, props.globalTlsCertificateArn);\n  }\n\n  private createCdnAccessIdentity(): IOriginAccessIdentity {\n    const originAccessIdentityName = `${this.resourceIdPrefix}-cdn-s3-access`;\n    return new OriginAccessIdentity(this, originAccessIdentityName);\n  }\n\n  private createStaticAssetsBucket(): IBucket {\n    const bucketName = `${this.resourceIdPrefix}-assets`;\n    const bucket = new Bucket(this, bucketName, {\n      accessControl: BucketAccessControl.AUTHENTICATED_READ,\n      blockPublicAccess: BlockPublicAccess.BLOCK_ALL,\n      bucketName,\n      // the bucket and all of its objects can be deleted, because all the content is managed in this project\n      removalPolicy: RemovalPolicy.DESTROY,\n      autoDeleteObjects: true,\n    });\n\n    bucket.grantReadWrite(this.cdnAccessIdentity);\n\n    return bucket;\n  }\n\n  private createSsrLambdaLayer(): LayerVersion {\n    const layerName = `${this.resourceIdPrefix}-ssr-layer`;\n    return new LayerVersion(this, layerName, {\n      layerVersionName: layerName,\n      code: Code.fromAsset('.nuxt/cdk-deployment/layer'),\n      compatibleRuntimes: [Runtime.NODEJS_12_X],\n      description: `Contains node_modules required for server-side of ${this.resourceIdPrefix}.`,\n    });\n  }\n\n  private createLambdaFunction(): Function {\n    const funcName = `${this.resourceIdPrefix}-function`;\n\n    return new Function(this, funcName, {\n      functionName: funcName,\n      runtime: Runtime.NODEJS_12_X,\n      architecture: Architecture.ARM_64,\n      layers: [this.layer],\n      handler: 'index.handler',\n      code: Code.fromAsset('.nuxt/cdk-deployment/src', {\n        exclude: ['**.svg', '**.ico', '**.png', '**.jpg', 'chunk.*.js*', 'bundle.*.js*', 'bundle.*.js*', 'sw.js*'],\n      }),\n      timeout: Duration.seconds(10),\n      memorySize: 512,\n      logRetention: RetentionDays.ONE_MONTH,\n      environment: {},\n      allowPublicSubnet: false\n    });\n  }\n\n  private createApiGateway(): HttpApi {\n    const lambdaIntegration = new HttpLambdaIntegration(`${this.resourceIdPrefix}-lambda-integration`, this.lambdaFunction);\n    const apiName = `${this.resourceIdPrefix}-api`;\n    const apiGateway = new HttpApi(this, apiName, {\n      apiName,\n      // The app does not allow any cross-origin access by purpose: the app should not be embeddable anywhere\n      corsPreflight: undefined,\n      defaultIntegration: lambdaIntegration,\n    });\n\n    apiGateway.addRoutes({\n      integration: lambdaIntegration,\n      path: '/{proxy+}',\n      methods: [HttpMethod.GET, HttpMethod.HEAD],\n    });\n    return apiGateway;\n  }\n\n  private createHttpsForwardingBehavior(): BehaviorOptions {\n    return {\n      origin: new HttpOrigin(`${this.apiGateway.httpApiId}.execute-api.${this.region}.amazonaws.com`, {\n        connectionAttempts: 2,\n        connectionTimeout: Duration.seconds(2),\n        readTimeout: Duration.seconds(10),\n        protocolPolicy: OriginProtocolPolicy.HTTPS_ONLY,\n      }),\n      allowedMethods: AllowedMethods.ALLOW_GET_HEAD,\n      compress: true,\n      viewerProtocolPolicy: ViewerProtocolPolicy.REDIRECT_TO_HTTPS,\n      originRequestPolicy: undefined,\n      cachePolicy: this.createSsrCachePolicy(),\n    };\n  }\n\n  /**\n   * Eventhough we don't want to cache SSR requests, we still have to create a cache policy, in order to\n   * forward required cookies, query params and headers. This doesn't make any sense, because if nothing\n   * is cached, one would expect, that anything would/could be forwarded, but anyway...\n   */\n  private createSsrCachePolicy(): ICachePolicy {\n\n    // The headers to pass to the app\n    const headers = [\n      'User-Agent', // Required to distinguish between mobile and desktop template\n      'Authorization', // For authorization\n    ];\n\n    return new CachePolicy(this, `${this.resourceIdPrefix}-cache-policy`, {\n      cachePolicyName: `${this.resourceIdPrefix}-cdn-cache-policy`,\n      comment: `Passes all required request data to the ${this.resourceIdPrefix} origin.`,\n      defaultTtl: Duration.seconds(0),\n      minTtl: Duration.seconds(0),\n      maxTtl: Duration.seconds(1), // the max TTL must not be 0 for a cache policy\n      queryStringBehavior: CacheQueryStringBehavior.all(),\n      headerBehavior: CacheHeaderBehavior.allowList(...headers),\n      cookieBehavior: CacheCookieBehavior.all(),\n      enableAcceptEncodingBrotli: true,\n      enableAcceptEncodingGzip: true,\n    });\n  }\n\n  private createCloudFrontDistribution(props: NuxtAppStackProps): Distribution {\n    const cdnName = `${this.resourceIdPrefix}-cdn`;\n\n    return new Distribution(this, cdnName, {\n      domainNames: [props.domain],\n      comment: `${this.resourceIdPrefix}-redirect`,\n      minimumProtocolVersion: SecurityPolicyProtocol.TLS_V1_2_2018,\n      certificate: this.tlsCertificate,\n      defaultBehavior: this.httpsForwardingBehavior,\n      additionalBehaviors: this.createStaticAssetBehaviors(),\n      priceClass: PriceClass.PRICE_CLASS_100, // Use only North America and Europe\n    });\n  }\n\n  private createStaticAssetBehaviors(): Record<string, BehaviorOptions> {\n    const staticAssetsCacheConfig: BehaviorOptions = {\n      origin: new S3Origin(this.staticAssetsBucket, {\n        connectionAttempts: 2,\n        connectionTimeout: Duration.seconds(3),\n        originAccessIdentity: this.cdnAccessIdentity,\n        originPath: this.deploymentRevision,\n      }),\n      compress: true,\n      allowedMethods: AllowedMethods.ALLOW_GET_HEAD_OPTIONS,\n      cachedMethods: CachedMethods.CACHE_GET_HEAD_OPTIONS,\n      cachePolicy: CachePolicy.CACHING_OPTIMIZED,\n      viewerProtocolPolicy: ViewerProtocolPolicy.REDIRECT_TO_HTTPS,\n    };\n\n    const rules: Record<string, BehaviorOptions> = {};\n    NuxtAppStaticAssets.forEach(asset => {\n      rules[`${asset.target}${asset.pattern}`] = staticAssetsCacheConfig\n    })\n\n    return rules\n  }\n\n  /**\n   * In order to enable a zero-downtime deployment, we use a new subdirectory (revision) for every deployment.\n   * The previous versions are retained to allow clients to continue to work with an older revision.\n   */\n  private configureDeployments(): BucketDeployment[] {\n    const defaultCacheConfig = [\n      CacheControl.setPublic(),\n      CacheControl.maxAge(Duration.days(365)),\n      CacheControl.fromString('immutable'),\n    ];\n\n    // Returns a deployment for every configured static asset type to respect the different cache settings\n    return NuxtAppStaticAssets.filter(asset => fs.existsSync(asset.source)).map((asset, assetIndex) => {\n      return new BucketDeployment(this, `${this.resourceIdPrefix}-assets-deployment-${assetIndex}`, {\n        sources: [Source.asset(asset.source)],\n        destinationBucket: this.staticAssetsBucket,\n        destinationKeyPrefix: this.deploymentRevision + asset.target,\n        prune: false,\n        storageClass: StorageClass.STANDARD,\n        exclude: ['*'],\n        include: [asset.pattern],\n        cacheControl: asset.cacheControl ?? defaultCacheConfig,\n        contentType: asset.contentType,\n      })\n    });\n  }\n\n  private findHostedZone(props: NuxtAppStackProps): IHostedZone {\n    const domainParts = props.domain.split('.');\n\n    return HostedZone.fromHostedZoneAttributes(this, `${this.resourceIdPrefix}-hosted-zone`, {\n      hostedZoneId: props.hostedZoneId,\n      zoneName: domainParts[domainParts.length - 1], // Support subdomains\n    });\n  }\n\n  private createDnsRecords(props: NuxtAppStackProps): void {\n    const dnsTarget = RecordTarget.fromAlias(new CloudFrontTarget(this.cdn));\n\n    // Create a record for IPv4\n    new ARecord(this, `${this.resourceIdPrefix}-ipv4-record`, {\n      recordName: props.domain,\n      zone: this.hostedZone,\n      target: dnsTarget,\n    });\n\n    // Create a record for IPv6\n    new AaaaRecord(this, `${this.resourceIdPrefix}-ipv6-record`, {\n      recordName: props.domain,\n      zone: this.hostedZone,\n      target: dnsTarget,\n    });\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nuxt-app-stack.js","sourceRoot":"","sources":["nuxt-app-stack.ts"],"names":[],"mappings":"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","sourcesContent":["import {Duration, RemovalPolicy, Stack} from 'aws-cdk-lib';\nimport { Construct } from 'constructs';\nimport {Certificate, ICertificate} from \"aws-cdk-lib/aws-certificatemanager\";\nimport {\n  AllowedMethods,\n  BehaviorOptions, CacheCookieBehavior,\n  CachedMethods, CacheHeaderBehavior,\n  CachePolicy, CacheQueryStringBehavior,\n  Distribution, ICachePolicy,\n  IOriginAccessIdentity, OriginAccessIdentity, OriginProtocolPolicy, PriceClass,\n  SecurityPolicyProtocol,\n  ViewerProtocolPolicy\n} from \"aws-cdk-lib/aws-cloudfront\";\nimport {Architecture, Code, LayerVersion, Runtime, Function} from \"aws-cdk-lib/aws-lambda\";\nimport {BlockPublicAccess, Bucket, BucketAccessControl, IBucket} from \"aws-cdk-lib/aws-s3\";\nimport {ARecord, AaaaRecord, HostedZone, IHostedZone, RecordTarget} from \"aws-cdk-lib/aws-route53\";\nimport {BucketDeployment, CacheControl, Source, StorageClass} from \"aws-cdk-lib/aws-s3-deployment\";\nimport {HttpOrigin, S3Origin} from \"aws-cdk-lib/aws-cloudfront-origins\";\nimport {CloudFrontTarget} from \"aws-cdk-lib/aws-route53-targets\";\nimport {HttpMethod} from \"aws-cdk-lib/aws-stepfunctions-tasks\";\nimport {RetentionDays} from \"aws-cdk-lib/aws-logs\";\nimport { HttpLambdaIntegration } from '@aws-cdk/aws-apigatewayv2-integrations-alpha';\nimport {HttpApi} from \"@aws-cdk/aws-apigatewayv2-alpha\";\nimport {getNuxtAppStaticAssetConfigs, StaticAssetConfig} from \"./nuxt-app-static-assets\";\nimport {AppStackProps} from \"./app-stack-props\";\nimport * as fs from \"fs\";\nimport {Rule, Schedule} from \"aws-cdk-lib/aws-events\";\nimport {LambdaFunction} from \"aws-cdk-lib/aws-events-targets\";\nimport {NuxtConfig} from \"./nuxt-config\";\n\n/**\n * Defines the props required for the {@see NuxtAppStack}.\n */\nexport interface NuxtAppStackProps extends AppStackProps {\n  /**\n   * The domain (without the protocol) at which the Nuxt app shall be publicly available.\n   * A DNS record will be automatically created in Route53 for the domain.\n   * This also supports subdomains.\n   * Examples: \"example.com\", \"sub.example.com\"\n   */\n  readonly domain: string;\n\n  /**\n   * The id of the hosted zone to create a DNS record for the specified domain.\n   */\n  readonly hostedZoneId: string;\n\n  /**\n   * The ARN of the certificate to use for the Nuxt app to make it accessible via HTTPS.\n   * The certificate must be issued for the specified domain in us-east-1 (global) regardless of the\n   * region used for the Nuxt app itself.\n   */\n  readonly globalTlsCertificateArn: string;\n\n  /**\n   * The nuxt.config.js of the Nuxt app.\n   */\n  readonly nuxtConfig: NuxtConfig;\n}\n\n/**\n * Creates a lambda function that renders the Nuxt app and is publicly reachable via a specified domain.\n */\nexport class NuxtAppStack extends Stack {\n\n  /**\n   * The identifier prefix of the resources created by the stack.\n   *\n   * @private\n   */\n  private readonly resourceIdPrefix: string;\n\n  /**\n   * The identifier for the current deployment that is used as S3 folder name\n   * to store the static assets of the Nuxt app.\n   *\n   * @private\n   */\n  private readonly deploymentRevision: string;\n\n  /**\n   * The certificate to use for the Nuxt app to make it accessible via HTTPS.\n   *\n   * @private\n   */\n  private readonly tlsCertificate: ICertificate;\n\n  /**\n   * The identity to use for accessing the deployment assets on S3.\n   *\n   * @private\n   */\n  private readonly cdnAccessIdentity: IOriginAccessIdentity;\n\n  /**\n   * The S3 bucket where the deployment assets gets stored.\n   */\n  public staticAssetsBucket: IBucket;\n\n  /**\n   * The lambda function to render the Nuxt app on the server side.\n   *\n   * @private\n   */\n  private readonly lambdaFunction: Function;\n\n  /**\n   * The API gateway to make the lambda function to render the Nuxt app publicly available.\n   *\n   * @private\n   */\n  private apiGateway: HttpApi;\n\n  /**\n   * The configs for the static assets of the Nuxt app that shall be publicly available.\n   *\n   * @private\n   */\n  private staticAssetConfigs: StaticAssetConfig[];\n\n  /**\n   * The cloudfront distribution to route incoming requests to the Nuxt lambda function (via the API gateway)\n   * or the S3 assets folder (with caching).\n   *\n   * @private\n   */\n  private readonly cdn: Distribution;\n\n  constructor(scope: Construct, id: string, props: NuxtAppStackProps) {\n    super(scope, id, props);\n\n    this.resourceIdPrefix = `${props.project}-${props.service}-${props.environment}`;\n    this.deploymentRevision = new Date().toISOString();\n    this.staticAssetConfigs = getNuxtAppStaticAssetConfigs(props.nuxtConfig);\n    this.tlsCertificate = this.findTlsCertificate(props);\n    this.cdnAccessIdentity = this.createCdnAccessIdentity();\n    this.staticAssetsBucket = this.createStaticAssetsBucket();\n    this.lambdaFunction = this.createLambdaFunction();\n    this.apiGateway = this.createApiGateway();\n    this.cdn = this.createCloudFrontDistribution(props);\n    this.configureDeployments();\n    this.createDnsRecords(props);\n    this.createPingRule();\n  }\n\n  /**\n   * Finds the certificate to use for providing HTTPS requests to our Nuxt app.\n   *\n   * @param props\n   * @private\n   */\n  private findTlsCertificate(props: NuxtAppStackProps): ICertificate {\n    return Certificate.fromCertificateArn(this, `${this.resourceIdPrefix}-tls-certificate`, props.globalTlsCertificateArn);\n  }\n\n  /**\n   * Creates the identity to access our S3 deployment asset files via the cloudfront distribution.\n   *\n   * @private\n   */\n  private createCdnAccessIdentity(): IOriginAccessIdentity {\n    const originAccessIdentityName = `${this.resourceIdPrefix}-cdn-s3-access`;\n    return new OriginAccessIdentity(this, originAccessIdentityName);\n  }\n\n  /**\n   * Creates the bucket to store the static deployment asset files of the Nuxt app.\n   *\n   * @private\n   */\n  private createStaticAssetsBucket(): IBucket {\n    const bucketName = `${this.resourceIdPrefix}-assets`;\n    const bucket = new Bucket(this, bucketName, {\n      accessControl: BucketAccessControl.AUTHENTICATED_READ,\n      blockPublicAccess: BlockPublicAccess.BLOCK_ALL,\n      bucketName,\n      // The bucket and all of its objects can be deleted, because all the content is managed in this project\n      removalPolicy: RemovalPolicy.DESTROY,\n      autoDeleteObjects: true,\n    });\n\n    bucket.grantReadWrite(this.cdnAccessIdentity);\n\n    return bucket;\n  }\n\n  /**\n   * Creates a lambda layer with the node_modules required to render the Nuxt app on the server side.\n   *\n   * @private\n   */\n  private createSsrLambdaLayer(): LayerVersion {\n    const layerName = `${this.resourceIdPrefix}-ssr-layer`;\n    return new LayerVersion(this, layerName, {\n      layerVersionName: layerName,\n      code: Code.fromAsset('.nuxt/cdk-deployment/layer'),\n      compatibleRuntimes: [Runtime.NODEJS_12_X],\n      description: `Provides the node_modules required for SSR of ${this.resourceIdPrefix}.`,\n    });\n  }\n\n  /**\n   * Creates the lambda function to render the Nuxt app.\n   *\n   * @private\n   */\n  private createLambdaFunction(): Function {\n    const funcName = `${this.resourceIdPrefix}-function`;\n\n    return new Function(this, funcName, {\n      functionName: funcName,\n      description: `Renders the ${this.resourceIdPrefix} Nuxt app.`,\n      runtime: Runtime.NODEJS_12_X,\n      architecture: Architecture.ARM_64,\n      layers: [this.createSsrLambdaLayer()],\n      handler: 'index.handler',\n      code: Code.fromAsset('.nuxt/cdk-deployment/src', {\n        exclude: ['**.svg', '**.ico', '**.png', '**.jpg', 'chunk.*.js*', 'bundle.*.js*', 'bundle.*.js*', 'sw.js*'],\n      }),\n      timeout: Duration.seconds(10),\n      memorySize: 512,\n      logRetention: RetentionDays.ONE_MONTH,\n      allowPublicSubnet: false\n    });\n  }\n\n  /**\n   * Creates the API gateway to make the Nuxt app render lambda function publicly available.\n   *\n   * @private\n   */\n  private createApiGateway(): HttpApi {\n    const lambdaIntegration = new HttpLambdaIntegration(`${this.resourceIdPrefix}-lambda-integration`, this.lambdaFunction);\n    const apiName = `${this.resourceIdPrefix}-api`;\n    const apiGateway = new HttpApi(this, apiName, {\n      apiName,\n      description: `Connects the ${this.resourceIdPrefix} cloudfront distribution with the ${this.resourceIdPrefix} lambda function to make it publicly available.`,\n      // The app does not allow any cross-origin access by purpose: the app should not be embeddable anywhere\n      corsPreflight: undefined,\n      defaultIntegration: lambdaIntegration,\n    });\n\n    apiGateway.addRoutes({\n      integration: lambdaIntegration,\n      path: '/{proxy+}',\n      methods: [HttpMethod.GET, HttpMethod.HEAD],\n    });\n    return apiGateway;\n  }\n\n  /**\n   * Creates the cloudfront distribution that routes incoming requests to the Nuxt lambda function (via the API gateway)\n   * or the S3 assets folder (with caching).\n   *\n   * @param props\n   * @private\n   */\n  private createCloudFrontDistribution(props: NuxtAppStackProps): Distribution {\n    const cdnName = `${this.resourceIdPrefix}-cdn`;\n\n    return new Distribution(this, cdnName, {\n      domainNames: [props.domain],\n      comment: `${this.resourceIdPrefix}-redirect`,\n      minimumProtocolVersion: SecurityPolicyProtocol.TLS_V1_2_2018,\n      certificate: this.tlsCertificate,\n      defaultBehavior: this.createNuxtAppRouteBehavior(),\n      additionalBehaviors: this.createStaticAssetsRouteBehavior(),\n      priceClass: PriceClass.PRICE_CLASS_100, // Use only North America and Europe\n    });\n  }\n\n  /**\n   * Creates a behavior for the cloudfront distribution to route incoming requests to the Nuxt render lambda function (via API gateway).\n   * Additionally, this automatically redirects HTTP requests to HTTPS.\n   *\n   * @private\n   */\n  private createNuxtAppRouteBehavior(): BehaviorOptions {\n    return {\n      origin: new HttpOrigin(`${this.apiGateway.httpApiId}.execute-api.${this.region}.amazonaws.com`, {\n        connectionAttempts: 2,\n        connectionTimeout: Duration.seconds(2),\n        readTimeout: Duration.seconds(10),\n        protocolPolicy: OriginProtocolPolicy.HTTPS_ONLY,\n      }),\n      allowedMethods: AllowedMethods.ALLOW_GET_HEAD,\n      compress: true,\n      viewerProtocolPolicy: ViewerProtocolPolicy.REDIRECT_TO_HTTPS,\n      originRequestPolicy: undefined,\n      cachePolicy: this.createSsrCachePolicy(),\n    };\n  }\n\n  /**\n   * Creates a cache policy for the Nuxt app route behavior of our cloudfront distribution.\n   * Eventhough we don't want to cache SSR requests, we still have to create this cache policy in order to\n   * forward required cookies, query params and headers. This doesn't make any sense, because if nothing\n   * is cached, one would expect, that anything would/could be forwarded, but anyway...\n   */\n  private createSsrCachePolicy(): ICachePolicy {\n\n    // The headers to make accessible in our Nuxt app code\n    const headers = [\n      'User-Agent', // Required to distinguish between mobile and desktop template\n      'Authorization', // For authorization\n    ];\n\n    return new CachePolicy(this, `${this.resourceIdPrefix}-cache-policy`, {\n      cachePolicyName: `${this.resourceIdPrefix}-cdn-cache-policy`,\n      comment: `Passes all required request data to the ${this.resourceIdPrefix} origin.`,\n      defaultTtl: Duration.seconds(0),\n      minTtl: Duration.seconds(0),\n      maxTtl: Duration.seconds(1), // The max TTL must not be 0 for a cache policy\n      queryStringBehavior: CacheQueryStringBehavior.all(),\n      headerBehavior: CacheHeaderBehavior.allowList(...headers),\n      cookieBehavior: CacheCookieBehavior.all(),\n      enableAcceptEncodingBrotli: true,\n      enableAcceptEncodingGzip: true,\n    });\n  }\n\n  /**\n   * Creates a behavior for the cloudfront distribution to route matching incoming requests for our static assets\n   * to the S3 bucket that holds these static assets.\n   *\n   * @private\n   */\n  private createStaticAssetsRouteBehavior(): Record<string, BehaviorOptions> {\n    const staticAssetsCacheConfig: BehaviorOptions = {\n      origin: new S3Origin(this.staticAssetsBucket, {\n        connectionAttempts: 2,\n        connectionTimeout: Duration.seconds(3),\n        originAccessIdentity: this.cdnAccessIdentity,\n        originPath: this.deploymentRevision,\n      }),\n      compress: true,\n      allowedMethods: AllowedMethods.ALLOW_GET_HEAD_OPTIONS,\n      cachedMethods: CachedMethods.CACHE_GET_HEAD_OPTIONS,\n      cachePolicy: CachePolicy.CACHING_OPTIMIZED,\n      viewerProtocolPolicy: ViewerProtocolPolicy.REDIRECT_TO_HTTPS,\n    };\n\n    const rules: Record<string, BehaviorOptions> = {};\n    this.staticAssetConfigs.forEach(asset => {\n      rules[`${asset.target}${asset.pattern}`] = staticAssetsCacheConfig\n    })\n\n    return rules\n  }\n\n  /**\n   * Uploads the static assets of the Nuxt app as defined in {@see getNuxtAppStaticAssetConfigs} to the static assets S3 bucket.\n   * In order to enable a zero-downtime deployment, we use a new subdirectory (revision) for every deployment.\n   * The previous versions are retained to allow clients to continue to work with an older revision but gets cleaned up\n   * after a specified period of time via the lambda function in the {@see NuxtAppAssetsCleanupStack}.\n   */\n  private configureDeployments(): BucketDeployment[] {\n    const defaultCacheConfig = [\n      CacheControl.setPublic(),\n      CacheControl.maxAge(Duration.days(365)),\n      CacheControl.fromString('immutable'),\n    ];\n\n    // Returns a deployment for every configured static asset type to respect the different cache settings\n    return this.staticAssetConfigs.filter(asset => fs.existsSync(asset.source)).map((asset, assetIndex) => {\n      return new BucketDeployment(this, `${this.resourceIdPrefix}-assets-deployment-${assetIndex}`, {\n        sources: [Source.asset(asset.source)],\n        destinationBucket: this.staticAssetsBucket,\n        destinationKeyPrefix: this.deploymentRevision + asset.target,\n        prune: false,\n        storageClass: StorageClass.STANDARD,\n        exclude: ['*'],\n        include: [asset.pattern],\n        cacheControl: asset.cacheControl ?? defaultCacheConfig,\n        contentType: asset.contentType,\n      })\n    });\n  }\n\n  /**\n   * Resolves the hosted zone at which the DNS records shall be created to access our Nuxt app on the internet.\n   *\n   * @param props\n   * @private\n   */\n  private findHostedZone(props: NuxtAppStackProps): IHostedZone {\n    const domainParts = props.domain.split('.');\n\n    return HostedZone.fromHostedZoneAttributes(this, `${this.resourceIdPrefix}-hosted-zone`, {\n      hostedZoneId: props.hostedZoneId,\n      zoneName: domainParts[domainParts.length - 1], // Support subdomains\n    });\n  }\n\n  /**\n   * Creates the DNS records to access our Nuxt app on the internet via our custom domain.\n   *\n   * @param props\n   * @private\n   */\n  private createDnsRecords(props: NuxtAppStackProps): void {\n    const hostedZone = this.findHostedZone(props);\n    const dnsTarget = RecordTarget.fromAlias(new CloudFrontTarget(this.cdn));\n\n    // Create a record for IPv4\n    new ARecord(this, `${this.resourceIdPrefix}-ipv4-record`, {\n      recordName: props.domain,\n      zone: hostedZone,\n      target: dnsTarget,\n    });\n\n    // Create a record for IPv6\n    new AaaaRecord(this, `${this.resourceIdPrefix}-ipv6-record`, {\n      recordName: props.domain,\n      zone: hostedZone,\n      target: dnsTarget,\n    });\n  }\n\n  /**\n   * Creates a scheduled rule to ping our Nuxt app lambda function every 5 minutes in order to keep it warm\n   * and speed up initial SSR requests.\n   *\n   * @private\n   */\n  private createPingRule(): void {\n    new Rule(this, `${this.resourceIdPrefix}-pinger-rule`, {\n      ruleName: `${this.resourceIdPrefix}-pinger`,\n      description: `Pings the lambda function of the ${this.resourceIdPrefix} app every 5 minutes to keep it warm.`,\n      enabled: true,\n      schedule: Schedule.rate(Duration.minutes(5)),\n      targets: [new LambdaFunction(this.lambdaFunction)],\n    });\n  }\n}\n"]}