cdk-nuxt 0.2.2 → 0.2.3

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: '/',
+        }));
+        // 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":"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","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/app-stack-props.d.ts

@@ -0,0 +1,6 @@
+import { StackProps } from "aws-cdk-lib";
+export interface AppStackProps extends StackProps {
+    readonly project: string;
+    readonly service: string;
+    readonly environment: string;
+}

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

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXBwLXN0YWNrLXByb3BzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiYXBwLXN0YWNrLXByb3BzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge1N0YWNrUHJvcHN9IGZyb20gXCJhd3MtY2RrLWxpYlwiO1xuXG5leHBvcnQgaW50ZXJmYWNlIEFwcFN0YWNrUHJvcHMgZXh0ZW5kcyBTdGFja1Byb3BzIHtcbiAgICByZWFkb25seSBwcm9qZWN0OiBzdHJpbmc7XG4gICAgcmVhZG9ubHkgc2VydmljZTogc3RyaW5nO1xuICAgIHJlYWRvbmx5IGVudmlyb25tZW50OiBzdHJpbmc7XG59Il19

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

@@ -0,0 +1,22 @@
+import { IBucket } from "aws-cdk-lib/aws-s3";
+import { Stack } from "aws-cdk-lib";
+import { AppStackProps } from "./app-stack-props";
+import { Construct } from "constructs";
+export interface NuxtAppAssetsCleanupProps extends AppStackProps {
+    readonly staticAssetsBucket: IBucket;
+    readonly sentryDsn: string;
+}
+/**
+ * Contains a scheduled lambda function, that deletes outdated static assets of the PWA from S3.
+ */
+export declare class NuxtAppAssetsCleanupStack extends Stack {
+    private readonly resourceIdPrefix;
+    private staticAssetsBucket;
+    private readonly layer;
+    private readonly lambdaFunction;
+    private scheduledRule;
+    constructor(scope: Construct, id: string, props: NuxtAppAssetsCleanupProps);
+    private createLayer;
+    private createLambdaFunction;
+    private createRule;
+}

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

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NuxtAppAssetsCleanupStack = void 0;
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const aws_lambda_1 = require("aws-cdk-lib/aws-lambda");
+const aws_events_1 = require("aws-cdk-lib/aws-events");
+const aws_logs_1 = require("aws-cdk-lib/aws-logs");
+const aws_events_targets_1 = require("aws-cdk-lib/aws-events-targets");
+const path = require("path");
+/**
+ * Contains a scheduled lambda function, that deletes outdated static assets of the PWA from S3.
+ */
+class NuxtAppAssetsCleanupStack extends aws_cdk_lib_1.Stack {
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        this.resourceIdPrefix = `${props.project}-${props.service}-${props.environment}`;
+        this.staticAssetsBucket = props.staticAssetsBucket;
+        this.layer = this.createLayer();
+        this.lambdaFunction = this.createLambdaFunction(props);
+        this.scheduledRule = this.createRule(props);
+    }
+    createLayer() {
+        const layerName = `${this.resourceIdPrefix}-layer`;
+        return new aws_lambda_1.LayerVersion(this, layerName, {
+            layerVersionName: layerName,
+            code: aws_lambda_1.Code.fromAsset(path.join(__dirname, '../functions/assets_cleanup/build/layer')),
+            compatibleRuntimes: [aws_lambda_1.Runtime.NODEJS_14_X],
+        });
+    }
+    createLambdaFunction(props) {
+        const functionName = `${this.resourceIdPrefix}-function`;
+        const result = new aws_lambda_1.Function(this, functionName, {
+            functionName: functionName,
+            runtime: aws_lambda_1.Runtime.NODEJS_14_X,
+            architecture: aws_lambda_1.Architecture.ARM_64,
+            layers: [this.layer],
+            handler: `index.handler`,
+            code: aws_lambda_1.Code.fromAsset(path.join(__dirname, '../functions/assets_cleanup/build/app')),
+            timeout: aws_cdk_lib_1.Duration.minutes(1),
+            memorySize: 128,
+            logRetention: aws_logs_1.RetentionDays.TWO_WEEKS,
+            environment: {
+                STATIC_ASSETS_BUCKET: this.staticAssetsBucket.bucketName,
+                SENTRY_DSN: props.sentryDsn,
+                ENVIRONMENT: props.environment,
+                AWS_NODEJS_CONNECTION_REUSE_ENABLED: '1',
+                NODE_OPTIONS: '--enable-source-maps',
+            },
+        });
+        // grant function access to S3 bucket
+        this.staticAssetsBucket.grantRead(result);
+        this.staticAssetsBucket.grantDelete(result);
+        return result;
+    }
+    createRule(props) {
+        const ruleName = `${this.resourceIdPrefix}-scheduled-rule`;
+        // Schedule every tuesday at 03:30 AM GMT
+        return new aws_events_1.Rule(this, ruleName, {
+            ruleName,
+            description: `Triggers a cleanup of outdated static assets of the ${props.project} app.`,
+            enabled: true,
+            schedule: aws_events_1.Schedule.cron({ weekDay: '3', hour: '3', minute: '30' }),
+            targets: [new aws_events_targets_1.LambdaFunction(this.lambdaFunction)],
+        });
+    }
+}
+exports.NuxtAppAssetsCleanupStack = NuxtAppAssetsCleanupStack;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,46 @@
+import { Stack } from 'aws-cdk-lib';
+import { Construct } from 'constructs';
+import { IBucket } from "aws-cdk-lib/aws-s3";
+import { AppStackProps } from "./app-stack-props";
+export interface NuxtAppStackProps extends AppStackProps {
+    readonly baseDomain: string;
+    readonly subDomain?: string;
+    readonly globalTlsCertificateArn: string;
+    readonly hostedZoneId: string;
+}
+export declare class NuxtAppStack extends Stack {
+    private readonly resourceIdPrefix;
+    private readonly deploymentRevision;
+    private readonly tlsCertificate;
+    private readonly cdnAccessIdentity;
+    staticAssetsBucket: IBucket;
+    private readonly layer;
+    private readonly lambdaFunction;
+    private apiGateway;
+    private readonly httpsForwardingBehavior;
+    private readonly cdn;
+    private readonly hostedZone;
+    constructor(scope: Construct, id: string, props: NuxtAppStackProps);
+    private findTlsCertificate;
+    private createCdnAccessIdentity;
+    private createStaticAssetsBucket;
+    private createSsrLambdaLayer;
+    private createLambdaFunction;
+    private createApiGateway;
+    private createHttpsForwardingBehavior;
+    /**
+     * Eventhough we don't want to cache SSR requests, we still have to create a cache policy, in order to
+     * forward required cookies, query params and headers. This doesn't make any sense, because if nothing
+     * is cached, one would expect, that anything would/could be forwarded, but anyway...
+     */
+    private createSsrCachePolicy;
+    private createCloudFrontDistribution;
+    private createStaticAssetBehaviors;
+    /**
+     * 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.
+     */
+    private configureDeployments;
+    private findHostedZone;
+    private createDnsRecords;
+}

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

