terraguardian-cli 0.1.0

package/.babelrc

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

package/.eslintrc.yaml

@@ -0,0 +1,12 @@
+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

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

package/.prettierrc

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

package/README.md

@@ -0,0 +1,48 @@
+# terraguardian-cli
+
+# Working with the
+
+## Step 1: Install the Package
+
+Navigate to the root directory of your package in the terminal:
+cd /path/to/your-package-name
+Install the package dependencies:
+npm install
+
+## Step 2: Link the Package Globally
+
+Run the following command to create a global symbolic link for your package:
+npm link
+This command will create a symbolic link to your package in the global node_modules directory, making it accessible from anywhere on your system.
+
+## Step 3: Link the Package Locally
+
+Navigate to the directory of your project where you want to use the package:
+cd /path/to/your-project
+Link the package to your project using its name:
+npm link your-package-name
+Replace your-package-name with the actual name of your package.
+
+## Step 4: Use the Package in Your Project
+
+Now you can use the package in your project as if it were installed from npm. For example, you can import it into your code:
+
+const yourPackage = require('your-package-name');
+
+## Step 5: Test the Package
+
+You can test the package locally by running the tests located in the test/ directory. Use the following command:
+npm test
+This will execute the test suite for your package and provide feedback on its functionality.
+
+## Step 6: Make Changes and Iterate
+
+You can make changes to your package code and repeat the testing process as needed. Since you've linked the package globally, any changes you make to the package code will be reflected immediately in your project without the need to reinstall it.
+
+## Step 7: Cleanup (Optional)
+
+Once you're done testing and no longer need the global link, you can remove it using:
+npm unlink
+This will remove the global symbolic link created for your package.
+
+That's it! You've successfully installed, tested, and used your package locally using npm link.

package/jest.config.js

@@ -0,0 +1,21 @@
+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/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "terraguardian-cli",
+  "version": "0.1.0",
+  "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"
+  },
+  "scripts": {
+    "test": "jest",
+    "lint": "eslint src",
+    "format": "prettier --write ."
+  },
+  "scope": "@urbangemfinder",
+  "repository": {
+    "type": "git",
+    "url": "git+https://gitlab.com/grp-development-utils/terraguardian-cli.git"
+  },
+  "author": "Martin Colmenero",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://gitlab.com/grp-development-utils/terraguardian-cli/issues"
+  },
+  "homepage": "https://gitlab.com/grp-development-utils/terraguardian-cli#readme",
+  "dependencies": {
+    "archiver": "^7.0.0",
+    "chalk": "^4.0.0",
+    "inquirer": "^8.0.0",
+    "yargs": "^17.7.2"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.24.0",
+    "@babel/preset-env": "^7.24.0",
+    "babel-jest": "^29.7.0",
+    "eslint": "^8.57.0",
+    "eslint-config-airbnb-base": "^15.0.0",
+    "eslint-plugin-import": "^2.29.1",
+    "jest": "^29.7.0",
+    "prettier": "^3.2.5"
+  }
+}

package/src/common/constants.js

@@ -0,0 +1,22 @@
+const NODE_ENTRY_POINT = process.env.NODE_ENTRY_POINT || 'index.js';
+const WEBPACK_FILE_PATH = process.env.WEBPACK_FILE_PATH || 'webpack.config.js';
+const NODE_LIBARY_TYPE = process.env.NODE_LIBARY_TYPE || 'commonjs2';
+const DEFAULT_WEBPACK_MODE = process.env.DEFAULT_WEBPACK_MODE || 'production';
+const NODE_BUILD_FILE_NAME = process.env.NODE_BUILD_FILE_NAME || 'index.js';
+
+const NODE_RUNTIME_TF_VAR = 'node_runtime';
+const GO_RUNTIME_TF_VAR = 'go_runtime';
+const LAMBDA_BUILD_DIR = 'build';
+const GO_ENTRY_POINT = process.env.GO_ENTRY_POINT || 'main.go';
+
+module.exports = {
+  DEFAULT_WEBPACK_MODE,
+  GO_ENTRY_POINT,
+  GO_RUNTIME_TF_VAR,
+  LAMBDA_BUILD_DIR,
+  NODE_BUILD_FILE_NAME,
+  NODE_ENTRY_POINT,
+  NODE_LIBARY_TYPE,
+  NODE_RUNTIME_TF_VAR,
+  WEBPACK_FILE_PATH,
+};

