terraguardian-cli 0.2.1 → 0.2.3

package/README.md

@@ -46,3 +46,69 @@ 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.
+
+## Build Configuration
+
+### Default Build Settings
+
+The CLI uses esbuild to bundle Node.js Lambda functions with the following default settings:
+- **Target**: Node.js 22 (`node22`)
+- **Platform**: Node
+- **Bundle**: Enabled
+- **Minify**: Enabled
+
+### Custom esbuild Configuration
+
+You can customize the build process by creating an `esbuild.config.js` file in your project root. The CLI will automatically detect and use your custom configuration.
+
+**Example `esbuild.config.js`:**
+
+```javascript
+module.exports = {
+  // Bundle all dependencies (default: true)
+  bundle: true,
+
+  // Target platform (default: 'node')
+  platform: 'node',
+
+  // Target Node.js version (default: 'node22')
+  target: 'node22',
+
+  // Minify the output (default: true)
+  minify: true,
+
+  // External dependencies - these will not be bundled
+  external: [
+    '@aws-sdk/*',  // Exclude all AWS SDK v3 packages
+  ],
+
+  // Custom esbuild flags
+  customFlags: [
+    '--sourcemap',  // Enable source maps
+    '--keep-names', // Preserve function names
+  ],
+};
+```
+
+### Configuration Options
+
+- **bundle** (boolean): Bundle all dependencies into a single file
+- **platform** (string): Target platform (`'node'`, `'browser'`, etc.)
+- **target** (string): Node.js version target (`'node18'`, `'node20'`, `'node22'`, etc.)
+- **minify** (boolean): Minify the output for smaller bundle size
+- **external** (array): List of packages to exclude from bundling (useful for AWS SDK v3)
+- **customFlags** (array): Additional esbuild CLI flags
+
+### Environment Variables
+
+You can also override configuration using environment variables:
+
+- `NODE_TARGET`: Node.js version (default: `node22`)
+- `ESBUILD_CONFIG_FILE_PATH`: Path to custom config file (default: `esbuild.config.js`)
+- `NODE_BUILD_FILE_NAME`: Output filename (default: `index.js`)
+- `NODE_ENTRY_POINT`: Entry point filename (default: `index.js`)
+
+**Example:**
+```bash
+NODE_TARGET=node20 tg-cli --node-build
+```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "terraguardian-cli",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "CLI that helps with projects that are built with terraform and helps with deployments of lambda src code",
   "main": "index.js",
   "bin": {
@@ -29,6 +29,7 @@
   "dependencies": {
     "archiver": "^7.0.0",
     "chalk": "^4.0.0",
+    "glob": "^10.3.10",
     "inquirer": "^8.2.6",
     "yargs": "^17.7.2"
   },
@@ -42,4 +43,4 @@
     "jest": "^29.7.0",
     "prettier": "^3.2.5"
   }
-}
+}

package/src/common/constants.js

@@ -3,6 +3,8 @@ 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_TARGET = process.env.NODE_TARGET || 'node22';
+const ESBUILD_CONFIG_FILE_PATH = process.env.ESBUILD_CONFIG_FILE_PATH || 'esbuild.config.js';
 
 const NODE_RUNTIME_TF_VAR = 'node_runtime';
 const GO_RUNTIME_TF_VAR = 'go_runtime';
