terraguardian-cli 0.1.2 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "terraguardian-cli",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "description": "CLI that helps with projects that are built with terraform and helps with deployments of lambda src code",
   "main": "index.js",
   "bin": {
@@ -9,7 +9,6 @@
   "files": [
     "src",
     "bin"
-    
   ],
   "scripts": {
     "test": "jest",
@@ -30,7 +29,7 @@
   "dependencies": {
     "archiver": "^7.0.0",
     "chalk": "^4.0.0",
-    "inquirer": "^8.0.0",
+    "inquirer": "^8.2.6",
     "yargs": "^17.7.2"
   },
   "devDependencies": {

package/src/common/helpers.js

@@ -4,6 +4,7 @@ const exec = util.promisify(require('child_process').exec);
 
 async function executeCommand(command) {
   const { stdout, stderr } = await exec(command);
+  console.log(stdout);
   if (stderr) {
     throw new Error(stderr);
   }

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

@@ -1,29 +1,28 @@
 const chalk = require('chalk');
+const { executeCommand } = require('../../common/helpers');
+const FileHandler = require('../../fs-utils/FileHandler');
+const { findEntryPoints, getNormalizedLambdaNames } = require('./helpers');
 
 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;
+// Create esbuild build command
+function getEsbuildBuildCommand(lambdaName, lambdaPath, buildOutputDir) {
+  const buildCommand = [
+    'npx esbuild',
+    lambdaPath, // Input file (entry point)
+    '--bundle', // Bundle the files together
+    '--platform=node', // Set platform to node for AWS Lambda
+    '--target=node20', // Change as needed for your Lambda runtime
+    `--outfile=${buildOutputDir}/${NODE_BUILD_FILE_NAME}`, // Output file name
+    '--sourcemap', // Optional: generate sourcemaps for debugging
+    '--minify', // Optional: minify the output (you can disable if not needed)
+  ];
+
+  return buildCommand.join(' ');
 }
 
 async function buildNodeLambda(lambdaName, lambdaPath) {
@@ -31,7 +30,7 @@ async function buildNodeLambda(lambdaName, lambdaPath) {
 
   const buildOutputDir = `${LAMBDA_BUILD_DIR}/${lambdaName}`;
 
-  const buildCommand = await getWebpackBuildCommand(lambdaName, lambdaPath, buildOutputDir);
+  const buildCommand = getEsbuildBuildCommand(lambdaName, lambdaPath, buildOutputDir);
   console.log(await executeCommand(buildCommand));
   console.log(chalk.green('Successfully built the Lambda'));
   return `${buildOutputDir}/${NODE_BUILD_FILE_NAME}`;
@@ -40,12 +39,10 @@ async function buildNodeLambda(lambdaName, lambdaPath) {
 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');
+    if (!FileHandler.doesPathExist('./node_modules')) {
+      console.log('node_modules does not exist, installing...');
       const { stdout, stderr } = await executeCommand('npm install');
       console.log(stdout);
       console.log(stderr);

package/src/features/deploy/lambda.js

@@ -0,0 +1,11 @@
+const { executeCommand } = require('../../common/helpers');
+
+// uses the aws cli to deploy a lambda to AWS
+function deployLambda(lambdaName, zipFileName) {
+  const deployCommand = `aws lambda update-function-code --function-name ${lambdaName} --zip-file fileb://dist/${zipFileName}.zip 1> /dev/null`;
+  return executeCommand(deployCommand);
+}
+
+module.exports = {
+  deployLambda,
+};

package/src/features/validate-terraform/validate.js

@@ -0,0 +1,86 @@
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const crypto = require('crypto');
+
+// Find all .tf files recursively
+function getTerraformFiles(dir) {
+  let files = [];
+  /* eslint-disable-next-line */
+  for (const file of fs.readdirSync(dir)) {
+    const fullPath = path.join(dir, file);
+    if (fs.statSync(fullPath).isDirectory()) {
+      files = files.concat(getTerraformFiles(fullPath));
+    } else if (file.endsWith('.tf')) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+
+async function validateTerraformCode() {
+  const ROOT_DIR = process.cwd();
+  const BUILD_DIR = path.join(ROOT_DIR, 'tf-build');
+  const LOCK_FILE = path.join(BUILD_DIR, '.terraform.lock.hcl');
+  const HASH_FILE = path.join(ROOT_DIR, '.tf-build-hash');
+
+  try {
+    console.log(`Setting up Terraform validation in ${BUILD_DIR}...`);
+
+    // Ensure tf-build exists and remove old Terraform files (but keep .terraform/ if it exists)
+    if (fs.existsSync(BUILD_DIR)) {
+      fs.readdirSync(BUILD_DIR).forEach((file) => {
+        const filePath = path.join(BUILD_DIR, file);
+        if (!file.startsWith('.terraform')) {
+          fs.rmSync(filePath, { recursive: true, force: true });
+        }
+      });
+    } else {
+      fs.mkdirSync(BUILD_DIR, { recursive: true });
+    }
+
+    const tfFiles = getTerraformFiles(ROOT_DIR);
+
+    // Generate a hash of all Terraform files
+    const hash = crypto.createHash('sha256');
+    tfFiles.forEach((file) => {
+      hash.update(fs.readFileSync(file));
+    });
+    const currentHash = hash.digest('hex');
+
+    // Check if the hash has changed since the last run
+    let previousHash = '';
+    if (fs.existsSync(HASH_FILE)) {
+      previousHash = fs.readFileSync(HASH_FILE, 'utf8');
+    }
+
+    const providersChanged = !fs.existsSync(LOCK_FILE) || previousHash !== currentHash;
+
+    // Copy files with modified names
+    tfFiles.forEach((file) => {
+      const relativePath = path.relative(ROOT_DIR, file);
+      const modifiedName = relativePath.replace(/\//g, '-');
+      const destPath = path.join(BUILD_DIR, modifiedName);
+      fs.copyFileSync(file, destPath);
+    });
+
+    // Run terraform init only if providers changed
+    if (providersChanged) {
+      console.log('Providers changed, running terraform init...');
+      execSync('terraform init -backend=false -input=false -no-color', { cwd: BUILD_DIR, stdio: 'inherit' });
+      fs.writeFileSync(HASH_FILE, currentHash); // Save new hash
+    } else {
+      console.log('No provider changes detected, skipping terraform init.');
+    }
+
+    // Run terraform validate
+    execSync('terraform validate', { cwd: BUILD_DIR, stdio: 'inherit' });
+
+    console.log('Terraform validation successful.');
+  } catch (error) {
+    console.error('Terraform validation failed:', error.message);
+    process.exit(1);
+  }
+}
+
+module.exports = { validateTerraformCode };

package/src/index.js

@@ -4,9 +4,19 @@ const yargs = require('yargs');
 const chalk = require('chalk');
 const path = require('path');
 const fs = require('fs');
+const inquirer = require('inquirer');
+
 const { zipAndMoveFolders } = require('./features/build/zip');
 const { buildNodeLambdas } = require('./features/build/node-build');
-const { deployLambda } = require('./features/deploy');
+const { deployLambda } = require('./features/deploy/lambda');
+const { validateTerraformCode } = require('./features/validate-terraform/validate');
+
+// A function that gets the names of the zip files in the dist folder and filters out the extension
+function getZipNames(dirPath) {
+  const files = fs.readdirSync(dirPath);
+  const zipFiles = files.filter((file) => path.extname(file) === '.zip').map((file) => path.basename(file, '.zip'));
+  return zipFiles;
+}
 
 const usage = chalk.keyword('violet')('\nUsage: tg-cli [<command> [, options]]');
 const argv = yargs
@@ -27,6 +37,11 @@ const argv = yargs
     describe: 'deploy a lambda',
     type: 'boolean',
   })
+  .option('v', {
+    alias: 'validate-tf',
+    describe: 'validate terraform code even if it is nested',
+    type: 'boolean',
+  })
   .help(true)
   .alias('h', 'help').argv;
 
@@ -47,10 +62,31 @@ async function executeUserCommand(userCommands) {
     console.log(`Zipping complete. Details saved to ${resultFilePath}`);
   } else if (userCommands.d || userCommands.deploy) {
     console.log('deploying');
-    await deployLambda();
+    // get all the zip folder names from the dist folder
+    const lambdasOptions = getZipNames('dist');
+    const response = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'deployOptions',
+        message: 'Which Lambda would you like to deploy?',
+        choices: lambdasOptions,
+      },
+    ]);
+    // get name of the lambda to deploy
+    const res = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'nameOfLambda',
+        message: 'What is the name of the lambda?',
+      },
+    ]);
+    await deployLambda(res.nameOfLambda, response.deployOptions);
   } else if (userCommands.N || userCommands['node-build']) {
     console.log('building node lambda');
     await buildNodeLambdas();
+  } else if (userCommands.v || userCommands['validate-tf']) {
+    console.log('Validating terraform code');
+    await validateTerraformCode();
   } else {
     yargs.showHelp();
   }

package/src/features/deploy.js

@@ -1,65 +0,0 @@
-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,
-};