cdk-nuxt 0.1.1 → 0.2.3

package/lib/cli/deploy.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+
+const shell = require("shelljs");
+const path = require("path");
+require('dotenv').config()
+
+const deploymentFolder = '.nuxt/cdk-deployment';
+
+shell.rm('-rf', deploymentFolder);
+shell.mkdir('-p', `${deploymentFolder}/.nuxt/dist`);
+
+shell.cp('-r', '.nuxt/dist/server', `${deploymentFolder}/.nuxt/dist`);
+
+shell.cp(path.join(__dirname, '../server/lambda-handler.js'), deploymentFolder);
+
+shell.cp('.env', deploymentFolder);
+shell.cp('nuxt.config.js', deploymentFolder);
+
+const entryPoint = path.join(__dirname, '../index.ts')
+shell.exec(`yarn cdk deploy --require-approval never --all --app="yarn ts-node ${entryPoint}"`);

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/functions/assets_cleanup/index.ts

@@ -0,0 +1,96 @@
+import {DeleteObjectsCommand, ListObjectsV2Command, S3Client} from "@aws-sdk/client-s3";
+
+const ONE_WEEK_IN_MILLISECONDS = 1000 * 60 * 60 * 24 * 7;
+
+exports.handler = async (event: any, context: any) => {
+    console.log('Starting cleanup of static assets older than 1 week...');
+
+    try {
+        const client = new 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 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 = deploymentFolders.CommonPrefixes?.map(folder => folder.Prefix?.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 ListObjectsV2Command({
+                            Bucket: bucketName,
+                            Prefix: folderName,
+                        })
+                    )
+                    .then(outdatedAssets => {
+                        return client.send(
+                            new DeleteObjectsCommand({
+                                Bucket: bucketName,
+                                Delete: {
+                                    Objects: outdatedAssets.Contents?.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);
+    }
+};

package/lib/functions/assets_cleanup/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "cdk-nuxt-assets-cleanup",
+  "version": "0.1.2",
+  "main": "index.js",
+  "license": "UNLICENSED",
+  "private": true,
+  "scripts": {
+    "install-layer": "yarn install --frozen-lockfile --production --modules-folder build/layer/nodejs/node_modules",
+    "build": "tsc --project ./tsconfig.json"
+  },
+  "devDependencies": {
+    "@types/node": "^16.11.0",
+    "ts-node": "^10.3.0",
+    "typescript": "^4.4.0"
+  },
+  "dependencies": {
+    "@aws-sdk/client-s3": "^3.37.0"
+  }
+}

package/lib/functions/assets_cleanup/tsconfig.json

@@ -0,0 +1,35 @@
+{
+  "compilerOptions": {
+    "outDir": "./build/app",
+    "target": "ES2021",
+    "module": "CommonJS",
+    "lib": [
+      "es2021"
+    ],
+    "declaration": true,
+    "alwaysStrict": true,
+    "sourceMap": true,
+    "inlineSources": true,
+    "inlineSourceMap": false,
+    "sourceRoot": "/",
+    "noEmitHelpers": true,
+    "importHelpers": true,
+    "noImplicitAny": false,
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": false,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "strictPropertyInitialization": false,
+    "moduleResolution": "node",
+    "baseUrl": "./",
+    "paths": {
+      "*": ["./node_modules/*"]
+    },
+    "typeRoots": ["./node_modules/@types"],
+    "skipLibCheck": true
+  },
+  "include": ["./"],
+  "exclude": ["./build", "./node_modules"]
+}