@@ -11,6 +13,7 @@ const GO_ENTRY_POINT = process.env.GO_ENTRY_POINT || 'main.go';
 
 module.exports = {
   DEFAULT_WEBPACK_MODE,
+  ESBUILD_CONFIG_FILE_PATH,
   GO_ENTRY_POINT,
   GO_RUNTIME_TF_VAR,
   LAMBDA_BUILD_DIR,
@@ -18,5 +21,6 @@ module.exports = {
   NODE_ENTRY_POINT,
   NODE_LIBARY_TYPE,
   NODE_RUNTIME_TF_VAR,
+  NODE_TARGET,
   WEBPACK_FILE_PATH,
 };

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

@@ -1,25 +1,69 @@
 const chalk = require('chalk');
+const path = require('path');
 const { executeCommand } = require('../../common/helpers');
 const FileHandler = require('../../fs-utils/FileHandler');
 const { findEntryPoints, getNormalizedLambdaNames } = require('./helpers');
 
 const {
+  ESBUILD_CONFIG_FILE_PATH,
   LAMBDA_BUILD_DIR,
   NODE_BUILD_FILE_NAME,
   NODE_RUNTIME_TF_VAR,
+  NODE_TARGET,
 } = require('../../common/constants');
 
+// Load custom esbuild configuration if it exists
+function loadCustomEsbuildConfig() {
+  const configPath = path.resolve(process.cwd(), ESBUILD_CONFIG_FILE_PATH);
+
+  if (FileHandler.doesFileExist(configPath)) {
+    try {
+      console.log(chalk.blue(`Using custom esbuild config from ${ESBUILD_CONFIG_FILE_PATH}`));
+      return require(configPath); // eslint-disable-line import/no-dynamic-require, global-require
+    } catch (error) {
+      console.log(chalk.yellow(`Warning: Failed to load custom esbuild config: ${error.message}`));
+      console.log(chalk.yellow('Falling back to default configuration'));
+      return null;
+    }
+  }
+  return null;
+}
+
+// Get default esbuild configuration
+function getDefaultEsbuildConfig() {
+  return {
+    bundle: true,
+    platform: 'node',
+    target: NODE_TARGET,
+    minify: true,
+  };
+}
+
 // 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
-    '--minify', // Optional: minify the output (you can disable if not needed)
-  ];
+  const customConfig = loadCustomEsbuildConfig();
+  const config = customConfig || getDefaultEsbuildConfig();
+
+  const buildCommand = ['npx esbuild', lambdaPath];
+
+  // Add configuration flags
+  if (config.bundle !== false) buildCommand.push('--bundle');
+  if (config.platform) buildCommand.push(`--platform=${config.platform}`);
+  if (config.target) buildCommand.push(`--target=${config.target}`);
+  if (config.minify) buildCommand.push('--minify');
+
+  // Add output file
+  buildCommand.push(`--outfile=${buildOutputDir}/${NODE_BUILD_FILE_NAME}`);
+
+  // Add external dependencies if specified
+  if (config.external && Array.isArray(config.external)) {
+    config.external.forEach((ext) => buildCommand.push(`--external:${ext}`));
+  }
+
+  // Add any custom flags
+  if (config.customFlags && Array.isArray(config.customFlags)) {
+    buildCommand.push(...config.customFlags);
+  }
 
   return buildCommand.join(' ');
 }
@@ -48,9 +92,10 @@ async function buildNodeLambdas() {
     }
   }
 
