terraguardian-cli 0.1.0 → 0.1.2

package/package.json

@@ -1,11 +1,16 @@
 {
   "name": "terraguardian-cli",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "CLI that helps with projects that are built with terraform and helps with deployments of lambda src code",
   "main": "index.js",
   "bin": {
     "tg-cli": "src/index.js"
   },
+  "files": [
+    "src",
+    "bin"
+    
+  ],
   "scripts": {
     "test": "jest",
     "lint": "eslint src",

package/src/features/build/go-build.js

@@ -0,0 +1,23 @@
+const chalk = require('chalk');
+const util = require('util');
+const exec = util.promisify(require('child_process').exec);
+
+const GO_BINARY_NAME = 'bootstrap';
+const GO_ARCHITECTURE = 'arm64';
+
+const { GO_LAMBDA_SRC_DIR, LAMBDA_BUILD_DIR } = require('../../common/constants');
+
+async function buildGoLambda(lambdaName) {
+  console.log('Building the go lambda...');
+  const goLambdaSrcPath = `${GO_LAMBDA_SRC_DIR}/${lambdaName.split('lambda_')[1]}`;
+  const buildOutputDir = `${LAMBDA_BUILD_DIR}/${lambdaName}`;
+  const buildCommand = `GOOS='linux' GOARCH='${GO_ARCHITECTURE}' GO111MODULE='on' go build -tags 'lambda.norpc' -o '${buildOutputDir}/${GO_BINARY_NAME}' '${goLambdaSrcPath}'`;
+
+  await exec(buildCommand);
+  console.log(chalk.green('Successfully built the lambda'));
+  return `${buildOutputDir}/${GO_BINARY_NAME}`;
+}
+
+module.exports = {
+  buildGoLambda,
+};

package/src/features/build/helpers.js

@@ -0,0 +1,44 @@
+const { execSync } = require('child_process');
+const { NODE_RUNTIME_TF_VAR, GO_RUNTIME_TF_VAR } = require('../../common/constants');
+
+const getEntryPointPaths = (config) => execSync(`${config.search} -name "${config.entryPoint}" -print`)
+  .toString()
+  .split('\n')
+  .filter(Boolean);
+
+const getNormalizedLambdaNames = (lamdbdaPaths) => lamdbdaPaths.map((lambdaPath) => {
+  const regex = /lambda_(\w+)/g;
+  return regex.exec(lambdaPath)[0];
+});
+
+function findEntryPoints(runtime, lambdaName) {
+  const findConfig = {
+    [GO_RUNTIME_TF_VAR]: {
+      search: 'find "$(pwd)/build" -path "$(pwd)/build" -prune -o -name node_modules -prune -o -path "$(pwd)/dist" -prune -o',
+      entryPoint: 'main.go',
+      regexFilter: null,
+    },
+    [NODE_RUNTIME_TF_VAR]: {
+      search: 'find "$(pwd)/modules" -path "$(pwd)/dist" -prune -o -name node_modules -prune -o -path "$(pwd)/build" -prune -o',
+      entryPoint: 'index.js',
+      regexFilter: 'lambda_[^/]+/src/index.js',
+    },
+  }[runtime];
+  const entryPointPaths = getEntryPointPaths(findConfig);
+
+  if (lambdaName) {
+    return entryPointPaths.find((path) => path.includes(lambdaName));
+  }
+
+  const regex = new RegExp(findConfig.regexFilter);
+  if (regex) {
+    return entryPointPaths.filter((path) => regex.test(path));
+  }
+  return entryPointPaths;
+}
+
+module.exports = {
+  findEntryPoints,
+  getEntryPointPaths,
+  getNormalizedLambdaNames,
+};

package/src/features/build/node-build.js

@@ -0,0 +1,63 @@
+const chalk = require('chalk');
+
+const {
+  LAMBDA_BUILD_DIR,
+  WEBPACK_FILE_PATH,
+  NODE_LIBARY_TYPE,
+  DEFAULT_WEBPACK_MODE,
+  NODE_BUILD_FILE_NAME,
+  NODE_RUNTIME_TF_VAR,
+} = require('../../common/constants');
+const { executeCommand } = require('../../common/helpers');
+const FileHandler = require('../../fs-utils/FileHandler');
+const { findEntryPoints, getNormalizedLambdaNames } = require('./helpers');
+
+function getWebpackBuildCommand(lambdaName, lambdaPath, buildOutputDir) {
+  let buildCommand;
+  const webpackExists = FileHandler.doesFileExist('webpack.config.js');
+
+  if (webpackExists) {
+    console.log('Webpack exists');
+    buildCommand = (`npx webpack --config ${WEBPACK_FILE_PATH} --entry ${lambdaPath} --output-path "${buildOutputDir}" --output-filename ${NODE_BUILD_FILE_NAME}`);
+  } else {
+    console.log('Webpack does not exist');
+    buildCommand = (`npx webpack -entry ${lambdaPath} --output "${buildOutputDir}" --output-filename ${NODE_BUILD_FILE_NAME} -t ${NODE_LIBARY_TYPE} -target 'node' -mode ${DEFAULT_WEBPACK_MODE}`);
+  }
+  return buildCommand;
+}
+
+async function buildNodeLambda(lambdaName, lambdaPath) {
+  console.log(chalk.blue(`Building the Node Lambda ${lambdaName}...`));
+
+  const buildOutputDir = `${LAMBDA_BUILD_DIR}/${lambdaName}`;
+
+  const buildCommand = await getWebpackBuildCommand(lambdaName, lambdaPath, buildOutputDir);
+  console.log(await executeCommand(buildCommand));
+  console.log(chalk.green('Successfully built the Lambda'));
+  return `${buildOutputDir}/${NODE_BUILD_FILE_NAME}`;
+}
+
+async function buildNodeLambdas() {
+  const lambdaPaths = findEntryPoints(NODE_RUNTIME_TF_VAR);
+  const normalizedLambdaNames = getNormalizedLambdaNames(lambdaPaths);
+  if (lambdaPaths.length > 0) {
+    if (FileHandler.doesPathExist('./node_modules')) {
+      console.log('node_modules exists');
+    } else {
+      console.log('node_modules does not exist');
+      console.log('Installing node_modules');
+      const { stdout, stderr } = await executeCommand('npm install');
+      console.log(stdout);
+      console.log(stderr);
+    }
+  }
+
+  lambdaPaths.forEach((lambdaPath, index) => {
+    buildNodeLambda(normalizedLambdaNames[index], lambdaPath);
+  });
+}
+
+module.exports = {
+  buildNodeLambda,
+  buildNodeLambdas,
+};

package/src/features/build/zip.js

@@ -0,0 +1,100 @@
+const fs = require('fs');
+const archiver = require('archiver');
+const path = require('path');
+const { promisify } = require('util');
+
+const readdir = promisify(fs.readdir);
+const stat = promisify(fs.stat);
+const mkdir = promisify(fs.mkdir);
+// const rename = promisify(fs.rename);
+
+// TODO: Revist this later for hasing the build dir
+// function getFileHash(filePath) {
+//     const data = fs.readFileSync(filePath);
+//     return crypto.createHash('md5').update(data).digest('hex');
+// }
+
+async function setTimestampToSameTimeRecursive(dirPath, timestamp) {
+  fs.readdirSync(dirPath).forEach((file) => {
+    const filePath = path.join(dirPath, file);
+    const statOutput = fs.statSync(filePath);
+
+    if (statOutput.isDirectory()) {
+      fs.utimesSync(filePath, timestamp, timestamp);
+      setTimestampToSameTimeRecursive(filePath, timestamp);
+    } else {
+      fs.utimesSync(filePath, timestamp, timestamp);
+    }
+  });
+}
+
+async function zipFolder(sourceFolder, destinationZip) {
+  return new Promise((resolve, reject) => {
+    const output = fs.createWriteStream(destinationZip);
+    const archive = archiver('zip');
+
+    output.on('close', async () => {
+      // TODO: Return to this if needed for hashing
+      // console.log("zipFileName")
+      // console.log(zipFileName)
+
+      // const zipHash = getFileHash(path.join(zipFileName))
+      // const zipName = await getZipName(zipFileName, "zipHash")
+      // await fs.renameSync(zipFileName, path.join(destinationZip, zipName))
+      // console.log(`${zipFileName} zip file has been created`)
+      resolve();
+    });
+
+    output.on('error', (err) => {
+      reject(err);
+    });
+
+    archive.pipe(output);
+    archive.directory(sourceFolder, false);
+    archive.finalize();
+  });
+}
+
+async function zipAndMoveFolders(sourceFolder, destinationFolder) {
+  const zipFiles = {}; // Object to store zip file information
+
+  try {
+    const ts = new Date(2020, 0, 1);
+    await setTimestampToSameTimeRecursive(sourceFolder, ts);
+    // Ensure the destination folder exists
+    await mkdir(destinationFolder, { recursive: true });
+
+    // Read all files and subdirectories in the source folder
+    const entries = await readdir(sourceFolder);
+    // eslint-disable-next-line
+    for (const entry of entries) {
+      const entryPath = path.join(sourceFolder, entry);
+      const stats = await stat(entryPath);
+
+      if (stats.isDirectory()) {
+        // If the entry is a directory, zip it and move the resulting zip file
+        const zipFileName = `${entry}.zip`;
+        const zipFilePath = path.join(destinationFolder, zipFileName);
+        await zipFolder(entryPath, zipFilePath, zipFileName);
+
+        // Add the zip file details to the object
+        zipFiles[entry] = {
+          name: zipFileName,
+          path: zipFilePath,
+        };
+      }
+    }
+    console.log('All folders have been zipped and moved successfully.');
+  } catch (error) {
+    console.error('Failed to zip and move folders:', error);
+  }
+  return zipFiles; // Return the JSON object
+}
+// TODO: Revist later
+// async function getZipName(builtLambda, zipHash) {
+//     return `${builtLambda}_-_${zipHash}.zip`
+// }
+
+module.exports = {
+  zipAndMoveFolders,
+};

package/src/index.js

@@ -2,6 +2,8 @@
 
 const yargs = require('yargs');
 const chalk = require('chalk');
+const path = require('path');
+const fs = require('fs');
 const { zipAndMoveFolders } = require('./features/build/zip');
 const { buildNodeLambdas } = require('./features/build/node-build');
 const { deployLambda } = require('./features/deploy');
@@ -30,8 +32,19 @@ const argv = yargs
 
 async function executeUserCommand(userCommands) {
   if (userCommands.z || userCommands.zip) {
-    zipAndMoveFolders('build', 'dist');
-    console.log('zipping');
+    // Write the result to a JSON file
+    console.log('Zipping folders...');
+    const zipDetails = await zipAndMoveFolders('build', 'dist');
+
+    // Write the result to a JSON file
+    const resultFilePath = path.join(process.cwd(), 'zip-details.json');
+    await fs.promises.writeFile(
+      resultFilePath,
+      JSON.stringify(zipDetails, null, 2),
+      'utf-8',
+    );
+
+    console.log(`Zipping complete. Details saved to ${resultFilePath}`);
   } else if (userCommands.d || userCommands.deploy) {
     console.log('deploying');
     await deployLambda();

package/.babelrc

@@ -1,7 +0,0 @@
-{
-    "presets": [
-      "@babel/preset-env"
-    ],
-    "plugins": []
-  }
-  

package/.eslintrc.yaml

@@ -1,12 +0,0 @@
-extends: 
-  - airbnb-base
-  - plugin:import/errors 
-  - plugin:import/warnings
-rules:
-  prefer-destructuring: off
-  no-template-curly-in-string: warn
-  no-return-await: off
-  no-await-in-loop: warn
-  no-plusplus: off
-  import/extensions: off
-  import/no-unresolved: "off"

package/.gitlab-ci.yml

@@ -1,5 +0,0 @@
-include:
-  - project: 'grp-development-utils/cicd-pipeline-utilities/node-cicd'
-    ref: v1-latest
-    file:
-      - 'consumer/templates/node-package.yml'

package/.prettierrc

@@ -1,6 +0,0 @@
-{
-  "semi": false,
-  "singleQuote": true,
-  "tabWidth": 2,
-  "useTabs": false
-}

package/jest.config.js

@@ -1,21 +0,0 @@
-module.exports = {
-    roots: ['<rootDir>'],
-    moduleFileExtensions: ['js', 'json'],
-    testEnvironment: 'node',
-    testRegex: '\\.test\\.js$',
-    transform: {
-      '^.+\\.js$': 'babel-jest',
-    },
-    collectCoverage: true,
-    coverageDirectory: 'test/coverage',
-    collectCoverageFrom: ['<rootDir>/src/**/*.js'],
-    coveragePathIgnorePatterns: ['/node_modules/', '/build/', '/dist/'], // Add paths to ignore here
-    coverageThreshold: {
-        global: {
-          branches: 0,
-          functions: 0,
-          lines: 0,
-          statements: 0,
-        },
-      },
-  };

package/test/main.test.js

@@ -1,3 +0,0 @@
-test('adds 1 + 2 to equal 3', () => {
-    expect(1+2).toBe(3);
-});