cdk-nuxt 0.10.0 → 0.10.2

package/index.d.ts

@@ -0,0 +1,2 @@
+export { NuxtServerAppStack, NuxtServerAppStackProps } from "./lib/stack/server/nuxt-server-app-stack";
+export { NuxtStaticAppStack, NuxtStaticAppStackProps } from "./lib/stack/static/nuxt-static-app-stack";

package/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NuxtStaticAppStack = exports.NuxtServerAppStack = void 0;
+var nuxt_server_app_stack_1 = require("./lib/stack/server/nuxt-server-app-stack");
+Object.defineProperty(exports, "NuxtServerAppStack", { enumerable: true, get: function () { return nuxt_server_app_stack_1.NuxtServerAppStack; } });
+var nuxt_static_app_stack_1 = require("./lib/stack/static/nuxt-static-app-stack");
+Object.defineProperty(exports, "NuxtStaticAppStack", { enumerable: true, get: function () { return nuxt_static_app_stack_1.NuxtStaticAppStack; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSxrRkFBb0c7QUFBNUYsMkhBQUEsa0JBQWtCLE9BQUE7QUFDMUIsa0ZBQW9HO0FBQTVGLDJIQUFBLGtCQUFrQixPQUFBIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHtOdXh0U2VydmVyQXBwU3RhY2ssIE51eHRTZXJ2ZXJBcHBTdGFja1Byb3BzfSBmcm9tIFwiLi9saWIvc3RhY2svc2VydmVyL251eHQtc2VydmVyLWFwcC1zdGFja1wiXG5leHBvcnQge051eHRTdGF0aWNBcHBTdGFjaywgTnV4dFN0YXRpY0FwcFN0YWNrUHJvcHN9IGZyb20gXCIuL2xpYi9zdGFjay9zdGF0aWMvbnV4dC1zdGF0aWMtYXBwLXN0YWNrXCJcbiJdfQ==

package/lib/functions/assets-cleanup/index.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/functions/assets-cleanup/index.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const client_s3_1 = require("@aws-sdk/client-s3");
+const ONE_WEEK_IN_MILLISECONDS = 1000 * 60 * 60 * 24 * 7;
+exports.handler = async (event, context) => {
+    var _a;
+    console.log('Starting cleanup of static assets older than 1 week...');
+    try {
+        const client = new client_s3_1.S3Client({ region: process.env.AWS_REGION });
+        const bucketName = process.env.STATIC_ASSETS_BUCKET;
+        if (!bucketName) {
+            throw new Error("Static asset's bucket name not specified in environment!");
+        }
+        const deleteOlderThan = new Date(Date.now() - ONE_WEEK_IN_MILLISECONDS);
+        // As we don't have hundreds of deployments per week, there's no need for pagination
+        const deploymentFolders = await client.send(new client_s3_1.ListObjectsV2Command({
+            Bucket: bucketName,
+            Delimiter: '/', // Only retrieve the top level folders
+        }));
+        // The result is a list of objects containing the keys with a trailing slash
+        const folderNames = (_a = deploymentFolders.CommonPrefixes) === null || _a === void 0 ? void 0 : _a.map(folder => { var _a; return (_a = folder.Prefix) === null || _a === void 0 ? void 0 : _a.slice(0, -1); });
+        if (!folderNames) {
+            console.log('Canceled static assets cleanup as folder is empty.');
+            return;
+        }
+        // We sort the folders by their creation data and remove the latest one as this is the currently active one used in production
+        const legacyFolderNames = folderNames.sort((a, b) => {
+            // @ts-ignore
+            const creationDateA = new Date(a);
+            // @ts-ignore
+            const creationDateB = new Date(b);
+            return creationDateA.getTime() < creationDateB.getTime() ? -1 : 1;
+        });
+        const activeFolderName = legacyFolderNames.pop();
+        console.log(`Detected assets folder "${activeFolderName}" as current production folder...`);
+        // We want to get all outdated folders of our legacy (not productively used) folders for deletion
+        const outdatedFolderNames = legacyFolderNames.filter(folderName => {
+            // @ts-ignore
+            const creationDate = new Date(folderName);
+            return creationDate.getTime() < deleteOlderThan.getTime();
+        });
+        if (!outdatedFolderNames || outdatedFolderNames.length === 0) {
+            console.log('No outdated asset folders found.');
+        }
+        else {
+            console.log(`Deleting ${outdatedFolderNames.length} outdated folders...`);
+            // Unfortunately it's not possible to delete folders recursively 🙄
+            // so we need to query all the contents in order to delete them
+            const pendingPromises = outdatedFolderNames.map(folderName => {
+                return client
+                    .send(new client_s3_1.ListObjectsV2Command({
+                    Bucket: bucketName,
+                    Prefix: folderName,
+                }))
+                    .then(outdatedAssets => {
+                    var _a;
+                    return client.send(new client_s3_1.DeleteObjectsCommand({
+                        Bucket: bucketName,
+                        Delete: {
+                            Objects: (_a = outdatedAssets.Contents) === null || _a === void 0 ? void 0 : _a.map(outdatedAsset => {
+                                return { Key: outdatedAsset.Key };
+                            }),
+                        },
+                    }));
+                });
+            });
+            const results = await Promise.all(pendingPromises);
+            results.forEach(result => {
+                if (result.Errors && result.Errors.length) {
+                    const errorMsg = 'Failed to delete outdated static assets.';
+                    console.error(errorMsg, result.Errors);
+                    throw new Error(errorMsg);
+                }
+            });
+        }
+        console.log('Cleanup of old static assets finished.');
+    }
+    catch (error) {
+        console.error('### unexpected runtime error ###', error);
+    }
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":";;AAAA,kDAAwF;AAExF,MAAM,wBAAwB,GAAG,IAAI,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC;AAEzD,OAAO,CAAC,OAAO,GAAG,KAAK,EAAE,KAAU,EAAE,OAAY,EAAE,EAAE;;IACjD,OAAO,CAAC,GAAG,CAAC,wDAAwD,CAAC,CAAC;IAEtE,IAAI;QACA,MAAM,MAAM,GAAG,IAAI,oBAAQ,CAAC,EAAC,MAAM,EAAE,OAAO,CAAC,GAAG,CAAC,UAAU,EAAC,CAAC,CAAC;QAC9D,MAAM,UAAU,GAAG,OAAO,CAAC,GAAG,CAAC,oBAAoB,CAAC;QAEpD,IAAI,CAAC,UAAU,EAAE;YACb,MAAM,IAAI,KAAK,CAAC,0DAA0D,CAAC,CAAC;SAC/E;QAED,MAAM,eAAe,GAAG,IAAI,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,wBAAwB,CAAC,CAAC;QAExE,oFAAoF;QACpF,MAAM,iBAAiB,GAAG,MAAM,MAAM,CAAC,IAAI,CACvC,IAAI,gCAAoB,CAAC;YACrB,MAAM,EAAE,UAAU;YAClB,SAAS,EAAE,GAAG,EAAE,sCAAsC;SACzD,CAAC,CACL,CAAC;QAEF,4EAA4E;QAC5E,MAAM,WAAW,GAAG,MAAA,iBAAiB,CAAC,cAAc,0CAAE,GAAG,CAAC,MAAM,CAAC,EAAE,WAAC,OAAA,MAAA,MAAM,CAAC,MAAM,0CAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA,EAAA,CAAC,CAAA;QAChG,IAAI,CAAC,WAAW,EAAE;YACd,OAAO,CAAC,GAAG,CAAC,oDAAoD,CAAC,CAAC;YAClE,OAAO;SACV;QAED,8HAA8H;QAC9H,MAAM,iBAAiB,GAAG,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,EAAC,CAAC,EAAE,EAAE;YAC/C,aAAa;YACb,MAAM,aAAa,GAAG,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC;YAClC,aAAa;YACb,MAAM,aAAa,GAAG,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC;YAElC,OAAO,aAAa,CAAC,OAAO,EAAE,GAAG,aAAa,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QACtE,CAAC,CAAC,CAAA;QACF,MAAM,gBAAgB,GAAG,iBAAiB,CAAC,GAAG,EAAE,CAAC;QACjD,OAAO,CAAC,GAAG,CAAC,2BAA2B,gBAAgB,mCAAmC,CAAC,CAAC;QAE5F,iGAAiG;QACjG,MAAM,mBAAmB,GAAG,iBAAiB,CAAC,MAAM,CAAC,UAAU,CAAC,EAAE;YAC1D,aAAa;YACb,MAAM,YAAY,GAAG,IAAI,IAAI,CAAC,UAAU,CAAC,CAAC;YAC1C,OAAO,YAAY,CAAC,OAAO,EAAE,GAAG,eAAe,CAAC,OAAO,EAAE,CAAC;QAC9D,CAAC,CACJ,CAAC;QAEF,IAAI,CAAC,mBAAmB,IAAI,mBAAmB,CAAC,MAAM,KAAK,CAAC,EAAE;YAC1D,OAAO,CAAC,GAAG,CAAC,kCAAkC,CAAC,CAAC;SACnD;aAAM;YACH,OAAO,CAAC,GAAG,CAAC,YAAY,mBAAmB,CAAC,MAAM,sBAAsB,CAAC,CAAC;YAE1E,mEAAmE;YACnE,+DAA+D;YAC/D,MAAM,eAAe,GAAG,mBAAmB,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE;gBACzD,OAAO,MAAM;qBACR,IAAI,CACD,IAAI,gCAAoB,CAAC;oBACrB,MAAM,EAAE,UAAU;oBAClB,MAAM,EAAE,UAAU;iBACrB,CAAC,CACL;qBACA,IAAI,CAAC,cAAc,CAAC,EAAE;;oBACnB,OAAO,MAAM,CAAC,IAAI,CACd,IAAI,gCAAoB,CAAC;wBACrB,MAAM,EAAE,UAAU;wBAClB,MAAM,EAAE;4BACJ,OAAO,EAAE,MAAA,cAAc,CAAC,QAAQ,0CAAE,GAAG,CAAC,aAAa,CAAC,EAAE;gCAClD,OAAO,EAAC,GAAG,EAAE,aAAa,CAAC,GAAG,EAAC,CAAC;4BACpC,CAAC,CAAC;yBACL;qBACJ,CAAC,CACL,CAAC;gBACN,CAAC,CAAC,CAAC;YACX,CAAC,CAAC,CAAC;YAEH,MAAM,OAAO,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC;YACnD,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE;gBACrB,IAAI,MAAM,CAAC,MAAM,IAAI,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE;oBACvC,MAAM,QAAQ,GAAG,0CAA0C,CAAC;oBAC5D,OAAO,CAAC,KAAK,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC;oBACvC,MAAM,IAAI,KAAK,CAAC,QAAQ,CAAC,CAAC;iBAC7B;YACL,CAAC,CAAC,CAAC;SACN;QAED,OAAO,CAAC,GAAG,CAAC,wCAAwC,CAAC,CAAC;KACzD;IAAC,OAAO,KAAK,EAAE;QACZ,OAAO,CAAC,KAAK,CAAC,kCAAkC,EAAE,KAAK,CAAC,CAAC;KAC5D;AACL,CAAC,CAAC","sourcesContent":["import {DeleteObjectsCommand, ListObjectsV2Command, S3Client} from \"@aws-sdk/client-s3\";\n\nconst ONE_WEEK_IN_MILLISECONDS = 1000 * 60 * 60 * 24 * 7;\n\nexports.handler = async (event: any, context: any) => {\n    console.log('Starting cleanup of static assets older than 1 week...');\n\n    try {\n        const client = new S3Client({region: process.env.AWS_REGION});\n        const bucketName = process.env.STATIC_ASSETS_BUCKET;\n\n        if (!bucketName) {\n            throw new Error(\"Static asset's bucket name not specified in environment!\");\n        }\n\n        const deleteOlderThan = new Date(Date.now() - ONE_WEEK_IN_MILLISECONDS);\n\n        // As we don't have hundreds of deployments per week, there's no need for pagination\n        const deploymentFolders = await client.send(\n            new ListObjectsV2Command({\n                Bucket: bucketName,\n                Delimiter: '/', // Only retrieve the top level folders\n            })\n        );\n\n        // The result is a list of objects containing the keys with a trailing slash\n        const folderNames = deploymentFolders.CommonPrefixes?.map(folder => folder.Prefix?.slice(0, -1))\n        if (!folderNames) {\n            console.log('Canceled static assets cleanup as folder is empty.');\n            return;\n        }\n\n        // We sort the folders by their creation data and remove the latest one as this is the currently active one used in production\n        const legacyFolderNames = folderNames.sort((a,b) => {\n            // @ts-ignore\n            const creationDateA = new Date(a);\n            // @ts-ignore\n            const creationDateB = new Date(b);\n\n            return creationDateA.getTime() < creationDateB.getTime() ? -1 : 1;\n        })\n        const activeFolderName = legacyFolderNames.pop();\n        console.log(`Detected assets folder \"${activeFolderName}\" as current production folder...`);\n\n        // We want to get all outdated folders of our legacy (not productively used) folders for deletion\n        const outdatedFolderNames = legacyFolderNames.filter(folderName => {\n                // @ts-ignore\n                const creationDate = new Date(folderName);\n                return creationDate.getTime() < deleteOlderThan.getTime();\n            }\n        );\n\n        if (!outdatedFolderNames || outdatedFolderNames.length === 0) {\n            console.log('No outdated asset folders found.');\n        } else {\n            console.log(`Deleting ${outdatedFolderNames.length} outdated folders...`);\n\n            // Unfortunately it's not possible to delete folders recursively 🙄\n            // so we need to query all the contents in order to delete them\n            const pendingPromises = outdatedFolderNames.map(folderName => {\n                return client\n                    .send(\n                        new ListObjectsV2Command({\n                            Bucket: bucketName,\n                            Prefix: folderName,\n                        })\n                    )\n                    .then(outdatedAssets => {\n                        return client.send(\n                            new DeleteObjectsCommand({\n                                Bucket: bucketName,\n                                Delete: {\n                                    Objects: outdatedAssets.Contents?.map(outdatedAsset => {\n                                        return {Key: outdatedAsset.Key};\n                                    }),\n                                },\n                            })\n                        );\n                    });\n            });\n\n            const results = await Promise.all(pendingPromises);\n            results.forEach(result => {\n                if (result.Errors && result.Errors.length) {\n                    const errorMsg = 'Failed to delete outdated static assets.';\n                    console.error(errorMsg, result.Errors);\n                    throw new Error(errorMsg);\n                }\n            });\n        }\n\n        console.log('Cleanup of old static assets finished.');\n    } catch (error) {\n        console.error('### unexpected runtime error ###', error);\n    }\n};"]}

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

@@ -0,0 +1,38 @@
+import { StackProps } from "aws-cdk-lib";
+/**
+ * Defines the common props required to deploy Nuxt apps on AWS.
+ */
+export interface NuxtAppStackProps extends StackProps {
+    /**
+     * A string identifier for the project the Nuxt app is part of.
+     * A project might have multiple different services.
+     */
+    readonly project: string;
+    /**
+     * 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.
+     */
+    readonly service: string;
+    /**
+     * A string to identify the environment of the Nuxt app. This enables us
+     * to deploy multiple different environments of the same Nuxt app, e.g., production and development.
+     */
+    readonly environment: string;
+    /**
+     * 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;
+    /**
+     * 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 on CloudFront 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 specified via 'env.region' as CloudFront only works globally.
+     */
+    readonly globalTlsCertificateArn: string;
+}

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

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,5 +1,4 @@
 import {StackProps} from "aws-cdk-lib";
-import {NuxtConfig} from "./nuxt-config";
 
 /**
  * Defines the common props required to deploy Nuxt apps on AWS.

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

@@ -0,0 +1,32 @@
+import { CacheControl } from "aws-cdk-lib/aws-s3-deployment";
+export interface StaticAssetConfig {
+    /**
+     * The file pattern for the incoming requests that should be forwarded to the target path in the static assets S3 bucket
+     * with the appropriate cache and content settings defined in the same object.
+     */
+    pattern: string;
+    /**
+     * The local directory to upload the files from.
+     */
+    source: string;
+    /**
+     * The remote path at which to make the uploaded files from source accessible.
+     */
+    target: string;
+    /**
+     * The content type to set for the files in the source folder when uploading them to the target.
+     */
+    contentType: string;
+    /**
+     * The cache settings to use for the uploaded source files when accessing them on the target path with the specified pattern.
+     */
+    cacheControl?: CacheControl[];
+    /**
+     * Whether to invalidate the files matching the config's pattern in the distribution's edge caches after the files are uploaded to the destination bucket.
+     */
+    invalidateOnChange?: boolean;
+}
+/**
+ * Retrieves the static assets of the Nuxt app that shall be publicly available.
+ */
+export declare const getNuxtAppStaticAssetConfigs: () => StaticAssetConfig[];

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

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNuxtAppStaticAssetConfigs = void 0;
+const aws_s3_deployment_1 = require("aws-cdk-lib/aws-s3-deployment");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+/**
+ * Retrieves the custom static assets of the Nuxt app that shall be publicly available.
+ */
+const getNuxtAppCustomAssetConfigs = () => {
+    // The custom assets of server Nuxt apps are located in the src 'static' folder
+    // The custom assets of static Nuxt apps are located in the build files 'dist' folder
+    const customAssetsSourcePath = `./.output/public`;
+    const customAssetsTargetPath = '/';
+    return [
+        {
+            pattern: '*.txt',
+            source: customAssetsSourcePath,
+            target: customAssetsTargetPath,
+            contentType: 'text/plain; charset=UTF-8',
+            cacheControl: [aws_s3_deployment_1.CacheControl.setPublic(), aws_s3_deployment_1.CacheControl.maxAge(aws_cdk_lib_1.Duration.days(1))],
+        },
+        {
+            pattern: '*.xml',
+            source: customAssetsSourcePath,
+            target: customAssetsTargetPath,
+            contentType: 'text/xml; charset=UTF-8',
+            cacheControl: [aws_s3_deployment_1.CacheControl.setPublic(), aws_s3_deployment_1.CacheControl.maxAge(aws_cdk_lib_1.Duration.days(1))],
+        },
+        {
+            pattern: '.well-known/*',
+            source: customAssetsSourcePath,
+            target: customAssetsTargetPath,
+            contentType: 'application/json; charset=UTF-8',
+            cacheControl: [aws_s3_deployment_1.CacheControl.setPublic(), aws_s3_deployment_1.CacheControl.maxAge(aws_cdk_lib_1.Duration.days(1))],
+        },
+        {
+            pattern: '*.ico',
+            source: customAssetsSourcePath,
+            target: customAssetsTargetPath,
+            contentType: 'image/x-icon',
+        },
+        {
+            pattern: '*.png',
+            source: customAssetsSourcePath,
+            target: customAssetsTargetPath,
+            contentType: 'image/png',
+        },
+        {
+            pattern: '*.jpg',
+            source: customAssetsSourcePath,
+            target: customAssetsTargetPath,
+            contentType: 'image/jpg',
+        },
+        {
+            pattern: '*.svg',
+            source: customAssetsSourcePath,
+            target: customAssetsTargetPath,
+            contentType: 'image/svg+xml',
+        },
+        {
+            pattern: '*.js',
+            source: customAssetsSourcePath,
+            target: customAssetsTargetPath,
+            contentType: 'application/javascript; charset=UTF-8',
+            // The js files in the custom static directory are usually not versioned
+            // 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))],
+        }
+    ];
+};
+/**
+ * Retrieves the static assets of the Nuxt app that are generated by the build of the app.
+ */
+const getNuxtAppBuildAssetConfigs = () => {
+    // The build assets required for CSR that are generated by 'nuxt build'
+    const buildAssetsSourcePath = './.output/public/_nuxt';
+    const buildAssetsTargetPath = ('/_nuxt/'); // Must match 'build.publicPath' in nuxt.config.js
+    return [
+        // Build Assets
+        {
+            pattern: '*.js',
+            target: buildAssetsTargetPath,
+            source: buildAssetsSourcePath,
+            contentType: 'application/javascript; charset=UTF-8',
+        },
+        {
+            pattern: '*.js.map',
+            target: buildAssetsTargetPath,
+            source: buildAssetsSourcePath,
+            contentType: 'application/json; charset=UTF-8',
+        },
+        {
+            pattern: '*.css',
+            target: buildAssetsTargetPath,
+            source: buildAssetsSourcePath,
+            contentType: 'text/css; charset=UTF-8',
+        },
+        {
+            pattern: '*.html',
+            target: buildAssetsTargetPath,
+            source: buildAssetsSourcePath,
+            contentType: 'text/html; charset=UTF-8',
+            // We do not want to cache html files on the browser as we want to be able to publish new changes quickly
+            // However, we do cache the html files on CloudFront for a performance boost and invalidate the cache on every deployment
+            cacheControl: [aws_s3_deployment_1.CacheControl.setPublic(), aws_s3_deployment_1.CacheControl.sMaxAge(aws_cdk_lib_1.Duration.days(7))],
+            invalidateOnChange: true
+        },
+        // Manifest created by PWA module
+        {
+            pattern: 'manifest.*.json',
+            target: buildAssetsTargetPath,
+            source: buildAssetsSourcePath,
+            contentType: 'application/json; charset=UTF-8'
+        },
+        {
+            pattern: '*.png',
+            target: buildAssetsTargetPath,
+            source: buildAssetsSourcePath,
+            contentType: 'image/png',
+        },
+        {
+            pattern: '*.jpg',
+            target: buildAssetsTargetPath,
+            source: buildAssetsSourcePath,
+            contentType: 'image/jpg',
+        },
+        {
+            pattern: '*.svg',
+            target: buildAssetsTargetPath,
+            source: buildAssetsSourcePath,
+            contentType: 'image/svg+xml',
+        },
+        {
+            pattern: '*.eot',
+            target: buildAssetsTargetPath,
+            source: buildAssetsSourcePath,
+            contentType: 'application/vnd.ms-fontobject',
+        },
+        {
+            pattern: '*.ttf',
+            target: buildAssetsTargetPath,
+            source: buildAssetsSourcePath,
+            contentType: 'application/font-sfnt',
+        },
+        {
+            pattern: '*.woff',
+            target: buildAssetsTargetPath,
+            source: buildAssetsSourcePath,
+            contentType: 'font/woff',
+        },
+        {
+            pattern: '*.woff2',
+            target: buildAssetsTargetPath,
+            source: buildAssetsSourcePath,
+            contentType: 'font/woff2',
+        }
+    ];
+};
+/**
+ * Retrieves the static assets of the Nuxt app that shall be publicly available.
+ */
+const getNuxtAppStaticAssetConfigs = () => {
+    return [...getNuxtAppBuildAssetConfigs(), ...getNuxtAppCustomAssetConfigs()];
+};
+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":"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","sourcesContent":["import {CacheControl} from \"aws-cdk-lib/aws-s3-deployment\";\nimport {Duration} from \"aws-cdk-lib\";\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     * Whether to invalidate the files matching the config's pattern in the distribution's edge caches after the files are uploaded to the destination bucket.\n     */\n    invalidateOnChange?: boolean;\n}\n\n/**\n * Retrieves the custom static assets of the Nuxt app that shall be publicly available.\n */\nconst getNuxtAppCustomAssetConfigs = (): StaticAssetConfig[] => {\n\n    // The custom assets of server Nuxt apps are located in the src 'static' folder\n    // The custom assets of static Nuxt apps are located in the build files 'dist' folder\n    const customAssetsSourcePath = `./.output/public`;\n    const customAssetsTargetPath = '/';\n\n    return [\n        {\n            pattern: '*.txt', // E.g., robots.txt, ads.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: '*.xml', // E.g., sitemap.xml ...\n            source: customAssetsSourcePath,\n            target: customAssetsTargetPath,\n            contentType: 'text/xml; charset=UTF-8',\n            cacheControl: [CacheControl.setPublic(), CacheControl.maxAge(Duration.days(1))],\n        },\n        {\n            pattern: '.well-known/*', // Files for native app links\n            source: customAssetsSourcePath,\n            target: customAssetsTargetPath,\n            contentType: 'application/json; charset=UTF-8',\n            cacheControl: [CacheControl.setPublic(), CacheControl.maxAge(Duration.days(1))],\n        },\n        {\n            pattern: '*.ico', // Favicon\n            source: customAssetsSourcePath,\n            target: customAssetsTargetPath,\n            contentType: 'image/x-icon',\n        },\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: '*.svg',\n            source: customAssetsSourcePath,\n            target: customAssetsTargetPath,\n            contentType: 'image/svg+xml',\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 versioned\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};\n\n/**\n * Retrieves the static assets of the Nuxt app that are generated by the build of the app.\n */\nconst getNuxtAppBuildAssetConfigs = (): StaticAssetConfig[] => {\n\n    // The build assets required for CSR that are generated by 'nuxt build'\n    const buildAssetsSourcePath = './.output/public/_nuxt';\n    const buildAssetsTargetPath = ('/_nuxt/'); // Must match 'build.publicPath' in nuxt.config.js\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            pattern: '*.html',\n            target: buildAssetsTargetPath,\n            source: buildAssetsSourcePath,\n            contentType: 'text/html; charset=UTF-8',\n            // We do not want to cache html files on the browser as we want to be able to publish new changes quickly\n            // However, we do cache the html files on CloudFront for a performance boost and invalidate the cache on every deployment\n            cacheControl: [CacheControl.setPublic(), CacheControl.sMaxAge(Duration.days(7))],\n            invalidateOnChange: true\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            target: buildAssetsTargetPath,\n            source: buildAssetsSourcePath,\n            contentType: 'image/png',\n        },\n        {\n            pattern: '*.jpg',\n            target: buildAssetsTargetPath,\n            source: buildAssetsSourcePath,\n            contentType: 'image/jpg',\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};\n\n/**\n * Retrieves the static assets of the Nuxt app that shall be publicly available.\n */\nexport const getNuxtAppStaticAssetConfigs = (): StaticAssetConfig[] => {\n    return [...getNuxtAppBuildAssetConfigs(), ...getNuxtAppCustomAssetConfigs()];\n};"]}

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