-  lambdaPaths.forEach((lambdaPath, index) => {
-    buildNodeLambda(normalizedLambdaNames[index], lambdaPath);
-  });
+  // Build all lambdas and await each one
+  for (let index = 0; index < lambdaPaths.length; index++) {
+    await buildNodeLambda(normalizedLambdaNames[index], lambdaPaths[index]);
+  }
 }
 
 module.exports = {

package/src/features/build/zip.js

@@ -97,4 +97,5 @@ async function zipAndMoveFolders(sourceFolder, destinationFolder) {
 
 module.exports = {
   zipAndMoveFolders,
+  zipFolder,
 };

package/src/features/deploy/lambda.js

@@ -1,8 +1,71 @@
+const { execSync } = require('child_process');
+const inquirer = require('inquirer');
 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`;
+function getGitRepoName() {
+  const repoPath = execSync('git rev-parse --show-toplevel').toString().trim();
+  return repoPath.split('/').pop();
+}
+
+function getGitBranch() {
+  return execSync('git rev-parse --abbrev-ref HEAD').toString().trim();
+}
+
+function isTagBranch() {
+  const result = execSync('git describe --exact-match --tags HEAD || true').toString().trim();
+  return result.length > 0;
+}
+
+function normalizeProjectName(name) {
+  return name.toLowerCase();
+}
+
+function shortenProjectName(name) {
+  return name.replace(/[-_]/g, '').substring(0, 10);
+}
+
+function cleanBranch(branch) {
+  return branch.toLowerCase().replace(/[^a-zA-Z0-9]/g, '');
+}
+
+function getEnvironment(branch) {
+  if (branch === 'main' || branch === 'master') {
+    return 'test';
+  }
+  if (isTagBranch()) {
+    return 'prod';
+  }
+  return cleanBranch(branch);
+}
+
+// Deploys the zip file using the lambda key (e.g., 'lambda_get_products')
+async function deployLambda(lambdaKey, zipFileName) {
+  const projectName = getGitRepoName();
+  const branchName = getGitBranch();
+  const shortName = shortenProjectName(normalizeProjectName(projectName));
+  const environment = getEnvironment(branchName);
+  const formattedKey = lambdaKey.replace(/_/g, '-');
+
+  const fullLambdaName = `${shortName}-${environment}-${formattedKey}`;
+
+  console.log(`\nPreparing to deploy: ${fullLambdaName}`);
+  const { confirmDeploy } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'confirmDeploy',
+      message: 'Are you sure you want to deploy this Lambda?',
+      default: false,
+    },
+  ]);
+
+  if (!confirmDeploy) {
+    console.log('Deployment cancelled.');
+    return undefined;
+  }
+
+  const deployCommand = `aws lambda update-function-code --function-name ${fullLambdaName} --zip-file fileb://dist/${zipFileName}.zip 1> /dev/null`;
+
+  console.log(`Deploying: ${fullLambdaName}...`);
   return executeCommand(deployCommand);
 }
 

package/src/features/scaffold/helpers/extractBranchPrefix.js

@@ -0,0 +1,19 @@
+const fs = require('fs');
+const path = require('path');
+
+function extractBranchPrefix(tfDir) {
+  const tfFiles = fs.readdirSync(tfDir).filter((file) => file.endsWith('.tf'));
+
+  // eslint-disable-next-line no-restricted-syntax
+  for (const file of tfFiles) {
+    const content = fs.readFileSync(path.join(tfDir, file), 'utf-8');
+    const match = content.match(/\s*branch_prefix\s*=\s*"(.*?)"/);
+    if (match && match[1]) {
+      return match[1];
+    }
+  }
+
+  throw new Error('Could not find branch_prefix in any .tf file.');
+}
+
+module.exports = extractBranchPrefix;

package/src/features/scaffold/helpers/file.js

@@ -0,0 +1,11 @@
+// helpers/file.js
+
+const fs = require('fs');
+const path = require('path');
+
+function writeFile(filePath, content) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, content);
+}
+
+module.exports = { writeFile };

package/src/features/scaffold/helpers/format.js

@@ -0,0 +1,17 @@
+// helpers/format.js
+
+function toSnakeCase(name) {
+  return name.trim().toLowerCase().replace(/[-\s]/g, '_');
+}
+
+function toPascalCase(name) {
+  return name
+    .replace(/[-_]+/g, ' ')
+    .replace(/\s(.)/g, (_, group1) => group1.toUpperCase())
+    .replace(/^(.)/, (_, group1) => group1.toUpperCase());
+}
+
+module.exports = {
+  toSnakeCase,
+  toPascalCase,
+};

package/src/features/scaffold/helpers/scanServiceResources.js

