cdk-nuxt 0.3.3 → 0.3.7

package/README.md

@@ -1,5 +1,175 @@
-# Easy Nuxt deployments on AWS via CDK
+# CDK Nuxt Plugin
 
-This package allows deployments of Nuxt applications via CDK on AWS by using Route53, API Gateway, Cloudfront, Lambda and S3.
+<p>
+    <a href="https://github.com/ferdinandfrank/cdk-nuxt/actions/workflows/publish.yml"><img alt="Build" src="https://img.shields.io/github/workflow/status/ferdinandfrank/cdk-nuxt/Publish?logo=github" /></a>
+    <a href="https://www.npmjs.com/package/cdk-nuxt"><img alt="Version" src="https://img.shields.io/npm/v/cdk-nuxt.svg" /></a>
+    <a href="https://www.npmjs.com/package/cdk-nuxt"><img alt="License" src="https://img.shields.io/npm/l/cdk-nuxt.svg" /></a>
+</p>
 
-This package is currently in development and will be published with a full Readme shortly.
+Easily deploy a dynamic universal Nuxt application via CDK on AWS including the following features:
+
+- Fast responses via [Lambda](https://aws.amazon.com/lambda/)
+- Publicly available by a custom domain (or subdomain) via [Route53](https://aws.amazon.com/route53/) and [API Gateway](https://aws.amazon.com/api-gateway/)
+- Automatic redirects from HTTP to HTTPS via [CloudFront](https://aws.amazon.com/cloudfront/)
+- Automatic upload of the `client` build files for CSR and static assets to [S3](https://aws.amazon.com/s3/) with optimized caching rules
+- Scheduled pings of the Nuxt app to keep the Lambda warm for fast responses via [EventBridge](https://aws.amazon.com/eventbridge/) rules
+- Automatic cleanup of outdated static assets and build files
+
+> :warning: **This package might not support every Nuxt config yet.** But feel free to give it a try and open an issue or a PR if necessary.
+
+## Prerequisites
+
+- This package currently relies on using [yarn](https://yarnpkg.com/) instead of npm for deployment. Therefore, make sure to have yarn available on the deployment system.
+- You need an [AWS account](https://aws.amazon.com/premiumsupport/knowledge-center/create-and-activate-aws-account/?nc1=h_ls) to create and deploy the required resources for the Nuxt app on AWS.
+
+## Installation
+
+1. Install the package and its required dependencies:
+    ```bash
+    yarn add cdk-nuxt --dev # The package itself
+    yarn add ts-node typescript --dev # To compile the CDK stacks via typescript
+    yarn add aws-cdk@2.10.0 --dev # CDK cli with this exact version for the deployment
+    yarn add nuxt-aws-lambda nuxt-start # To make the Nuxt app renderable via AWS Lambda
+    ```
+
+2. Move the `nuxt` dependency to `devDependencies` as we installed `nuxt-start` to start our Nuxt app.<br/>Also, make sure that only the dependencies required for server-side rendering (SSR) are listed under `dependencies` to have the Lambda function and its layer as small as possible for better performance and to respect the [Lambda size limits](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-limits.html). Every other dependency should be under `devDependencies`. 
+   
+3. Move the `devDependencies` section in the `package.json` file above the `dependencies` section. This enables the deployment code to fully remove the `devDependencies` section while installing the Lambda layer for the `node_modules` to only keep the modules required for SSR and to keep it as small as possible.
+
+After the installation steps the `package.json` file should look something like this:
+
+```json
+{
+  "name": "nuxt-app",
+  "devDependencies": {
+    "aws-cdk": "2.10.0",
+    "cdk-nuxt": "^X.X.X",
+    "nuxt": "^X.X.X",
+    "ts-node": "^X.X.X",
+    "typescript": "^X.X.X"
+  },
+  "dependencies": {
+    "nuxt-aws-lambda": "^X.X.X",
+    "nuxt-start": "^X.X.X"
+  }
+}
+```
+
+## Setup
+
+1. Replace the `export default` part of your Nuxt configuration file (`nuxt.config.js`) with `module.exports =`, so it fits the following format:
+   ```js
+   // Change "export default" => "module.exports ="
+   module.exports = {
+     target: 'server',
+     ...
+   }
+   ```
+2. [Create an AWS account](https://aws.amazon.com/premiumsupport/knowledge-center/create-and-activate-aws-account/?nc1=h_ls), if you don't have one yet. Then login into the AWS console and note the `Account ID`. You will need it in step 5.
+3. [Create a hosted zone in Route53](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/AboutHZWorkingWith.html) for the desired domain, if you don't have one yet.<br/>This is required to create DNS records for the domain to make the Nuxt app publicly available on that domain.<br/>On the hosted zone details you should see the `Hosted zone ID` of the hosted zone. You will need it in step 5.
+4. [Request a public certificate in the AWS Certificate Manager (ACM)](https://docs.aws.amazon.com/acm/latest/userguide/gs-acm-request-public.html) for the desired domain in `us-east-1` (global) and validate it, if you don't have one yet.<br/>This is required to provide the Nuxt app via HTTPS on the public internet.<br/>Take note of the displayed `ARN` for the certificate. You will need it in step 5.<br/>**Important: The certificate must be issued in us-east-1 (global) regardless of the region used for the Nuxt app itself as it will be attached to the Cloudfront distribution which works globally.**
+5. Run the following command to automatically create the required CDK stack entrypoint at `stack/index.ts`. This file defines the config how the Nuxt app will be deployed via CDK. You should adapt the file to the project's needs, especially the props `env.account` (setup step 2), `hostedZoneId` (setup step 3) and `globalTlsCertificateArn` (setup step 4).
+
+   ```bash
+   node_modules/.bin/cdk-nuxt-init
+   ```
+
+   > :warning: It's recommended using a `.env` file or another secrets file to import the sensitive secrets into the `stack/index.ts` file.
+
+## Build and Deploy
+
+After the installation and the setup you are already good to go to build the Nuxt app and to deploy it to AWS with this package.
+
+1. Install the dependencies for the Nuxt app including the `devDependencies` as these are required to successfully build the app:
+   ```bash
+   yarn install --production=false
+   ```
+2. Build the Nuxt app with the build settings you need for the app:
+   ```bash
+   yarn build
+   ```
+3. Run the CDK deployment:
+   ```bash
+   node_modules/.bin/cdk-nuxt-deploy
+   ```
+   The deployment script will take care of installing only the dependencies that are required for the Nuxt app and deploying the Nuxt build files to AWS according to the stack settings in `stack/index.ts`.<br/>See the section Used AWS Resources for details on which resources will exactly be created on AWS.
+
+## Optional: Automatically deploy on every push (CD) via [GitHub Actions](https://github.com/features/actions)
+
+Feel free to copy the following GitHub Actions YAML file content into a YAML file at `.github/workflows/deploy.yml` to automatically build and deploy the Nuxt app to AWS on every push to a specific branch.<br/>This only works if you're using GitHub for the project's VCS repository.
+
+```yaml
+name: Deploy
+
+on:
+  push:
+    branches:
+      - master # Feel free to use another branch name
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        node-version: [ 14.x ]
+    steps:
+      - name: Checkout source code
+        uses: actions/checkout@v2
+
+      - name: Use Node.js ${{ matrix.node-version }}
+        uses: actions/setup-node@v1
+        with:
+          node-version: ${{ matrix.node-version }}
+
+      # Init cache to speed up yarn install
+      - name: Get yarn cache directory path
+        id: yarn-cache-dir-path
+        run: echo "::set-output name=dir::$(yarn cache dir)"
+
+      - uses: actions/cache@v2
+        with:
+          path: ${{ steps.yarn-cache-dir-path.outputs.dir }}
+          key: ${{ runner.os }}-node-${{ hashFiles('**/yarn.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-node-
+
+      # Optionally copy any secrets from the GitHub repository secrets to the deployment project directory right here
+
+      - name: Install dependencies
+        run: yarn install --production=false # Important to install devDependencies for the build
+
+      - name: Build project
+        run: yarn build # Should trigger 'nuxt build' according to the package.json
+
+      - name: Deploy to AWS
+        run: node_modules/.bin/nuxt-deploy
+        env:
+           # Create an IAM user on AWS for the deployment and create the appropriate secrets in the GitHub repository secrets
+          AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
+          AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
+          AWS_DEFAULT_REGION: ${{ secrets.AWS_DEFAULT_REGION }}
+```
+
+## Advanced: Used AWS Resources
+
+Two CDK stacks will be deployed to AWS using this package:
+
+### NuxtAppStack
+
+This is the main stack that is responsible for uploading all assets of the Nuxt app to AWS and to make it publicly reachable.
+The following AWS resources will be created by this stack:
+
+- [Lambda](https://aws.amazon.com/lambda/): A Lambda function to render the Nuxt app including a separated Lambda layer to provide the `node_modules` of the Nuxt app required for server-side rendering.
+- [S3](https://aws.amazon.com/s3/): A bucket to store the client files of the Nuxt build (`.nuxt/dist/client`) and the custom static files of the Nuxt app (`static`) with optimized cache settings.
+- [Route53](https://aws.amazon.com/route53/): Two DNS records (`A` for IPv4 and `AAAA` for IPv6) in the configured hosted zone to make the Nuxt app available on the internet via the configured custom domain.
+- [API Gateway](https://aws.amazon.com/api-gateway/): An HTTP API to make the Nuxt Lambda function publicly available.
+- [CloudFront](https://aws.amazon.com/cloudfront/): A distribution to route incoming requests to the Nuxt Lambda function (via the API Gateway) and the S3 bucket to serve the static assets for the Nuxt app.
+- [EventBridge](https://aws.amazon.com/eventbridge/): A scheduled rule to ping the Nuxt app's Lambda function every 5 minutes in order to keep it warm and to speed up initial SSR requests.
+
+### NuxtAppAssetsCleanupStack
+
+This stack is responsible for deleting outdated static assets from the S3 deployment bucket created by the NuxtAppStack.
+The following AWS resources will be created by this stack:
+
+- [Lambda](https://aws.amazon.com/lambda/): A Lambda function that deletes the outdated static assets of the Nuxt app from S3.
+- [EventBridge](https://aws.amazon.com/eventbridge/): A scheduled rule to trigger the stack's Lambda function every tuesday at 03:30 AM GMT.

package/lib/cli/deploy.js

@@ -3,7 +3,7 @@
 const shell = require("shelljs");
 const path = require("path");
 
-const logPrefix = 'Nuxt Deployment';
+const logPrefix = 'CDK Nuxt Deployment';
 
 shell.echo(`${logPrefix}: Starting deployment...`);
 
@@ -55,7 +55,14 @@ shell.cd(deploymentLayerFolder);
 
 // We do not want to install any dependencies listed under 'devDendencies'
 // Usually the --production flag should do the trick but somehow still installs some dev dependencies in some cases
-shell.exec('sed -i \'\' \'/\\"devDependencies\\"/,/}/ d; /^$/d\' package.json')
+const osSystem = shell.exec('echo $OSTYPE');
+const isMac = osSystem.startsWith('darwin')
+if (isMac) {
+    shell.exec('sed -i \'\' \'/\\"devDependencies\\"/,/}/ d\' package.json')
+} else {
+    shell.exec('sed -i \'/\\"devDependencies\\"/,/}/ d\' package.json')
+}
+
 if (shell.exec('yarn install --production --frozen-lockfile').code !== 0) {
     shell.echo(`${logPrefix} Error: Installation of lambda layer failed.`);
     shell.exit(1);

package/lib/cli/init.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+
+const shell = require("shelljs");
+const path = require("path");
+const fs = require("fs");
+
+const logPrefix = 'CDK Nuxt Init';
+
+shell.echo(`${logPrefix}: Initializing CDK stack index file...`);
+
+if (!fs.existsSync('stack')) {
+    shell.mkdir('-p', 'stack');
+    shell.cp(path.join(__dirname, '../templates/stack-index.ts'), 'stack/index.ts');
+    shell.echo(`${logPrefix}: CDK stack index file created. Please adapt the file at 'stack/index.ts' to the project's needs.`);
+} else {
+    shell.echo(`${logPrefix}: CDK stack folder already exists.`);
+}

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

@@ -102,7 +102,7 @@ class NuxtAppStack extends aws_cdk_lib_1.Stack {
             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*'],
+                exclude: ['**.svg', '**.ico', '**.png', '**.jpg', '**.js.map'],
             }),
             timeout: aws_cdk_lib_1.Duration.seconds(10),
             memorySize: 512,
@@ -303,4 +303,4 @@ class NuxtAppStack extends aws_cdk_lib_1.Stack {
     }
 }
 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} 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"]}
+//# 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', '**.js.map'],\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"]}

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

@@ -215,7 +215,7 @@ export class NuxtAppStack extends Stack {
       layers: [this.createSsrLambdaLayer()],
       handler: 'index.handler',
       code: Code.fromAsset('.nuxt/cdk-deployment/src', {
-        exclude: ['**.svg', '**.ico', '**.png', '**.jpg', 'chunk.*.js*', 'bundle.*.js*', 'bundle.*.js*', 'sw.js*'],
+        exclude: ['**.svg', '**.ico', '**.png', '**.jpg', '**.js.map'],
       }),
       timeout: Duration.seconds(10),
       memorySize: 512,

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

@@ -9,9 +9,11 @@ const aws_cdk_lib_1 = require("aws-cdk-lib");
  */
 const getNuxtAppStaticAssetConfigs = (nuxtConfig) => {
     var _a, _b;
+    // The build assets required for CSR that are generated by 'nuxt build'
     const buildAssetsSourcePath = './.nuxt/dist/client';
     const buildAssetsTargetPath = (_b = (_a = nuxtConfig.build) === null || _a === void 0 ? void 0 : _a.publicPath) !== null && _b !== void 0 ? _b : '/_nuxt/'; // Must match 'build.publicPath' in nuxt.config.js
-    const customAssetsSourcePath = `.${nuxtConfig.srcDir ? (nuxtConfig.srcDir + '/') : ''}/static`;
+    // The custom assets of the Nuxt app located in the src 'static' folder
+    const customAssetsSourcePath = `./${nuxtConfig.srcDir ? (nuxtConfig.srcDir + '/') : ''}static`;
     const customAssetsTargetPath = '/';
     return [
         // Build Assets
@@ -40,6 +42,12 @@ const getNuxtAppStaticAssetConfigs = (nuxtConfig) => {
             source: buildAssetsSourcePath,
             contentType: 'application/json; charset=UTF-8'
         },
+        {
+            pattern: '*.png',
+            source: buildAssetsTargetPath,
+            target: buildAssetsSourcePath,
+            contentType: 'image/png',
+        },
         {
             pattern: '*.svg',
             target: buildAssetsTargetPath,
@@ -91,13 +99,15 @@ const getNuxtAppStaticAssetConfigs = (nuxtConfig) => {
             cacheControl: [aws_s3_deployment_1.CacheControl.setPublic(), aws_s3_deployment_1.CacheControl.maxAge(aws_cdk_lib_1.Duration.days(1))],
         },
         {
-            pattern: 'sw.js',
+            pattern: '*.js',
             source: customAssetsSourcePath,
             target: customAssetsTargetPath,
             contentType: 'application/javascript; charset=UTF-8',
+            // The js files in the custom static directory are usually not versionized
+            // whereby we want to prevent any caching issues when updating them -> cache for only 2 days
             cacheControl: [aws_s3_deployment_1.CacheControl.setPublic(), aws_s3_deployment_1.CacheControl.maxAge(aws_cdk_lib_1.Duration.days(2))],
         },
     ];
 };
 exports.getNuxtAppStaticAssetConfigs = getNuxtAppStaticAssetConfigs;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nuxt-app-static-assets.js","sourceRoot":"","sources":["nuxt-app-static-assets.ts"],"names":[],"mappings":";;;AAAA,qEAA2D;AAC3D,6CAAqC;AA+BrC;;;GAGG;AACI,MAAM,4BAA4B,GAAG,CAAC,UAAsB,EAAuB,EAAE;;IAExF,MAAM,qBAAqB,GAAG,qBAAqB,CAAC;IACpD,MAAM,qBAAqB,GAAG,MAAA,MAAA,UAAU,CAAC,KAAK,0CAAE,UAAU,mCAAI,SAAS,CAAC,CAAC,kDAAkD;IAE3H,MAAM,sBAAsB,GAAG,IAAI,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,MAAM,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC;IAC/F,MAAM,sBAAsB,GAAG,GAAG,CAAC;IAEnC,OAAO;QAEH,eAAe;QACf;YACI,OAAO,EAAE,MAAM;YACf,MAAM,EAAE,qBAAqB;YAC7B,MAAM,EAAE,qBAAqB;YAC7B,WAAW,EAAE,uCAAuC;SACvD;QACD;YACI,OAAO,EAAE,UAAU;YACnB,MAAM,EAAE,qBAAqB;YAC7B,MAAM,EAAE,qBAAqB;YAC7B,WAAW,EAAE,iCAAiC;SACjD;QACD;YACI,OAAO,EAAE,OAAO;YAChB,MAAM,EAAE,qBAAqB;YAC7B,MAAM,EAAE,qBAAqB;YAC7B,WAAW,EAAE,yBAAyB;SACzC;QAED,iCAAiC;QACjC;YACI,OAAO,EAAE,iBAAiB;YAC1B,MAAM,EAAE,qBAAqB;YAC7B,MAAM,EAAE,qBAAqB;YAC7B,WAAW,EAAE,iCAAiC;SACjD;QACD;YACI,OAAO,EAAE,OAAO;YAChB,MAAM,EAAE,qBAAqB;YAC7B,MAAM,EAAE,qBAAqB;YAC7B,WAAW,EAAE,eAAe;SAC/B;QACD;YACI,OAAO,EAAE,OAAO;YAChB,MAAM,EAAE,qBAAqB;YAC7B,MAAM,EAAE,qBAAqB;YAC7B,WAAW,EAAE,+BAA+B;SAC/C;QACD;YACI,OAAO,EAAE,OAAO;YAChB,MAAM,EAAE,qBAAqB;YAC7B,MAAM,EAAE,qBAAqB;YAC7B,WAAW,EAAE,uBAAuB;SACvC;QACD;YACI,OAAO,EAAE,QAAQ;YACjB,MAAM,EAAE,qBAAqB;YAC7B,MAAM,EAAE,qBAAqB;YAC7B,WAAW,EAAE,WAAW;SAC3B;QACD;YACI,OAAO,EAAE,SAAS;YAClB,MAAM,EAAE,qBAAqB;YAC7B,MAAM,EAAE,qBAAqB;YAC7B,WAAW,EAAE,YAAY;SAC5B;QAED,uBAAuB;QACvB;YACI,OAAO,EAAE,OAAO;YAChB,MAAM,EAAE,sBAAsB;YAC9B,MAAM,EAAE,sBAAsB;YAC9B,WAAW,EAAE,WAAW;SAC3B;QACD;YACI,OAAO,EAAE,OAAO;YAChB,MAAM,EAAE,sBAAsB;YAC9B,MAAM,EAAE,sBAAsB;YAC9B,WAAW,EAAE,WAAW;SAC3B;QACD;YACI,OAAO,EAAE,YAAY;YACrB,MAAM,EAAE,sBAAsB;YAC9B,MAAM,EAAE,sBAAsB;YAC9B,WAAW,EAAE,2BAA2B;YACxC,YAAY,EAAE,CAAC,gCAAY,CAAC,SAAS,EAAE,EAAE,gCAAY,CAAC,MAAM,CAAC,sBAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;SAClF;QACD;YACI,OAAO,EAAE,OAAO;YAChB,MAAM,EAAE,sBAAsB;YAC9B,MAAM,EAAE,sBAAsB;YAC9B,WAAW,EAAE,uCAAuC;YACpD,YAAY,EAAE,CAAC,gCAAY,CAAC,SAAS,EAAE,EAAE,gCAAY,CAAC,MAAM,CAAC,sBAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;SAClF;KACJ,CAAA;AACL,CAAC,CAAC;AAhGW,QAAA,4BAA4B,gCAgGvC","sourcesContent":["import {CacheControl} from \"aws-cdk-lib/aws-s3-deployment\";\nimport {Duration} from \"aws-cdk-lib\";\nimport {NuxtConfig} from \"./nuxt-config\";\n\nexport interface StaticAssetConfig {\n    /**\n     * The file pattern for the incoming requests that should be forwarded to the target path in the static assets S3 bucket\n     * with the appropriate cache and content settings defined in the same object.\n     */\n    pattern: string,\n\n    /**\n     * The local directory to upload the files from.\n     */\n    source: string,\n\n    /**\n     * The remote path at which to make the uploaded files from source accessible.\n     */\n    target: string,\n\n    /**\n     * The content type to set for the files in the source folder when uploading them to the target.\n     */\n    contentType: string,\n\n    /**\n     * The cache settings to use for the uploaded source files when accessing them on the target path with the specified pattern.\n     */\n    cacheControl?: CacheControl[]\n}\n\n/**\n * Retrieves the static assets of the Nuxt app that shall be publicly available.\n * These should match the files in '.nuxt/dist/client' and 'static'.\n */\nexport const getNuxtAppStaticAssetConfigs = (nuxtConfig: NuxtConfig): StaticAssetConfig[] => {\n\n    const buildAssetsSourcePath = './.nuxt/dist/client';\n    const buildAssetsTargetPath = nuxtConfig.build?.publicPath ?? '/_nuxt/'; // Must match 'build.publicPath' in nuxt.config.js\n\n    const customAssetsSourcePath = `.${nuxtConfig.srcDir ? (nuxtConfig.srcDir + '/') : ''}/static`;\n    const customAssetsTargetPath = '/';\n\n    return [\n\n        // Build Assets\n        {\n            pattern: '*.js',\n            target: buildAssetsTargetPath,\n            source: buildAssetsSourcePath,\n            contentType: 'application/javascript; charset=UTF-8',\n        },\n        {\n            pattern: '*.js.map',\n            target: buildAssetsTargetPath,\n            source: buildAssetsSourcePath,\n            contentType: 'application/json; charset=UTF-8',\n        },\n        {\n            pattern: '*.css',\n            target: buildAssetsTargetPath,\n            source: buildAssetsSourcePath,\n            contentType: 'text/css; charset=UTF-8',\n        },\n\n        // Manifest created by PWA module\n        {\n            pattern: 'manifest.*.json',\n            target: buildAssetsTargetPath,\n            source: buildAssetsSourcePath,\n            contentType: 'application/json; charset=UTF-8'\n        },\n        {\n            pattern: '*.svg',\n            target: buildAssetsTargetPath,\n            source: buildAssetsSourcePath,\n            contentType: 'image/svg+xml',\n        },\n        {\n            pattern: '*.eot',\n            target: buildAssetsTargetPath,\n            source: buildAssetsSourcePath,\n            contentType: 'application/vnd.ms-fontobject',\n        },\n        {\n            pattern: '*.ttf',\n            target: buildAssetsTargetPath,\n            source: buildAssetsSourcePath,\n            contentType: 'application/font-sfnt',\n        },\n        {\n            pattern: '*.woff',\n            target: buildAssetsTargetPath,\n            source: buildAssetsSourcePath,\n            contentType: 'font/woff',\n        },\n        {\n            pattern: '*.woff2',\n            target: buildAssetsTargetPath,\n            source: buildAssetsSourcePath,\n            contentType: 'font/woff2',\n        },\n\n        // Custom Static Assets\n        {\n            pattern: '*.png',\n            source: customAssetsSourcePath,\n            target: customAssetsTargetPath,\n            contentType: 'image/png',\n        },\n        {\n            pattern: '*.jpg',\n            source: customAssetsSourcePath,\n            target: customAssetsTargetPath,\n            contentType: 'image/jpg',\n        },\n        {\n            pattern: 'robots.txt',\n            source: customAssetsSourcePath,\n            target: customAssetsTargetPath,\n            contentType: 'text/plain; charset=UTF-8',\n            cacheControl: [CacheControl.setPublic(), CacheControl.maxAge(Duration.days(1))],\n        },\n        {\n            pattern: 'sw.js',\n            source: customAssetsSourcePath,\n            target: customAssetsTargetPath,\n            contentType: 'application/javascript; charset=UTF-8',\n            cacheControl: [CacheControl.setPublic(), CacheControl.maxAge(Duration.days(2))],\n        },\n    ]\n};"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nuxt-app-static-assets.js","sourceRoot":"","sources":["nuxt-app-static-assets.ts"],"names":[],"mappings":";;;AAAA,qEAA2D;AAC3D,6CAAqC;AA+BrC;;;GAGG;AACI,MAAM,4BAA4B,GAAG,CAAC,UAAsB,EAAuB,EAAE;;IAExF,uEAAuE;IACvE,MAAM,qBAAqB,GAAG,qBAAqB,CAAC;IACpD,MAAM,qBAAqB,GAAG,MAAA,MAAA,UAAU,CAAC,KAAK,0CAAE,UAAU,mCAAI,SAAS,CAAC,CAAC,kDAAkD;IAE3H,uEAAuE;IACvE,MAAM,sBAAsB,GAAG,KAAK,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,MAAM,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,QAAQ,CAAC;IAC/F,MAAM,sBAAsB,GAAG,GAAG,CAAC;IAEnC,OAAO;QAEH,eAAe;QACf;YACI,OAAO,EAAE,MAAM;YACf,MAAM,EAAE,qBAAqB;YAC7B,MAAM,EAAE,qBAAqB;YAC7B,WAAW,EAAE,uCAAuC;SACvD;QACD;YACI,OAAO,EAAE,UAAU;YACnB,MAAM,EAAE,qBAAqB;YAC7B,MAAM,EAAE,qBAAqB;YAC7B,WAAW,EAAE,iCAAiC;SACjD;QACD;YACI,OAAO,EAAE,OAAO;YAChB,MAAM,EAAE,qBAAqB;YAC7B,MAAM,EAAE,qBAAqB;YAC7B,WAAW,EAAE,yBAAyB;SACzC;QAED,iCAAiC;QACjC;YACI,OAAO,EAAE,iBAAiB;YAC1B,MAAM,EAAE,qBAAqB;YAC7B,MAAM,EAAE,qBAAqB;YAC7B,WAAW,EAAE,iCAAiC;SACjD;QACD;YACI,OAAO,EAAE,OAAO;YAChB,MAAM,EAAE,qBAAqB;YAC7B,MAAM,EAAE,qBAAqB;YAC7B,WAAW,EAAE,WAAW;SAC3B;QACD;YACI,OAAO,EAAE,OAAO;YAChB,MAAM,EAAE,qBAAqB;YAC7B,MAAM,EAAE,qBAAqB;YAC7B,WAAW,EAAE,eAAe;SAC/B;QACD;YACI,OAAO,EAAE,OAAO;YAChB,MAAM,EAAE,qBAAqB;YAC7B,MAAM,EAAE,qBAAqB;YAC7B,WAAW,EAAE,+BAA+B;SAC/C;QACD;YACI,OAAO,EAAE,OAAO;YAChB,MAAM,EAAE,qBAAqB;YAC7B,MAAM,EAAE,qBAAqB;YAC7B,WAAW,EAAE,uBAAuB;SACvC;QACD;YACI,OAAO,EAAE,QAAQ;YACjB,MAAM,EAAE,qBAAqB;YAC7B,MAAM,EAAE,qBAAqB;YAC7B,WAAW,EAAE,WAAW;SAC3B;QACD;YACI,OAAO,EAAE,SAAS;YAClB,MAAM,EAAE,qBAAqB;YAC7B,MAAM,EAAE,qBAAqB;YAC7B,WAAW,EAAE,YAAY;SAC5B;QAED,uBAAuB;QACvB;YACI,OAAO,EAAE,OAAO;YAChB,MAAM,EAAE,sBAAsB;YAC9B,MAAM,EAAE,sBAAsB;YAC9B,WAAW,EAAE,WAAW;SAC3B;QACD;YACI,OAAO,EAAE,OAAO;YAChB,MAAM,EAAE,sBAAsB;YAC9B,MAAM,EAAE,sBAAsB;YAC9B,WAAW,EAAE,WAAW;SAC3B;QACD;YACI,OAAO,EAAE,YAAY;YACrB,MAAM,EAAE,sBAAsB;YAC9B,MAAM,EAAE,sBAAsB;YAC9B,WAAW,EAAE,2BAA2B;YACxC,YAAY,EAAE,CAAC,gCAAY,CAAC,SAAS,EAAE,EAAE,gCAAY,CAAC,MAAM,CAAC,sBAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;SAClF;QACD;YACI,OAAO,EAAE,MAAM;YACf,MAAM,EAAE,sBAAsB;YAC9B,MAAM,EAAE,sBAAsB;YAC9B,WAAW,EAAE,uCAAuC;YACpD,0EAA0E;YAC1E,4FAA4F;YAC5F,YAAY,EAAE,CAAC,gCAAY,CAAC,SAAS,EAAE,EAAE,gCAAY,CAAC,MAAM,CAAC,sBAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;SAClF;KACJ,CAAA;AACL,CAAC,CAAC;AA1GW,QAAA,4BAA4B,gCA0GvC","sourcesContent":["import {CacheControl} from \"aws-cdk-lib/aws-s3-deployment\";\nimport {Duration} from \"aws-cdk-lib\";\nimport {NuxtConfig} from \"./nuxt-config\";\n\nexport interface StaticAssetConfig {\n    /**\n     * The file pattern for the incoming requests that should be forwarded to the target path in the static assets S3 bucket\n     * with the appropriate cache and content settings defined in the same object.\n     */\n    pattern: string,\n\n    /**\n     * The local directory to upload the files from.\n     */\n    source: string,\n\n    /**\n     * The remote path at which to make the uploaded files from source accessible.\n     */\n    target: string,\n\n    /**\n     * The content type to set for the files in the source folder when uploading them to the target.\n     */\n    contentType: string,\n\n    /**\n     * The cache settings to use for the uploaded source files when accessing them on the target path with the specified pattern.\n     */\n    cacheControl?: CacheControl[]\n}\n\n/**\n * Retrieves the static assets of the Nuxt app that shall be publicly available.\n * These should match the files in '.nuxt/dist/client' and 'static'.\n */\nexport const getNuxtAppStaticAssetConfigs = (nuxtConfig: NuxtConfig): StaticAssetConfig[] => {\n\n    // The build assets required for CSR that are generated by 'nuxt build'\n    const buildAssetsSourcePath = './.nuxt/dist/client';\n    const buildAssetsTargetPath = nuxtConfig.build?.publicPath ?? '/_nuxt/'; // Must match 'build.publicPath' in nuxt.config.js\n\n    // The custom assets of the Nuxt app located in the src 'static' folder\n    const customAssetsSourcePath = `./${nuxtConfig.srcDir ? (nuxtConfig.srcDir + '/') : ''}static`;\n    const customAssetsTargetPath = '/';\n\n    return [\n\n        // Build Assets\n        {\n            pattern: '*.js',\n            target: buildAssetsTargetPath,\n            source: buildAssetsSourcePath,\n            contentType: 'application/javascript; charset=UTF-8',\n        },\n        {\n            pattern: '*.js.map',\n            target: buildAssetsTargetPath,\n            source: buildAssetsSourcePath,\n            contentType: 'application/json; charset=UTF-8',\n        },\n        {\n            pattern: '*.css',\n            target: buildAssetsTargetPath,\n            source: buildAssetsSourcePath,\n            contentType: 'text/css; charset=UTF-8',\n        },\n\n        // Manifest created by PWA module\n        {\n            pattern: 'manifest.*.json',\n            target: buildAssetsTargetPath,\n            source: buildAssetsSourcePath,\n            contentType: 'application/json; charset=UTF-8'\n        },\n        {\n            pattern: '*.png',\n            source: buildAssetsTargetPath,\n            target: buildAssetsSourcePath,\n            contentType: 'image/png',\n        },\n        {\n            pattern: '*.svg',\n            target: buildAssetsTargetPath,\n            source: buildAssetsSourcePath,\n            contentType: 'image/svg+xml',\n        },\n        {\n            pattern: '*.eot',\n            target: buildAssetsTargetPath,\n            source: buildAssetsSourcePath,\n            contentType: 'application/vnd.ms-fontobject',\n        },\n        {\n            pattern: '*.ttf',\n            target: buildAssetsTargetPath,\n            source: buildAssetsSourcePath,\n            contentType: 'application/font-sfnt',\n        },\n        {\n            pattern: '*.woff',\n            target: buildAssetsTargetPath,\n            source: buildAssetsSourcePath,\n            contentType: 'font/woff',\n        },\n        {\n            pattern: '*.woff2',\n            target: buildAssetsTargetPath,\n            source: buildAssetsSourcePath,\n            contentType: 'font/woff2',\n        },\n\n        // Custom Static Assets\n        {\n            pattern: '*.png',\n            source: customAssetsSourcePath,\n            target: customAssetsTargetPath,\n            contentType: 'image/png',\n        },\n        {\n            pattern: '*.jpg',\n            source: customAssetsSourcePath,\n            target: customAssetsTargetPath,\n            contentType: 'image/jpg',\n        },\n        {\n            pattern: 'robots.txt',\n            source: customAssetsSourcePath,\n            target: customAssetsTargetPath,\n            contentType: 'text/plain; charset=UTF-8',\n            cacheControl: [CacheControl.setPublic(), CacheControl.maxAge(Duration.days(1))],\n        },\n        {\n            pattern: '*.js',\n            source: customAssetsSourcePath,\n            target: customAssetsTargetPath,\n            contentType: 'application/javascript; charset=UTF-8',\n            // The js files in the custom static directory are usually not versionized\n            // whereby we want to prevent any caching issues when updating them -> cache for only 2 days\n            cacheControl: [CacheControl.setPublic(), CacheControl.maxAge(Duration.days(2))],\n        },\n    ]\n};"]}

package/lib/stack/nuxt-app-static-assets.ts

@@ -36,10 +36,12 @@ export interface StaticAssetConfig {
  */
 export const getNuxtAppStaticAssetConfigs = (nuxtConfig: NuxtConfig): StaticAssetConfig[] => {
 
+    // The build assets required for CSR that are generated by 'nuxt build'
     const buildAssetsSourcePath = './.nuxt/dist/client';
     const buildAssetsTargetPath = nuxtConfig.build?.publicPath ?? '/_nuxt/'; // Must match 'build.publicPath' in nuxt.config.js
 
-    const customAssetsSourcePath = `.${nuxtConfig.srcDir ? (nuxtConfig.srcDir + '/') : ''}/static`;
+    // The custom assets of the Nuxt app located in the src 'static' folder
+    const customAssetsSourcePath = `./${nuxtConfig.srcDir ? (nuxtConfig.srcDir + '/') : ''}static`;
     const customAssetsTargetPath = '/';
 
     return [
@@ -71,6 +73,12 @@ export const getNuxtAppStaticAssetConfigs = (nuxtConfig: NuxtConfig): StaticAsse
             source: buildAssetsSourcePath,
             contentType: 'application/json; charset=UTF-8'
         },
+        {
+            pattern: '*.png',
+            source: buildAssetsTargetPath,
+            target: buildAssetsSourcePath,
+            contentType: 'image/png',
+        },
         {
             pattern: '*.svg',
             target: buildAssetsTargetPath,
@@ -123,10 +131,12 @@ export const getNuxtAppStaticAssetConfigs = (nuxtConfig: NuxtConfig): StaticAsse
             cacheControl: [CacheControl.setPublic(), CacheControl.maxAge(Duration.days(1))],
         },
         {
-            pattern: 'sw.js',
+            pattern: '*.js',
             source: customAssetsSourcePath,
             target: customAssetsTargetPath,
             contentType: 'application/javascript; charset=UTF-8',
+            // The js files in the custom static directory are usually not versionized
+            // whereby we want to prevent any caching issues when updating them -> cache for only 2 days
             cacheControl: [CacheControl.setPublic(), CacheControl.maxAge(Duration.days(2))],
         },
     ]

package/lib/templates/stack-index.ts

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+import {App} from "aws-cdk-lib";
+import {NuxtAppStack, NuxtAppStackProps, NuxtAppAssetsCleanupProps, NuxtAppAssetsCleanupStack, AppStackProps} from "cdk-nuxt";
+const NuxtConfig = require('../nuxt.config');
+
+const app: App = new App();
+
+const commonProps: AppStackProps = {
+    // The AWS environment (account/region) where this stack will be deployed.
+    env: {
+        // The ID of your AWS account on which to deploy the stack.
+        account: 'XXXXXXXX',
+
+        // The AWS region where to deploy the Nuxt app.
+        region: 'eu-central-1'
+    },
+    // A string identifier for the project the Nuxt app is part of. A project might have multiple different services.
+    project: 'my-project',
+    // A string identifier for the project's service the Nuxt app is created for. This can be seen as the name of the Nuxt app.
+    service: 'nuxt-app',
+    // A string to identify the environment of the Nuxt app.
+    environment: 'dev',
+    // Stack tags that will be applied to all the taggable resources and the stack itself.
+    tags: {
+        service: 'nuxt-app'
+    }
+};
+
+const appStackProps: NuxtAppStackProps = {
+    ...commonProps,
+    // The domain (without the protocol) at which the Nuxt app shall be publicly available.
+    domain: 'example.com',
+    // 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.
+    globalTlsCertificateArn: 'arn:aws:acm:us-east-1:XXXXXXXXXX:certificate/XXXXXXXXXXXXXXXXX',
+    // The id of the hosted zone to create a DNS record for the specified domain.
+    hostedZoneId: 'XXXXXXXXXXXXX',
+
+    nuxtConfig: NuxtConfig
+};
+const appStack = new NuxtAppStack(app, `${appStackProps.project}-${appStackProps.service}-${appStackProps.environment}-stack`, appStackProps);
+
+const cleanupStackProps: NuxtAppAssetsCleanupProps = {
+    ...commonProps,
+    service: `${appStackProps.service}-assets-cleanup`,
+    staticAssetsBucket: appStack.staticAssetsBucket,
+};
+new NuxtAppAssetsCleanupStack(app, `${cleanupStackProps.project}-${cleanupStackProps.service}-${cleanupStackProps.environment}-stack`, cleanupStackProps);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cdk-nuxt",
-  "version": "0.3.3",
+  "version": "0.3.7",
   "license": "MIT",
   "files": [
     "lib",
@@ -9,7 +9,8 @@
   "main": "index.js",
   "types": "index.d.ts",
   "bin": {
-    "nuxt-deploy": "./lib/cli/deploy.js"
+    "cdk-nuxt-init": "./lib/cli/init.js",
+    "cdk-nuxt-deploy": "./lib/cli/deploy.js"
   },
   "scripts": {
     "build": "tsc"
@@ -30,7 +31,7 @@
     "source-map-support": "^0.5.16"
   },
   "peerDependencies": {
-    "aws-cdk": "^2.10.0",
+    "aws-cdk": "2.10.0",
     "nuxt-aws-lambda": "^1.5.0",
     "nuxt-start": "^2.15.8",
     "ts-node": "^10.5.0",