@@ -0,0 +1,223 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NuxtAppStack = void 0;
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const aws_certificatemanager_1 = require("aws-cdk-lib/aws-certificatemanager");
+const aws_cloudfront_1 = require("aws-cdk-lib/aws-cloudfront");
+const aws_lambda_1 = require("aws-cdk-lib/aws-lambda");
+const aws_s3_1 = require("aws-cdk-lib/aws-s3");
+const aws_route53_1 = require("aws-cdk-lib/aws-route53");
+const aws_s3_deployment_1 = require("aws-cdk-lib/aws-s3-deployment");
+const aws_cloudfront_origins_1 = require("aws-cdk-lib/aws-cloudfront-origins");
+const aws_route53_targets_1 = require("aws-cdk-lib/aws-route53-targets");
+const aws_stepfunctions_tasks_1 = require("aws-cdk-lib/aws-stepfunctions-tasks");
+const aws_logs_1 = require("aws-cdk-lib/aws-logs");
+const aws_apigatewayv2_integrations_alpha_1 = require("@aws-cdk/aws-apigatewayv2-integrations-alpha");
+const aws_apigatewayv2_alpha_1 = require("@aws-cdk/aws-apigatewayv2-alpha");
+const nuxt_app_static_assets_1 = require("./nuxt-app-static-assets");
+const fs = require("fs");
+class NuxtAppStack extends aws_cdk_lib_1.Stack {
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        aws_cdk_lib_1.Tags.of(scope).add('project', props.project);
+        aws_cdk_lib_1.Tags.of(scope).add('domain', props.subDomain ? `${props.subDomain}.${props.baseDomain}` : props.baseDomain);
+        aws_cdk_lib_1.Tags.of(scope).add('service', props.service);
+        aws_cdk_lib_1.Tags.of(scope).add('environment', props.environment);
+        this.resourceIdPrefix = `${props.project}-${props.service}-${props.environment}`;
+        this.deploymentRevision = new Date().toISOString();
+        this.tlsCertificate = this.findTlsCertificate(props);
+        this.cdnAccessIdentity = this.createCdnAccessIdentity();
+        this.staticAssetsBucket = this.createStaticAssetsBucket();
+        this.layer = this.createSsrLambdaLayer();
+        this.lambdaFunction = this.createLambdaFunction();
+        this.apiGateway = this.createApiGateway();
+        this.httpsForwardingBehavior = this.createHttpsForwardingBehavior();
+        this.cdn = this.createCloudFrontDistribution(props);
+        this.configureDeployments();
+        this.hostedZone = this.findHostedZone(props);
+        this.createDnsRecords(props);
+    }
+    findTlsCertificate(props) {
+        return aws_certificatemanager_1.Certificate.fromCertificateArn(this, `${this.resourceIdPrefix}-tls-certificate`, props.globalTlsCertificateArn);
+    }
+    createCdnAccessIdentity() {
+        const originAccessIdentityName = `${this.resourceIdPrefix}-cdn-s3-access`;
+        return new aws_cloudfront_1.OriginAccessIdentity(this, originAccessIdentityName);
+    }
+    createStaticAssetsBucket() {
+        const bucketName = `${this.resourceIdPrefix}-assets`;
+        const bucket = new aws_s3_1.Bucket(this, bucketName, {
+            accessControl: aws_s3_1.BucketAccessControl.AUTHENTICATED_READ,
+            blockPublicAccess: aws_s3_1.BlockPublicAccess.BLOCK_ALL,
+            bucketName,
+            // the bucket and all of its objects can be deleted, because all the content is managed in this project
+            removalPolicy: aws_cdk_lib_1.RemovalPolicy.DESTROY,
+            autoDeleteObjects: true,
+        });
+        bucket.grantReadWrite(this.cdnAccessIdentity);
+        return bucket;
+    }
+    createSsrLambdaLayer() {
+        const layerName = `${this.resourceIdPrefix}-ssr-layer`;
+        return new aws_lambda_1.LayerVersion(this, layerName, {
+            layerVersionName: layerName,
+            code: aws_lambda_1.Code.fromAsset('./server/layer'),
+            compatibleRuntimes: [aws_lambda_1.Runtime.NODEJS_12_X],
+            description: `Contains node_modules required for server-side of ${this.resourceIdPrefix}.`,
+        });
+    }
+    createLambdaFunction() {
+        const funcName = `${this.resourceIdPrefix}-function`;
+        return new aws_lambda_1.Function(this, funcName, {
+            functionName: funcName,
+            runtime: aws_lambda_1.Runtime.NODEJS_12_X,
+            architecture: aws_lambda_1.Architecture.ARM_64,
+            layers: [this.layer],
+            handler: 'lambda-handler.render',
+            code: aws_lambda_1.Code.fromAsset('.nuxt/cdk-deployment', {
+                exclude: ['**.svg', '**.ico', '**.png', '**.jpg', 'chunk.*.js*', 'bundle.*.js*', 'bundle.*.js*', 'sw.js*'],
+            }),
+            timeout: aws_cdk_lib_1.Duration.seconds(10),
+            memorySize: 512,
+            logRetention: aws_logs_1.RetentionDays.ONE_MONTH,
+            environment: {},
+            allowPublicSubnet: false
+        });
+    }
+    createApiGateway() {
+        const lambdaIntegration = new aws_apigatewayv2_integrations_alpha_1.HttpLambdaIntegration(`${this.resourceIdPrefix}-lambda-integration`, this.lambdaFunction);
+        const apiName = `${this.resourceIdPrefix}-api`;
+        const apiGateway = new aws_apigatewayv2_alpha_1.HttpApi(this, apiName, {
+            apiName,
+            // The app does not allow any cross-origin access by purpose: the app should not be embeddable anywhere
+            corsPreflight: undefined,
+            defaultIntegration: lambdaIntegration,
+        });
+        apiGateway.addRoutes({
+            integration: lambdaIntegration,
+            path: '/{proxy+}',
+            methods: [aws_stepfunctions_tasks_1.HttpMethod.GET, aws_stepfunctions_tasks_1.HttpMethod.HEAD],
+        });
+        return apiGateway;
+    }
+    createHttpsForwardingBehavior() {
+        return {
+            origin: new aws_cloudfront_origins_1.HttpOrigin(`${this.apiGateway.httpApiId}.execute-api.${this.region}.amazonaws.com`, {
+                connectionAttempts: 2,
+                connectionTimeout: aws_cdk_lib_1.Duration.seconds(2),
+                readTimeout: aws_cdk_lib_1.Duration.seconds(10),
+                protocolPolicy: aws_cloudfront_1.OriginProtocolPolicy.HTTPS_ONLY,
+            }),
+            allowedMethods: aws_cloudfront_1.AllowedMethods.ALLOW_GET_HEAD,
+            compress: true,
+            viewerProtocolPolicy: aws_cloudfront_1.ViewerProtocolPolicy.REDIRECT_TO_HTTPS,
+            originRequestPolicy: undefined,
+            cachePolicy: this.createSsrCachePolicy(),
+        };
+    }
+    /**
+     * Eventhough we don't want to cache SSR requests, we still have to create a cache policy, in order to
+     * forward required cookies, query params and headers. This doesn't make any sense, because if nothing
+     * is cached, one would expect, that anything would/could be forwarded, but anyway...
+     */
+    createSsrCachePolicy() {
+        // The headers to pass to the app
+        const headers = [
+            'User-Agent',
+            'Authorization',
+        ];
+        return new aws_cloudfront_1.CachePolicy(this, `${this.resourceIdPrefix}-cache-policy`, {
+            cachePolicyName: `${this.resourceIdPrefix}-cdn-cache-policy`,
+            comment: `Passes all required request data to the ${this.resourceIdPrefix} origin.`,
+            defaultTtl: aws_cdk_lib_1.Duration.seconds(0),
+            minTtl: aws_cdk_lib_1.Duration.seconds(0),
+            maxTtl: aws_cdk_lib_1.Duration.seconds(1),
+            queryStringBehavior: aws_cloudfront_1.CacheQueryStringBehavior.all(),
+            headerBehavior: aws_cloudfront_1.CacheHeaderBehavior.allowList(...headers),
+            cookieBehavior: aws_cloudfront_1.CacheCookieBehavior.all(),
+            enableAcceptEncodingBrotli: true,
+            enableAcceptEncodingGzip: true,
+        });
+    }
+    createCloudFrontDistribution(props) {
+        const cdnName = `${this.resourceIdPrefix}-cdn`;
+        return new aws_cloudfront_1.Distribution(this, cdnName, {
+            domainNames: props.subDomain ? [`${props.subDomain}.${props.baseDomain}`] : [props.baseDomain, `*.${props.baseDomain}`],
+            comment: `${this.resourceIdPrefix}-redirect`,
+            minimumProtocolVersion: aws_cloudfront_1.SecurityPolicyProtocol.TLS_V1_2_2018,
+            certificate: this.tlsCertificate,
+            defaultBehavior: this.httpsForwardingBehavior,
+            additionalBehaviors: this.createStaticAssetBehaviors(),
+            priceClass: aws_cloudfront_1.PriceClass.PRICE_CLASS_100,
+        });
+    }
+    createStaticAssetBehaviors() {
+        const staticAssetsCacheConfig = {
+            origin: new aws_cloudfront_origins_1.S3Origin(this.staticAssetsBucket, {
+                connectionAttempts: 2,
+                connectionTimeout: aws_cdk_lib_1.Duration.seconds(3),
+                originAccessIdentity: this.cdnAccessIdentity,
+                originPath: this.deploymentRevision,
+            }),
+            compress: true,
+            allowedMethods: aws_cloudfront_1.AllowedMethods.ALLOW_GET_HEAD_OPTIONS,
+            cachedMethods: aws_cloudfront_1.CachedMethods.CACHE_GET_HEAD_OPTIONS,
+            cachePolicy: aws_cloudfront_1.CachePolicy.CACHING_OPTIMIZED,
+            viewerProtocolPolicy: aws_cloudfront_1.ViewerProtocolPolicy.REDIRECT_TO_HTTPS,
+        };
+        const rules = {};
+        nuxt_app_static_assets_1.NuxtAppStaticAssets.forEach(asset => {
+            rules[`${asset.target}${asset.pattern}`] = staticAssetsCacheConfig;
+        });
+        return rules;
+    }
+    /**
+     * 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.
+     */
+    configureDeployments() {
+        const defaultCacheConfig = [
+            aws_s3_deployment_1.CacheControl.setPublic(),
+            aws_s3_deployment_1.CacheControl.maxAge(aws_cdk_lib_1.Duration.days(365)),
+            aws_s3_deployment_1.CacheControl.fromString('immutable'),
+        ];
+        // Returns a deployment for every configured static asset type to respect the different cache settings
+        return nuxt_app_static_assets_1.NuxtAppStaticAssets.filter(asset => fs.existsSync(asset.source)).map((asset, assetIndex) => {
+            var _a;
+            return new aws_s3_deployment_1.BucketDeployment(this, `${this.resourceIdPrefix}-assets-deployment-${assetIndex}`, {
+                sources: [aws_s3_deployment_1.Source.asset(asset.source)],
+                destinationBucket: this.staticAssetsBucket,
+                destinationKeyPrefix: this.deploymentRevision + asset.target,
+                prune: false,
+                storageClass: aws_s3_deployment_1.StorageClass.STANDARD,
+                exclude: ['*'],
+                include: [asset.pattern],
+                cacheControl: (_a = asset.cacheControl) !== null && _a !== void 0 ? _a : defaultCacheConfig,
+                contentType: asset.contentType,
+            });
+        });
+    }
+    findHostedZone(props) {
+        return aws_route53_1.HostedZone.fromHostedZoneAttributes(this, `${this.resourceIdPrefix}-hosted-zone`, {
+            hostedZoneId: props.hostedZoneId,
+            zoneName: props.baseDomain,
+        });
+    }
+    createDnsRecords(props) {
+        const dnsTarget = aws_route53_1.RecordTarget.fromAlias(new aws_route53_targets_1.CloudFrontTarget(this.cdn));
+        // Create a record for IPv4
+        new aws_route53_1.ARecord(this, `${this.resourceIdPrefix}-ipv4-record`, {
+            recordName: props.subDomain ? `${props.subDomain}.${props.baseDomain}` : props.baseDomain,
+            zone: this.hostedZone,
+            target: dnsTarget,
+        });
+        // Create a record for IPv6
+        new aws_route53_1.AaaaRecord(this, `${this.resourceIdPrefix}-ipv6-record`, {
+            recordName: props.subDomain ? `${props.subDomain}.${props.baseDomain}` : props.baseDomain,
+            zone: this.hostedZone,
+            target: dnsTarget,
+        });
+    }
+}
+exports.NuxtAppStack = NuxtAppStack;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nuxt-app-stack.js","sourceRoot":"","sources":["nuxt-app-stack.ts"],"names":[],"mappings":"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","sourcesContent":["import {Duration, RemovalPolicy, Stack, Tags} from 'aws-cdk-lib';\nimport { Construct } from 'constructs';\nimport {Certificate, ICertificate} from \"aws-cdk-lib/aws-certificatemanager\";\nimport {\n  AllowedMethods,\n  BehaviorOptions, CacheCookieBehavior,\n  CachedMethods, CacheHeaderBehavior,\n  CachePolicy, CacheQueryStringBehavior,\n  Distribution, ICachePolicy,\n  IOriginAccessIdentity, OriginAccessIdentity, OriginProtocolPolicy, PriceClass,\n  SecurityPolicyProtocol,\n  ViewerProtocolPolicy\n} from \"aws-cdk-lib/aws-cloudfront\";\nimport {Architecture, Code, LayerVersion, Runtime, Function} from \"aws-cdk-lib/aws-lambda\";\nimport {BlockPublicAccess, Bucket, BucketAccessControl, IBucket} from \"aws-cdk-lib/aws-s3\";\nimport {ARecord, AaaaRecord, HostedZone, IHostedZone, RecordTarget} from \"aws-cdk-lib/aws-route53\";\nimport {BucketDeployment, CacheControl, Source, StorageClass} from \"aws-cdk-lib/aws-s3-deployment\";\nimport {HttpOrigin, S3Origin} from \"aws-cdk-lib/aws-cloudfront-origins\";\nimport {CloudFrontTarget} from \"aws-cdk-lib/aws-route53-targets\";\nimport {HttpMethod} from \"aws-cdk-lib/aws-stepfunctions-tasks\";\nimport {RetentionDays} from \"aws-cdk-lib/aws-logs\";\nimport { HttpLambdaIntegration } from '@aws-cdk/aws-apigatewayv2-integrations-alpha';\nimport {HttpApi} from \"@aws-cdk/aws-apigatewayv2-alpha\";\nimport {NuxtAppStaticAssets} from \"./nuxt-app-static-assets\";\nimport {AppStackProps} from \"./app-stack-props\";\nimport * as fs from \"fs\";\n\nexport interface NuxtAppStackProps extends AppStackProps {\n  readonly baseDomain: string;\n  readonly subDomain?: string;\n\n  // Used by the CDN, must be issued in us-east-1 (global)\n  readonly globalTlsCertificateArn: string;\n\n  readonly hostedZoneId: string;\n}\n\nexport class NuxtAppStack extends Stack {\n  private readonly resourceIdPrefix: string;\n  private readonly deploymentRevision: string;\n  private readonly tlsCertificate: ICertificate;\n  private readonly cdnAccessIdentity: IOriginAccessIdentity;\n  public staticAssetsBucket: IBucket;\n  private readonly layer: LayerVersion;\n  private readonly lambdaFunction: Function;\n  private apiGateway: HttpApi;\n  private readonly httpsForwardingBehavior: BehaviorOptions;\n  private readonly cdn: Distribution;\n  private readonly hostedZone: IHostedZone;\n\n  constructor(scope: Construct, id: string, props: NuxtAppStackProps) {\n    super(scope, id, props);\n\n    Tags.of(scope).add('project', props.project);\n    Tags.of(scope).add('domain', props.subDomain ? `${props.subDomain}.${props.baseDomain}` : props.baseDomain);\n    Tags.of(scope).add('service', props.service);\n    Tags.of(scope).add('environment', props.environment);\n\n    this.resourceIdPrefix = `${props.project}-${props.service}-${props.environment}`;\n    this.deploymentRevision = new Date().toISOString();\n    this.tlsCertificate = this.findTlsCertificate(props);\n    this.cdnAccessIdentity = this.createCdnAccessIdentity();\n    this.staticAssetsBucket = this.createStaticAssetsBucket();\n    this.layer = this.createSsrLambdaLayer();\n    this.lambdaFunction = this.createLambdaFunction();\n    this.apiGateway = this.createApiGateway();\n    this.httpsForwardingBehavior = this.createHttpsForwardingBehavior();\n    this.cdn = this.createCloudFrontDistribution(props);\n    this.configureDeployments();\n    this.hostedZone = this.findHostedZone(props);\n    this.createDnsRecords(props);\n  }\n\n  private findTlsCertificate(props: NuxtAppStackProps): ICertificate {\n    return Certificate.fromCertificateArn(this, `${this.resourceIdPrefix}-tls-certificate`, props.globalTlsCertificateArn);\n  }\n\n  private createCdnAccessIdentity(): IOriginAccessIdentity {\n    const originAccessIdentityName = `${this.resourceIdPrefix}-cdn-s3-access`;\n    return new OriginAccessIdentity(this, originAccessIdentityName);\n  }\n\n  private createStaticAssetsBucket(): IBucket {\n    const bucketName = `${this.resourceIdPrefix}-assets`;\n    const bucket = new Bucket(this, bucketName, {\n      accessControl: BucketAccessControl.AUTHENTICATED_READ,\n      blockPublicAccess: BlockPublicAccess.BLOCK_ALL,\n      bucketName,\n      // the bucket and all of its objects can be deleted, because all the content is managed in this project\n      removalPolicy: RemovalPolicy.DESTROY,\n      autoDeleteObjects: true,\n    });\n\n    bucket.grantReadWrite(this.cdnAccessIdentity);\n\n    return bucket;\n  }\n\n  private createSsrLambdaLayer(): LayerVersion {\n    const layerName = `${this.resourceIdPrefix}-ssr-layer`;\n    return new LayerVersion(this, layerName, {\n      layerVersionName: layerName,\n      code: Code.fromAsset('./server/layer'),\n      compatibleRuntimes: [Runtime.NODEJS_12_X],\n      description: `Contains node_modules required for server-side of ${this.resourceIdPrefix}.`,\n    });\n  }\n\n  private createLambdaFunction(): Function {\n    const funcName = `${this.resourceIdPrefix}-function`;\n\n    return new Function(this, funcName, {\n      functionName: funcName,\n      runtime: Runtime.NODEJS_12_X,\n      architecture: Architecture.ARM_64,\n      layers: [this.layer],\n      handler: 'lambda-handler.render',\n      code: Code.fromAsset('.nuxt/cdk-deployment', {\n        exclude: ['**.svg', '**.ico', '**.png', '**.jpg', 'chunk.*.js*', 'bundle.*.js*', 'bundle.*.js*', 'sw.js*'],\n      }),\n      timeout: Duration.seconds(10),\n      memorySize: 512,\n      logRetention: RetentionDays.ONE_MONTH,\n      environment: {},\n      allowPublicSubnet: false\n    });\n  }\n\n  private createApiGateway(): HttpApi {\n    const lambdaIntegration = new HttpLambdaIntegration(`${this.resourceIdPrefix}-lambda-integration`, this.lambdaFunction);\n    const apiName = `${this.resourceIdPrefix}-api`;\n    const apiGateway = new HttpApi(this, apiName, {\n      apiName,\n      // The app does not allow any cross-origin access by purpose: the app should not be embeddable anywhere\n      corsPreflight: undefined,\n      defaultIntegration: lambdaIntegration,\n    });\n\n    apiGateway.addRoutes({\n      integration: lambdaIntegration,\n      path: '/{proxy+}',\n      methods: [HttpMethod.GET, HttpMethod.HEAD],\n    });\n    return apiGateway;\n  }\n\n  private createHttpsForwardingBehavior(): BehaviorOptions {\n    return {\n      origin: new HttpOrigin(`${this.apiGateway.httpApiId}.execute-api.${this.region}.amazonaws.com`, {\n        connectionAttempts: 2,\n        connectionTimeout: Duration.seconds(2),\n        readTimeout: Duration.seconds(10),\n        protocolPolicy: OriginProtocolPolicy.HTTPS_ONLY,\n      }),\n      allowedMethods: AllowedMethods.ALLOW_GET_HEAD,\n      compress: true,\n      viewerProtocolPolicy: ViewerProtocolPolicy.REDIRECT_TO_HTTPS,\n      originRequestPolicy: undefined,\n      cachePolicy: this.createSsrCachePolicy(),\n    };\n  }\n\n  /**\n   * Eventhough we don't want to cache SSR requests, we still have to create a cache policy, in order to\n   * forward required cookies, query params and headers. This doesn't make any sense, because if nothing\n   * is cached, one would expect, that anything would/could be forwarded, but anyway...\n   */\n  private createSsrCachePolicy(): ICachePolicy {\n\n    // The headers to pass to the app\n    const headers = [\n      'User-Agent', // Required to distinguish between mobile and desktop template\n      'Authorization', // For authorization\n    ];\n\n    return new CachePolicy(this, `${this.resourceIdPrefix}-cache-policy`, {\n      cachePolicyName: `${this.resourceIdPrefix}-cdn-cache-policy`,\n      comment: `Passes all required request data to the ${this.resourceIdPrefix} origin.`,\n      defaultTtl: Duration.seconds(0),\n      minTtl: Duration.seconds(0),\n      maxTtl: Duration.seconds(1), // the max TTL must not be 0 for a cache policy\n      queryStringBehavior: CacheQueryStringBehavior.all(),\n      headerBehavior: CacheHeaderBehavior.allowList(...headers),\n      cookieBehavior: CacheCookieBehavior.all(),\n      enableAcceptEncodingBrotli: true,\n      enableAcceptEncodingGzip: true,\n    });\n  }\n\n  private createCloudFrontDistribution(props: NuxtAppStackProps): Distribution {\n    const cdnName = `${this.resourceIdPrefix}-cdn`;\n\n    return new Distribution(this, cdnName, {\n      domainNames: props.subDomain ? [`${props.subDomain}.${props.baseDomain}`] : [props.baseDomain, `*.${props.baseDomain}`],\n      comment: `${this.resourceIdPrefix}-redirect`,\n      minimumProtocolVersion: SecurityPolicyProtocol.TLS_V1_2_2018,\n      certificate: this.tlsCertificate,\n      defaultBehavior: this.httpsForwardingBehavior,\n      additionalBehaviors: this.createStaticAssetBehaviors(),\n      priceClass: PriceClass.PRICE_CLASS_100, // Use only North America and Europe\n    });\n  }\n\n  private createStaticAssetBehaviors(): Record<string, BehaviorOptions> {\n    const staticAssetsCacheConfig: BehaviorOptions = {\n      origin: new S3Origin(this.staticAssetsBucket, {\n        connectionAttempts: 2,\n        connectionTimeout: Duration.seconds(3),\n        originAccessIdentity: this.cdnAccessIdentity,\n        originPath: this.deploymentRevision,\n      }),\n      compress: true,\n      allowedMethods: AllowedMethods.ALLOW_GET_HEAD_OPTIONS,\n      cachedMethods: CachedMethods.CACHE_GET_HEAD_OPTIONS,\n      cachePolicy: CachePolicy.CACHING_OPTIMIZED,\n      viewerProtocolPolicy: ViewerProtocolPolicy.REDIRECT_TO_HTTPS,\n    };\n\n    const rules: Record<string, BehaviorOptions> = {};\n    NuxtAppStaticAssets.forEach(asset => {\n      rules[`${asset.target}${asset.pattern}`] = staticAssetsCacheConfig\n    })\n\n    return rules\n  }\n\n  /**\n   * In order to enable a zero-downtime deployment, we use a new subdirectory (revision) for every deployment.\n   * The previous versions are retained to allow clients to continue to work with an older revision.\n   */\n  private configureDeployments(): BucketDeployment[] {\n    const defaultCacheConfig = [\n      CacheControl.setPublic(),\n      CacheControl.maxAge(Duration.days(365)),\n      CacheControl.fromString('immutable'),\n    ];\n\n    // Returns a deployment for every configured static asset type to respect the different cache settings\n    return NuxtAppStaticAssets.filter(asset => fs.existsSync(asset.source)).map((asset, assetIndex) => {\n      return new BucketDeployment(this, `${this.resourceIdPrefix}-assets-deployment-${assetIndex}`, {\n        sources: [Source.asset(asset.source)],\n        destinationBucket: this.staticAssetsBucket,\n        destinationKeyPrefix: this.deploymentRevision + asset.target,\n        prune: false,\n        storageClass: StorageClass.STANDARD,\n        exclude: ['*'],\n        include: [asset.pattern],\n        cacheControl: asset.cacheControl ?? defaultCacheConfig,\n        contentType: asset.contentType,\n      })\n    });\n  }\n\n  private findHostedZone(props: NuxtAppStackProps): IHostedZone {\n    return HostedZone.fromHostedZoneAttributes(this, `${this.resourceIdPrefix}-hosted-zone`, {\n      hostedZoneId: props.hostedZoneId,\n      zoneName: props.baseDomain,\n    });\n  }\n\n  private createDnsRecords(props: NuxtAppStackProps): void {\n    const dnsTarget = RecordTarget.fromAlias(new CloudFrontTarget(this.cdn));\n\n    // Create a record for IPv4\n    new ARecord(this, `${this.resourceIdPrefix}-ipv4-record`, {\n      recordName: props.subDomain ? `${props.subDomain}.${props.baseDomain}` : props.baseDomain,\n      zone: this.hostedZone,\n      target: dnsTarget,\n    });\n\n    // Create a record for IPv6\n    new AaaaRecord(this, `${this.resourceIdPrefix}-ipv6-record`, {\n      recordName: props.subDomain ? `${props.subDomain}.${props.baseDomain}` : props.baseDomain,\n      zone: this.hostedZone,\n      target: dnsTarget,\n    });\n  }\n}\n"]}

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