@@ -0,0 +1,29 @@
+const fs = require('fs');
+const path = require('path');
+const glob = require('glob');
+
+async function scanServiceResources(serviceKey, serviceConfig, modulesDir = 'modules') {
+  const basePath = path.join(process.cwd(), modulesDir, serviceKey);
+
+  if (!fs.existsSync(basePath)) {
+    return []; // No such module
+  }
+
+  const files = glob.sync(serviceConfig.scanPattern, {
+    cwd: basePath,
+    absolute: true,
+  });
+
+  const resourceNames = new Set();
+
+  // eslint-disable-next-line no-restricted-syntax
+  for (const file of files) {
+    const contents = fs.readFileSync(file, 'utf8');
+    const names = serviceConfig.extractResourceNames(contents);
+    names.forEach((n) => resourceNames.add(n));
+  }
+
+  return [...resourceNames];
+}
+
+module.exports = { scanServiceResources };

package/src/features/scaffold/index.js

@@ -0,0 +1,10 @@
+// scaffold.js
+
+const Scaffolder = require('./Scaffolder');
+
+async function scaffold() {
+  const scaffolder = new Scaffolder();
+  await scaffolder.promptAndRun();
+}
+
+module.exports = { scaffold };

package/src/features/scaffold/scaffolder.js

@@ -0,0 +1,49 @@
+// Scaffolder.js
+
+const path = require('path');
+const inquirer = require('inquirer');
+const chalk = require('chalk');
+
+const LambdaScaffolder = require('./services/Lambda');
+const extractBranchPrefix = require('./helpers/extractBranchPrefix');
+
+const SERVICES = {
+  lambda: LambdaScaffolder,
+};
+
+class Scaffolder {
+  // eslint-disable-next-line class-methods-use-this
+  async promptAndRun() {
+    const { service } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'service',
+        message: 'What service do you want to scaffold?',
+        choices: Object.keys(SERVICES),
+      },
+    ]);
+
+    const { name } = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'name',
+        message: `Enter a name for the ${service} (e.g., get-user):`,
+        validate: (input) => !!input.trim() || 'Name cannot be empty.',
+      },
+    ]);
+
+    let branchPrefix = 'YOUR_PREFIX_HERE';
+    const terraformProjectPath = path.join(process.cwd(), 'modules');
+    try {
+      branchPrefix = extractBranchPrefix(terraformProjectPath);
+    } catch (e) {
+      console.warn(chalk.yellow('Warning:'), e.message);
+    }
+
+    const ServiceScaffolder = SERVICES[service];
+    const scaffolder = new ServiceScaffolder(name, branchPrefix);
+    await scaffolder.run();
+  }
+}
+
+module.exports = Scaffolder;

package/src/features/scaffold/services/Lambda.js