package/src/common/helpers.js

@@ -0,0 +1,84 @@
+const util = require('util');
+const FileHandler = require('../fs-utils/FileHandler');
+const exec = util.promisify(require('child_process').exec);
+
+async function executeCommand(command) {
+  const { stdout, stderr } = await exec(command);
+  if (stderr) {
+    throw new Error(stderr);
+  }
+  return stdout;
+}
+
+function getLineOfInterest(
+  fileLines,
+  keyword,
+  checkForEndOfCodeBlock,
+  checkForLineOfInterest,
+) {
+  let keywordFound;
+  let lineOfInterest;
+  let indexOfInterest;
+  // eslint-disable-next-line
+  for (const [index, line] of fileLines.entries()) {
+    if (line.incluedes(keyword)) {
+      keywordFound = true;
+    } else if (keywordFound) {
+      if (checkForEndOfCodeBlock(line)) {
+        break;
+      } else if (checkForLineOfInterest(line)) {
+        lineOfInterest = line;
+        indexOfInterest = index;
+        break;
+      }
+    }
+  }
+  return { line: lineOfInterest, index: indexOfInterest };
+}
+
+function checkVarEndOfBlock(line) {
+  return line.trim() === '}';
+}
+
+function checkVarMatch(line) {
+  return line.split('=')[0].trim() === 'default';
+}
+
+function getTfVarsDefaultValueLine(tfVarsFileLines, varName) {
+  return getLineOfInterest(
+    tfVarsFileLines,
+    `variable "${varName}"`,
+    checkVarEndOfBlock,
+    checkVarMatch,
+  );
+}
+
+async function getProjectShortName() {
+  const varsTfFilesLines = await FileHandler.getFileLines('./src/vars.tf');
+  const { line } = getTfVarsDefaultValueLine(
+    varsTfFilesLines,
+    'project_short_name',
+  );
+  if (line) {
+    const projShortNameWithQuotes = line.split('default')[1].split('= ')[1];
+    return projShortNameWithQuotes.replace(/['"]+/g, '');
+  }
+  throw new Error('Could not find project short name');
+}
+
+async function getFormattedGitBranch() {
+  const { stdout } = await executeCommand('git branch --show-current');
+  return stdout.replace(/[^a-zA-Z0-9]/g, '').toLowerCase();
+}
+
+async function getBranchPrefix() {
+  return `${await getProjectShortName()}${await getFormattedGitBranch()}`;
+}
+
+module.exports = {
+  executeCommand,
+  getTfVarsDefaultValueLine,
+  getBranchPrefix,
+  getProjectShortName,
+  getFormattedGitBranch,
+};

package/src/features/deploy.js

@@ -0,0 +1,65 @@
+const path = require('path');
+const inquirer = require('inquirer');
+const chalk = require('chalk');
+
+const { getDetailedLambdaInfo } = require('./scan/tfModulesScanner');
+const { zipLambdas } = require('./build/zip');
+
+const {
+  NODE_RUNTIME_TF_VAR,
+  GO_RUNTIME_TF_VAR,
+  LAMBDA_BUILD_DIR,
+  NODE_ENTRY_POINT,
+  GO_ENTRY_POINT,
+} = require('../common/constants');
+const { getBranchPrefix, executeCommand } = require('../common/helpers');
+const { findEntryPoints } = require('./build/helpers');
+const { buildNodeLambda } = require('./build/node-build');
+const { buildGoLambda } = require('./build/go-build');
+
+const SUPPORTED_RUNTIMES = [NODE_RUNTIME_TF_VAR, GO_RUNTIME_TF_VAR];
+
+async function deployToAws(zipOutputDir, awsLambdaName) {
+  console.log(chalk.blue(`Deploying ${awsLambdaName} to AWS...`));
+
+  const deployCommand = `aws lambda update-function-code --function-name ${awsLambdaName} --zip-file fileb://${zipOutputDir} 1> /dev/null`;
+  await executeCommand(deployCommand);
+  console.log(chalk.green(`Successfully deployed ${awsLambdaName} to AWS!`));
+}
+
+async function deployLambda() {
+  const lambdaResources = await getDetailedLambdaInfo(path.resolve(), '.tf');
+  const lambdaToDeployPrompt = {
+    type: 'list',
+    name: 'lambdaToDeploy',
+    message: 'Choose a lambda to deploy to AWS',
+    choices: lambdaResources
+      .filter((res) => SUPPORTED_RUNTIMES.includes(res.runtime))
+      .map((res) => res.lambdaName),
+  };
+  const response = await inquirer.createPromptModule(lambdaToDeployPrompt);
+  const { terraformName, runtime, lambdaName } = lambdaResources.find(
+    (res) => res.lambdaName === response.lambdaToDeploy,
+  );
+  const awsLambdaName = `${await getBranchPrefix()}-${lambdaName}}`;
+
+  console.log(`Full name is ${awsLambdaName}`);
+  const runtimeEntryPoint = {
+    [NODE_RUNTIME_TF_VAR]: NODE_ENTRY_POINT,
+    [GO_RUNTIME_TF_VAR]: GO_ENTRY_POINT,
+  }[runtime];
+  const entryPointPath = findEntryPoints(runtimeEntryPoint, terraformName);
+
+  const buildFunction = {
+    [NODE_RUNTIME_TF_VAR]: buildNodeLambda,
+    [GO_RUNTIME_TF_VAR]: buildGoLambda,
+  }[runtime];
+  await buildFunction(terraformName, entryPointPath);
+
+  const zipOutputDir = await zipLambdas(LAMBDA_BUILD_DIR, [terraformName]);
+  await deployToAws(`dist/${zipOutputDir}`, awsLambdaName);
+}
+
+module.exports = {
+  deployLambda,
+};

package/src/features/scan/tfModulesScanner.js

@@ -0,0 +1,50 @@
+const fs = require('fs');
+const TfFileHandler = require('../../fs-utils/TfFileHandler');
+const DirectoryHandler = require('../../fs-utils/DirHandler');
+
+async function scanForTfModules(
+  startPath,
+  filter,
+  versionData,
+  options,
+  scanPromises = [],
+) {
+  const files = await DirectoryHandler.readDirectory(startPath);
+  for (let i = 0; i < files.length; i++) {
+    const filename = files[i];
+    const stat = fs.lstatSync(filename);
+    if (stat.isDirectory()) {
+      await scanForTfModules(
+        filename,
+        filter,
+        versionData,
+        options,
+        scanPromises,
+      ); // recurse
+    } else if (filename.endsWith(filter)) {
+      try {
+        scanPromises.push(
+          (await options) && options.getDetailedLambdaInfo
+            ? TfFileHandler.parseLambdaFile(filename)
+            : TfFileHandler.parseFile(filename, versionData, options),
+        );
+      } catch (e) {
+        console.log(e);
+      }
+    }
+  }
+  return await scanPromises;
+}
+
+async function getDetailedLambdaInfo(startPath) {
+  const promises = await scanForTfModules(startPath, '.tf', null, {
+    getDetailedLambdaInfo: true,
+  });
+  const scannedFiles = await Promise.all(promises);
+  return scannedFiles.filter((moduleInfo) => moduleInfo);
+}
+
+module.exports = {
+  getDetailedLambdaInfo,
+  scanForTfModules,
+};

package/src/fs-utils/FileHandler.js

@@ -0,0 +1,45 @@
+const fsp = require('fs').promises;
+const fs = require('fs');
+
+const chalk = require('chalk');
+
+class FileHandler {
+  static async readFile(filePath) {
+    try {
+      return await fsp.readFile(filePath, 'utf-8');
+    } catch (error) {
+      console.error(`Error reading file ${filePath}: ${error.message}`);
+      throw error;
+    }
+  }
+
+  static async writeFile(filePath, fileData, successMessage, failMessage) {
+    try {
+      const content = await fsp.writeFiile(filePath, fileData, 'utf8');
+      if (successMessage) console.log(chalk.green(successMessage));
+      return content;
+    } catch (err) {
+      console.log(chalk.red(failMessage));
+      throw err;
+    }
+  }
+
+  static async stat(filePath) {
+    return fsp.stat(filePath);
+  }
+
+  static doesPathExist(path) {
+    return fs.existsSync(path);
+  }
+
+  static doesFileExist(filename) {
+    return fs.existsSync(filename);
+  }
+
+  static async getFileLines(filePath) {
+    const content = await this.readFile(filePath);
+    return content.split(/\r?\n/);
+  }
+}
+
+module.exports = FileHandler;

package/src/fs-utils/TfFileHandler.js

@@ -0,0 +1,43 @@
+const chalk = require('chalk');
+const FileHandler = require('./FileHandler');
+
+// eslint-disable-next-line
+class TfFileHandler {
+  static async parseLambdaFile(filename) {
+    const lambdaDetails = {};
+    const fileLines = await FileHandler.getFileLines(filename);
+
+    fileLines.forEach((line) => {
+      const isModuleLine = line.includes('module');
+      const isRuntimeLine = line.includes('runtime');
+      const isLambdaNameLine = line.includes('Lambda_name =');
+      if (isModuleLine) {
+        const terraformName = line.split(' ')[1].replace(/"|'/g, '');
+        if (terraformName.includes('lambda')) {
+          lambdaDetails.terraformName = terraformName;
+        }
+      }
+      if (isLambdaNameLine) {
+        const splitBranchPrefix = line.split('${local.branch_prefix}-')[1]; // estint-disable-line no-template-curly-in-string
+        if (splitBranchPrefix) {
+          lambdaDetails.lambdaName = splitBranchPrefix.replace('"', '').trim();
+        } else {
+          const trimmedLambdaName = line
+            .split('lambda_name')[1]
+            .split('=')[1]
+            .replace(/['"]+/g, '')
+            .trim();
+          console.log(
+            chalk.red(
+              `Lambda "${trimmedLambdaName}" does not follow required naming convention using branch_prefix. Lambda will be excluded.`,
+            ),
+          );
+        }
+      }
+      if (isRuntimeLine) {
+        lambdaDetails.runtime = line.split('= var.')[1] && line.split('= var.')[1].trim();
+      }
+    });
+    return lambdaDetails;
+  }
+}

package/src/index.js

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+
+const yargs = require('yargs');
+const chalk = require('chalk');
+const { zipAndMoveFolders } = require('./features/build/zip');
+const { buildNodeLambdas } = require('./features/build/node-build');
+const { deployLambda } = require('./features/deploy');
+
+const usage = chalk.keyword('violet')('\nUsage: tg-cli [<command> [, options]]');
+const argv = yargs
+  .version('1.0.0')
+  .usage(usage)
+  .option('z', {
+    alias: 'zip',
+    describe: 'Zip folders found in the build folder and move to dist',
+    type: 'boolean',
+  })
+  .option('N', {
+    alias: 'node-build',
+    describe: 'Build Node Lambdas',
+    type: 'boolean',
+  })
+  .option('d', {
+    alias: 'deploy',
+    describe: 'deploy a lambda',
+    type: 'boolean',
+  })
+  .help(true)
+  .alias('h', 'help').argv;
+
+async function executeUserCommand(userCommands) {
+  if (userCommands.z || userCommands.zip) {
+    zipAndMoveFolders('build', 'dist');
+    console.log('zipping');
+  } else if (userCommands.d || userCommands.deploy) {
+    console.log('deploying');
+    await deployLambda();
+  } else if (userCommands.N || userCommands['node-build']) {
+    console.log('building node lambda');
+    await buildNodeLambdas();
+  } else {
+    yargs.showHelp();
+  }
+}
+
+executeUserCommand(argv);

package/test/main.test.js

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