@@ -0,0 +1,201 @@
+import { Stack } from 'aws-cdk-lib';
+import { Construct } from 'constructs';
+import { IBucket } from "aws-cdk-lib/aws-s3";
+import { NuxtAppStackProps } from "../nuxt-app-stack-props";
+/**
+ * Defines the props required for the {@see NuxtServerAppStack}.
+ */
+export interface NuxtServerAppStackProps extends NuxtAppStackProps {
+    /**
+     * The ARN of the certificate to use at the ApiGateway for the Nuxt app to make it accessible via the custom domain
+     * and to provide the custom domain to the Nuxt app via the 'Host' header for server side rendering use cases.
+     * The certificate must be issued in the same region as specified via 'env.region' as ApiGateway works regionally.
+     */
+    readonly regionalTlsCertificateArn: string;
+    /**
+     * The memory size to apply to the Nuxt app's Lambda.
+     * Defaults to 1792MB (optimized for costs and performance for standard Nuxt apps).
+     */
+    readonly memorySize?: number;
+    /**
+     * Whether to enable AWS X-Ray for the Nuxt Lambda function.
+     */
+    readonly enableTracing?: boolean;
+    /**
+     * Whether to enable a global Sitemap bucket which is permanently accessible through multiple deployments.
+     */
+    readonly enableSitemap?: boolean;
+}
+/**
+ * CDK stack to deploy a dynamic Nuxt app (target=server) on AWS with Lambda, ApiGateway, S3 and CloudFront.
+ */
+export declare class NuxtServerAppStack 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 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;
+    /**
+     * The S3 bucket where the sitemap assets gets stored.
+     */
+    sitemapBucket: IBucket | undefined;
+    /**
+     * The Lambda function to render the Nuxt app on the server side.
+     *
+     * @private
+     */
+    private readonly appLambdaFunction;
+    /**
+     * The Lambda function that cleanups the outdated static assets of the Nuxt app.
+     *
+     * @private
+     */
+    private readonly cleanupLambdaFunction;
+    /**
+     * The API gateway to make the Lambda function to render the Nuxt app publicly available.
+     *
+     * @private
+     */
+    private apiGateway;
+    /**
+     * 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;
+    constructor(scope: Construct, id: string, props: NuxtServerAppStackProps);
+    /**
+     * Creates the identity to access the 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 the bucket to store the sitemap assets of the Nuxt app.
+     *
+     * @private
+     */
+    private createSitemapBucket;
+    /**
+     * Creates the Lambda function to render the Nuxt app.
+     *
+     * @private
+     */
+    private createAppLambdaFunction;
+    /**
+     * Creates the Lambda function that cleanups the outdated static assets of the Nuxt app.
+     *
+     * @param props
+     * @private
+     */
+    private createCleanupLambdaFunction;
+    /**
+     * Creates the API gateway to make the Nuxt app render Lambda function publicly available.
+     *
+     * @private
+     */
+    private createApiGateway;
+    /**
+     * 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;
+    private setupCloudFrontRouting;
+    /**
+     * Creates a cache policy for the Nuxt app route behavior of the CloudFront distribution.
+     * Even though 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;
+    /**
+     * Creates a behavior for the CloudFront distribution to route matching incoming requests for the static assets
+     * to the S3 bucket that holds these static assets.
+     *
+     * @private
+     */
+    private createStaticAssetsRouteBehavior;
+    /**
+     * Creates a behavior for the CloudFront distribution to route matching incoming requests for the sitemap assets
+     * to the S3 bucket that holds these sitemap assets.
+     *
+     * @private
+     */
+    private createSitemapRouteBehavior;
+    /**
+     * 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 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 the Nuxt app on the internet.
+     *
+     * @param props
+     * @private
+     */
+    private findHostedZone;
+    /**
+     * Creates the DNS records to access the Nuxt app on the internet via the custom domain.
+     *
+     * @param props
+     * @private
+     */
+    private createDnsRecords;
+    /**
+     * Creates a scheduled rule to ping the Nuxt app Lambda function every 5 minutes in order to keep it warm
+     * and speed up initial SSR requests.
+     *
+     * @private
+     */
+    private createAppPingRule;
+    /**
+     * Creates a scheduled rule that runs every tuesday at 03:30 AM GMT to trigger
+     * our cleanup Lambda function.
+     *
+     * @private
+     */
+    private createCleanupTriggerRule;
+}