@@ -0,0 +1,83 @@
+const fs = require('fs');
+const path = require('path');
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const { toSnakeCase } = require('../helpers/format');
+const { writeFile } = require('../helpers/file');
+const mainTfTemplate = require('../templates/lambda/main.tf');
+const iamTfTemplate = require('../templates/lambda/iam.tf');
+const handlerTemplate = require('../templates/lambda/src.js');
+
+const ServiceRegistry = require('./ServiceRegistry');
+const { scanServiceResources } = require('../helpers/scanServiceResources');
+
+class LambdaScaffolder {
+  constructor(name, branchPrefix) {
+    this.originalName = name; // e.g., get-user
+    this.snakeName = toSnakeCase(name); // e.g., get_user
+    this.folderName = `lambda_${this.snakeName}`; // e.g., lambda_get_user
+    this.basePath = path.join(process.cwd(), 'modules/lambda', this.folderName);
+    this.branchPrefix = branchPrefix;
+    this.shortName = `l${name.split('-').join('')}`;
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  async promptResourceConnections() {
+    const choices = [];
+
+    // eslint-disable-next-line no-restricted-syntax
+    for (const [serviceKey, config] of Object.entries(ServiceRegistry)) {
+      const resources = await scanServiceResources(serviceKey, config);
+      if (resources.length > 0) {
+        choices.push(new inquirer.Separator(`--- ${config.displayName} ---`));
+        // Sort resources alphabetically within each service group
+        const sortedResources = resources.sort((a, b) => a.localeCompare(b));
+        sortedResources.forEach((r) => choices.push({
+          name: `${config.displayName}: ${r}`,
+          value: { serviceKey, resourceName: r },
+        }));
+      }
+    }
+
+    if (choices.length === 0) {
+      console.log(chalk.yellow('⚠️  No connectable resources found.'));
+      return [];
+    }
+
+    const { selectedResources } = await inquirer.prompt([
+      {
+        type: 'checkbox',
+        name: 'selectedResources',
+        message: 'Which resources should this Lambda connect to?',
+        choices,
+      },
+    ]);
+
+    return selectedResources;
+  }
+
+  async run() {
+    if (fs.existsSync(this.basePath)) {
+      console.log(chalk.red(`❌ Folder already exists: ${this.basePath}`));
+      return;
+    }
+
+    console.log(chalk.blue(`📦 Creating Lambda: ${this.folderName}`));
+
+    // ✅ Create base folders (recursive)
+    fs.mkdirSync(path.join(this.basePath, 'src'), { recursive: true });
+
+    const connectedResources = await this.promptResourceConnections();
+
+    writeFile(path.join(this.basePath, 'main.tf'), mainTfTemplate(this));
+    writeFile(
+      path.join(this.basePath, 'iam.tf'),
+      iamTfTemplate(this, connectedResources),
+    );
+    writeFile(path.join(this.basePath, 'src', 'index.js'), handlerTemplate(this));
+
+    console.log(chalk.green(`✅ Lambda scaffolded at ${this.basePath}`));
+  }
+}
+
+module.exports = LambdaScaffolder;

package/src/features/scaffold/services/ServiceRegistry.js

@@ -0,0 +1,50 @@
+module.exports = {
+  dynamodb: {
+    displayName: 'DynamoDB',
+    scanPattern: '**/*.tf', // Scan for any .tf file
+    extractResourceNames: (fileContents) => {
+      const regex = /resource\s+"aws_dynamodb_table"\s+"([^"]+)"/g;
+      const matches = [...fileContents.matchAll(regex)];
+      return matches.map((m) => m[1]); // e.g., ["users_table", "orders_table"]
+    },
+    getPolicy: (resourceName) => `
+      {
+        "Action": [
+          "dynamodb:GetItem",
+          "dynamodb:PutItem",
+          "dynamodb:UpdateItem",
+          "dynamodb:DeleteItem",
+          "dynamodb:Query",
+          "dynamodb:Scan"
+        ],
+        "Effect": "Allow",
+        "Resource": "\${aws_dynamodb_table.${resourceName}.arn}"
+      }
+    `,
+  },
+  s3: {
+    displayName: 'S3 Bucket',
+    scanPattern: '**/*.tf',
+    extractResourceNames: (fileContents) => {
+      const regex = /resource\s+"aws_s3_bucket"\s+"([^"]+)"/g;
+      const matches = [...fileContents.matchAll(regex)];
+      return matches.map((m) => m[1]);
+    },
+    getPolicy: (resourceName) => `
+      {
+        "Action": [
+          "s3:GetObject",
+          "s3:PutObject",
+          "s3:DeleteObject",
+          "s3:ListBucket"
+        ],
+        "Effect": "Allow",
+        "Resource": [
+          "\${aws_s3_bucket.${resourceName}.arn}",
+          "\${aws_s3_bucket.${resourceName}.arn}/*"
+        ]
+      }
+    `,
+  },
+  // Add more services (SQS, API Gateway, etc.) later
+};

package/src/features/scaffold/templates/lambda/iam.tf.js