@@ -0,0 +1,10 @@
+import { CacheControl } from "aws-cdk-lib/aws-s3-deployment";
+interface StaticAssetConfig {
+    pattern: string;
+    contentType: string;
+    source: string;
+    target: string;
+    cacheControl?: CacheControl[];
+}
+export declare const NuxtAppStaticAssets: StaticAssetConfig[];
+export {};

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

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NuxtAppStaticAssets = void 0;
+const aws_s3_deployment_1 = require("aws-cdk-lib/aws-s3-deployment");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const buildAssetsSourcePath = './.nuxt/dist/client';
+const buildAssetsTargetPath = '/assets/'; // Must match 'build.publicPath' in nuxt.config.js
+const customAssetsSourcePath = './src/static';
+const customAssetsTargetPath = '/';
+// Defines the paths with their cache settings that shall be public available in our app
+// These should match the files in 'src/.nuxt/dist/client' and 'static'
+exports.NuxtAppStaticAssets = [
+    // 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: 'sw.js',
+        target: buildAssetsTargetPath,
+        source: buildAssetsSourcePath,
+        contentType: 'application/javascript; charset=UTF-8',
+        cacheControl: [aws_s3_deployment_1.CacheControl.setPublic(), aws_s3_deployment_1.CacheControl.maxAge(aws_cdk_lib_1.Duration.days(1))],
+    },
+    {
+        pattern: 'sw.js.map',
+        target: buildAssetsTargetPath,
+        source: buildAssetsSourcePath,
+        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: '*.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',
+    },
+    // Custom Static Assets
+    {
+        pattern: '*.png',
+        source: customAssetsSourcePath,
+        target: customAssetsTargetPath,
+        contentType: 'image/png',
+    },
+    {
+        pattern: '*.jpg',
+        source: customAssetsSourcePath,
+        target: customAssetsTargetPath,
+        contentType: 'image/jpg',
+    },
+    {
+        pattern: 'robots.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: 'manifest.json',
+        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(2))],
+    },
+];
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cdk-nuxt",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "license": "MIT",
   "files": [
     "lib"

package/dist/index.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var nuxt_app_stack_1 = require("./stack/nuxt-app-stack");
-Object.defineProperty(exports, "NuxtAppStack", { enumerable: true, get: function () { return nuxt_app_stack_1.NuxtAppStack; } });
-var nuxt_app_assets_cleanup_stack_1 = require("./stack/nuxt-app-assets-cleanup-stack");
-Object.defineProperty(exports, "NuxtAppAssetsCleanupStack", { enumerable: true, get: function () { return nuxt_app_assets_cleanup_stack_1.NuxtAppAssetsCleanupStack; } });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9saWIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFBQSx5REFBc0U7QUFBOUQsOEdBQUEsWUFBWSxPQUFBO0FBQ3BCLHVGQUEwRztBQUFsRywwSUFBQSx5QkFBeUIsT0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7TnV4dEFwcFN0YWNrLCBOdXh0QXBwU3RhY2tQcm9wc30gZnJvbSBcIi4vc3RhY2svbnV4dC1hcHAtc3RhY2tcIlxuZXhwb3J0IHtOdXh0QXBwQXNzZXRzQ2xlYW51cFN0YWNrLCBOdXh0QXBwQXNzZXRzQ2xlYW51cFByb3BzfSBmcm9tIFwiLi9zdGFjay9udXh0LWFwcC1hc3NldHMtY2xlYW51cC1zdGFja1wiIl19

package/lib/index.ts

@@ -1,2 +0,0 @@
-export {NuxtAppStack, NuxtAppStackProps} from "./stack/nuxt-app-stack"
-export {NuxtAppAssetsCleanupStack, NuxtAppAssetsCleanupProps} from "./stack/nuxt-app-assets-cleanup-stack"