@@ -0,0 +1,55 @@
+const ServiceRegistry = require('../../services/ServiceRegistry');
+
+module.exports = ({ originalName, snakeName }, connectedResources = []) => `
+resource "aws_iam_role" "lambda_${snakeName}" {
+  name = "\${local.branch_prefix}-lambda-${originalName}-role"
+
+  assume_role_policy = jsonencode({
+    Version = "2012-10-17"
+    Statement = [
+      {
+        Action = "sts:AssumeRole"
+        Principal = {
+          Service = "lambda.amazonaws.com"
+        }
+        Effect = "Allow"
+        Sid    = ""
+      },
+    ]
+  })
+
+  tags = local.tags
+}
+
+resource "aws_iam_role_policy_attachment" "lambda_${snakeName}_common_permissions" {
+  role       = aws_iam_role.lambda_${snakeName}.name
+  policy_arn = aws_iam_policy.policy_lambda_common_permissions.arn
+}
+
+resource "aws_iam_role_policy_attachment" "lambda_${snakeName}_basic_execution" {
+  role       = aws_iam_role.lambda_${snakeName}.name
+  policy_arn = "arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole"
+}
+
+${connectedResources.length > 0
+    ? `
+resource "aws_iam_policy" "lambda_${snakeName}_connected_resources" {
+  name   = "\${local.branch_prefix}-lambda-${originalName}-resources"
+  policy = jsonencode({
+    Version = "2012-10-17",
+    Statement = [
+      ${connectedResources
+    .map((r) => ServiceRegistry[r.serviceKey].getPolicy(r.resourceName))
+    .join(',\n')}
+    ]
+  })
+}
+
+resource "aws_iam_role_policy_attachment" "lambda_${snakeName}_connected_resources_attach" {
+  role       = aws_iam_role.lambda_${snakeName}.name
+  policy_arn = aws_iam_policy.lambda_${snakeName}_connected_resources.arn
+}
+  `.trim()
+    : ''
+}
+`.trim();

package/src/features/scaffold/templates/lambda/main.tf.js

@@ -0,0 +1,26 @@
+module.exports = ({ originalName, snakeName, shortName }) => `
+locals {
+  ${shortName}               = "lambda-${originalName}"
+  ${shortName}_function_name = "\${local.branch_prefix}-\${local.${shortName}}"
+  path_to_${shortName}_zip   = local.zip_info.lambda_${snakeName}.path
+}
+
+resource "aws_lambda_function" "lambda_${snakeName}" {
+  function_name    = local.${shortName}_function_name
+  role             = aws_iam_role.lambda_${snakeName}.arn
+  handler          = var.node_handler
+  runtime          = var.node_runtime
+  filename         = local.path_to_${shortName}_zip
+  source_code_hash = filebase64sha256(local.path_to_${shortName}_zip)
+
+  environment {
+    variables = {
+      ENVIRONMENT = var.branch == "prod" ? "prod" : "dev"
+    }
+  }
+}
+
+resource "aws_cloudwatch_log_group" "lambda_${snakeName}_log_group" {
+  name              = "/aws/lambda/\${local.${shortName}_function_name}"
+  retention_in_days = 1
+}`;

package/src/features/scaffold/templates/lambda/src.js

@@ -0,0 +1,10 @@
+module.exports = ({ originalName }) => `
+exports.handler = async (event) => {
+  console.log("Received event:", JSON.stringify(event, null, 2));
+
+  return {
+    statusCode: 200,
+    body: JSON.stringify({ message: "Hello from ${originalName}!" }),
+  };
+};
+`.trim();

package/src/index.js

@@ -6,19 +6,16 @@ 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 { zipFolder, zipAndMoveFolders } = require('./features/build/zip');
+const { buildNodeLambdas, buildNodeLambda } = require('./features/build/node-build');
 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 { findEntryPoints, getNormalizedLambdaNames } = require('./features/build/helpers');
+const { NODE_RUNTIME_TF_VAR } = require('./common/constants');
+const { scaffold } = require('./features/scaffold');
 
 const usage = chalk.keyword('violet')('\nUsage: tg-cli [<command> [, options]]');
+
 const argv = yargs
   .version('1.0.0')
   .usage(usage)
@@ -34,61 +31,90 @@ const argv = yargs
   })
   .option('d', {
     alias: 'deploy',
-    describe: 'deploy a lambda',
+    describe: 'Deploy a Lambda',
     type: 'boolean',
   })
   .option('v', {
     alias: 'validate-tf',
-    describe: 'validate terraform code even if it is nested',
+    describe: 'Validate Terraform code even if nested',
+    type: 'boolean',
+  })
+  .option('s', {
+    alias: 'scaffold',
+    describe: 'Scaffold boilerplate code for a service',
     type: 'boolean',
   })
   .help(true)
   .alias('h', 'help').argv;
 
 async function executeUserCommand(userCommands) {
-  if (userCommands.z || userCommands.zip) {
-    // 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');
-    // 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();
+  try {
+    if (userCommands.z || userCommands.zip) {
+      console.log(chalk.blue('🔄 Zipping folders...'));
+      const zipDetails = await zipAndMoveFolders('build', 'dist');
+
+      const resultFilePath = path.join(process.cwd(), 'zip-details.json');
+      await fs.promises.writeFile(resultFilePath, JSON.stringify(zipDetails, null, 2), 'utf-8');
+      console.log(chalk.green(`✅ Zipping complete. Details saved to ${resultFilePath}`));
+    } else if (userCommands.d || userCommands.deploy) {
+      console.log(chalk.blue('🚀 Deploying Lambda...'));
+      const lambdaPaths = findEntryPoints(NODE_RUNTIME_TF_VAR);
+      const normalizedLambdaNames = getNormalizedLambdaNames(lambdaPaths);
+
+      // Create a map of lambda names to their paths and sort alphabetically
+      const lambdaMap = normalizedLambdaNames.map((name, index) => ({
+        name,
+        path: lambdaPaths[index],
+      })).sort((a, b) => a.name.localeCompare(b.name));
+
+      const sortedNames = lambdaMap.map((item) => item.name);
+
+      const { deployOptions } = await inquirer.prompt([
+        {
+          type: 'list',
+          name: 'deployOptions',
+          message: 'Which Lambda would you like to deploy?',
+          choices: sortedNames,
+        },
+      ]);
+
+      const selectedLambda = lambdaMap.find((item) => item.name === deployOptions);
+      const lambdaPath = selectedLambda.path;
+
+      // Build the selected Lambda
+      const builtFile = await buildNodeLambda(deployOptions, lambdaPath);
+
+      // Ensure dist folder exists
+      const distDir = path.join(process.cwd(), 'dist');
+      if (!fs.existsSync(distDir)) {
+        fs.mkdirSync(distDir);
+      }
+
+      const zipFilePath = `dist/${deployOptions}.zip`;
+      if (fs.existsSync(zipFilePath)) {
+        fs.unlinkSync(zipFilePath);
+      }
+
+      await zipFolder(path.dirname(builtFile), zipFilePath);
+      await deployLambda(deployOptions, deployOptions);
+
+      console.log(chalk.green(`✅ Lambda ${deployOptions} deployed successfully`));
+    } else if (userCommands.N || userCommands['node-build']) {
+      console.log(chalk.blue('🔨 Building Node Lambdas...'));
+      await buildNodeLambdas();
+    } else if (userCommands.s || userCommands.scaffold) {
+      console.log(chalk.blue('📦 Scaffolding new service...'));
+      await scaffold();
+    } else if (userCommands.v || userCommands['validate-tf']) {
+      console.log(chalk.blue('📝 Validating Terraform code...'));
+      await validateTerraformCode();
+    } else {
+      yargs.showHelp();
+    }
+  } catch (err) {
+    console.error(chalk.red(`❌ Error: ${err.message}`));
+    console.error(err.stack);
+    process.exit(1);
   }
 }