tfv 4.0.4 → 5.0.0

package/.github/workflows/publish.yml

@@ -4,18 +4,25 @@ on:
   push:
     branches: [main]
 
+permissions:
+  contents: read
+  id-token: write
+
 jobs:
   publish:
     runs-on: ubuntu-latest
+
     steps:
-      - name: checkout
-        uses: actions/checkout@v2
-      - name: setup node
-        uses: actions/setup-node@v1
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
         with:
-          node-version: 12
+          node-version: 18
           registry-url: https://registry.npmjs.org
-      - name: publish
-        run: npm publish --access public
+          cache: 'npm'
+
+      - run: npm ci
+
+      - run: npm publish --access public
         env:
-            NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/README.md

@@ -42,11 +42,28 @@ tfv -h
 tfv <command>
 
 Commands:
-  tfv install <version> [option] Example: tfv install 1.0.11       [aliases: i]
-  tfv list [option]      Example: tfv list                         [aliases: ls]
-  tfv remove <version>   Example: tfv rm 1.0.11                    [aliases: rm]
-  tfv auto-switch        Example: tfv as                           [aliases: as]
-  tfv use <version>      Example: tfv use 1.0.11
+
+  tfv install <version> [option]  Install a terraform version [aliases: i]
+
+  tfv list [option]               List installed or available terraform versions [aliases: ls]
+
+  tfv remove <version>            Remove terraform versions from tfv store [aliases: rm]
+
+  tfv auto-switch                 Auto-detect and switch to your project terraform version [aliases: as]
+
+  tfv use <version>               Switch to a specified terraform version
+
+  tfv apply                       Run terraform apply with optional file-based targets.
+  Accepts all terraform flags after --
+  Example: tfv apply --file main.tf --file network.tf -- -auto-approve -target=<TARGET> -var="env=prod"
+
+  tfv destroy                     Run terraform destroy with optional file-based targets.
+  Accepts all terraform flags after --
+  Example: tfv destroy --file main.tf --file network.tf -- -auto-approve -target=<TARGET> -var="env=prod"
+
+  tfv plan                        Run terraform plan with optional file-based targets.
+  Accepts all terraform flags after --
+  Example: tfv plan --file main.tf --file network.tf -- -auto-approve -target=<TARGET> -var="env=prod"
 
 Options:
   -h, --help     Show help                                             [boolean]
@@ -67,6 +84,9 @@ https://github.com/marcdomain/tfv/assets/25563661/fa44f0f2-2dca-4f22-9fea-c74e4b
       * [list](#list)
       * [remove](#remove)
       * [auto-switch](#auto-switch)
+      * [plan](#plan)
+      * [apply](#apply)
+      * [destroy](#destroy)
 <!--te-->
 
 ### Modules
@@ -162,3 +182,51 @@ Run with alias
 ```sh
   tfv as
 ```
+
+- #### _PLAN_
+
+Run terraform plan with optional file-based targets. Parses terraform files to extract resources, data sources, and modules as targets.
+
+```sh
+  tfv plan --file main.tf
+```
+
+With multiple files
+
+```sh
+  tfv plan --file main.tf --file network.tf
+```
+
+With extra terraform flags
+
+```sh
+  tfv plan --file main.tf -- -var="env=prod" -out=plan.out
+```
+
+- #### _APPLY_
+
+Run terraform apply with optional file-based targets.
+
+```sh
+  tfv apply --file main.tf
+```
+
+With auto-approve
+
+```sh
+  tfv apply --file main.tf -- -auto-approve
+```
+
+- #### _DESTROY_
+
+Run terraform destroy with optional file-based targets.
+
+```sh
+  tfv destroy --file main.tf
+```
+
+With auto-approve
+
+```sh
+  tfv destroy --file main.tf -- -auto-approve
+```

package/lib/commands/apply.js

@@ -0,0 +1,22 @@
+'use strict'
+
+const {runTerraformCommand} = require('../modules/terraform-command');
+
+exports.command = 'apply'
+exports.desc = 'Run terraform apply with optional file-based targets.\n'
+exports.builder = (yargs) => {
+  return yargs
+    .option('file', {
+      alias: 'f',
+      describe: 'Terraform file(s) to extract targets from',
+      type: 'array',
+    })
+    .epilog('Accepts all terraform flags after --\nExample: tfv apply --file main.tf --file network.tf -- -auto-approve -target=<TARGET> -var="env=prod"')
+}
+
+exports.handler = async (argv) => {
+  const {file, _} = argv;
+  // Extra args come after -- in the command line
+  const extraArgs = _.slice(1);
+  await runTerraformCommand('apply', file, extraArgs);
+}

package/lib/commands/destroy.js

@@ -0,0 +1,22 @@
+'use strict'
+
+const {runTerraformCommand} = require('../modules/terraform-command');
+
+exports.command = 'destroy'
+exports.desc = 'Run terraform destroy with optional file-based targets.\n'
+exports.builder = (yargs) => {
+  return yargs
+    .option('file', {
+      alias: 'f',
+      describe: 'Terraform file(s) to extract targets from',
+      type: 'array',
+    })
+    .epilog('Accepts all terraform flags after --\nExample: tfv destroy --file main.tf --file network.tf -- -auto-approve -target=<TARGET> -var="env=prod"')
+}
+
+exports.handler = async (argv) => {
+  const {file, _} = argv;
+  // Extra args come after -- in the command line
+  const extraArgs = _.slice(1);
+  await runTerraformCommand('destroy', file, extraArgs);
+}

package/lib/commands/install.js

@@ -6,13 +6,15 @@ const {install} = require('../modules/install');
 exports.command = 'install <version> [option]'
 exports.aliases = ['i']
 exports.desc = 'Install a terraform version'
-exports.builder = {
-  arch: {
-    describe: 'Specify system architecture',
-    alias: 'a',
-    type: 'string',
-    default: ''
-  }
+exports.builder = (yargs) => {
+  return yargs
+    .option('arch', {
+      alias: 'a',
+      describe: 'Specify system architecture. Defaults is the user system architecture',
+      type: 'string',
+      default: ''
+    })
+    .epilog('Version formats: latest, x.x.x (exact), x^ (latest major), x.x.^ (latest minor)\nExample: tfv install 1.5.7 --arch amd64')
 }
 
 exports.handler = async () => {
@@ -21,3 +23,4 @@ exports.handler = async () => {
 
   await install(version, arch);
 }
+

package/lib/commands/list.js

@@ -5,22 +5,25 @@ const {list} = require('../modules/list');
 
 exports.command = 'list [option]'
 exports.aliases = ['ls']
-exports.desc = 'Example: tfv list --local'
-exports.builder = {
-  local: {
-    alias: 'l',
-    describe: 'List terraform versions you have installed using tfv',
-    type: 'boolean',
-    default: true,
-  },
-  remote: {
-    alias: 'r',
-    describe: 'List all available terraform versions',
-    type: 'boolean',
-  }
+exports.desc = 'List installed or available terraform versions'
+exports.builder = (yargs) => {
+  return yargs
+    .option('local', {
+      alias: 'l',
+      describe: 'List terraform versions you have installed using tfv',
+      type: 'boolean',
+      default: true,
+    })
+    .option('remote', {
+      alias: 'r',
+      describe: 'List all available terraform versions',
+      type: 'boolean',
+    })
+    .epilog('Examples:\n  tfv ls            List locally installed versions\n  tfv ls --remote   List all available remote versions')
 }
 
 exports.handler = async () => {
   const {local, remote} = yargs.argv;
   await list(local, remote);
 }
+

package/lib/commands/plan.js

@@ -0,0 +1,22 @@
+'use strict'
+
+const {runTerraformCommand} = require('../modules/terraform-command');
+
+exports.command = 'plan'
+exports.desc = 'Run terraform plan with optional file-based targets.\n'
+exports.builder = (yargs) => {
+  return yargs
+    .option('file', {
+      alias: 'f',
+      describe: 'Terraform file(s) to extract targets from',
+      type: 'array',
+    })
+    .epilog('Accepts all terraform flags after --\nExample: tfv plan --file main.tf --file network.tf -- -auto-approve -target=<TARGET> -var="env=prod"')
+}
+
+exports.handler = async (argv) => {
+  const {file, _} = argv;
+  // Extra args come after -- in the command line
+  const extraArgs = _.slice(1);
+  await runTerraformCommand('plan', file, extraArgs);
+}

package/lib/commands/remove.js

@@ -5,12 +5,14 @@ const {remove} = require('../modules/remove');
 
 exports.command = 'remove <version>'
 exports.aliases = ['rm']
-exports.desc = 'Remove a list of versions managed by tfv'
-exports.builder = {
-  verbose: {
-    describe: 'Produce detailed output',
-    type: 'boolean',
-  }
+exports.desc = 'Remove terraform versions from tfv store'
+exports.builder = (yargs) => {
+  return yargs
+    .option('verbose', {
+      describe: 'Produce detailed output',
+      type: 'boolean',
+    })
+    .epilog('Example: tfv rm 1.5.7 1.4.6')
 }
 
 exports.handler = async () => {

package/lib/commands/switch.js

@@ -4,12 +4,14 @@ const {autoSwitch} = require('../modules/switch');
 
 exports.command = 'auto-switch'
 exports.aliases = ['as']
-exports.desc = 'Example: tfv as'
-exports.builder = {
-  verbose: {
-    describe: 'Produce detailed output',
-    type: 'boolean'
-  }
+exports.desc = 'Auto-detect and switch to your project terraform version'
+exports.builder = (yargs) => {
+  return yargs
+    .option('verbose', {
+      describe: 'Produce detailed output',
+      type: 'boolean'
+    })
+    .epilog('Reads version from .terraform-version or required_version in .tf files\nExample: tfv auto-switch')
 }
 
 exports.handler = async () => {

package/lib/commands/use.js

@@ -4,12 +4,14 @@ const yargs = require('yargs');
 const {use} = require('../modules/use');
 
 exports.command = 'use <version>'
-exports.desc = 'Example: tfv use 1.0.11'
-exports.builder = {
-  verbose: {
-    describe: 'Produce detailed output',
-    type: 'boolean',
-  }
+exports.desc = 'Switch to a specified terraform version\n'
+exports.builder = (yargs) => {
+  return yargs
+    .option('verbose', {
+      describe: 'Produce detailed output',
+      type: 'boolean',
+    })
+    .epilog('Example: tfv use 1.5.7')
 }
 
 exports.handler = async () => {
@@ -17,3 +19,4 @@ exports.handler = async () => {
 
   await use(version);
 }
+

package/lib/modules/list.js

@@ -6,20 +6,98 @@ const {formatVersions} = require('../utils/formatVersions');
 const {P_END, P_OK} = require('../utils/colors');
 const {checkStore} = require('../utils/store');
 
+const MAX_COLUMNS_PER_TABLE = 6;
+
+/**
+ * Groups versions by their major.minor prefix
+ */
+const groupVersionsByRelease = (versions) => {
+  const groups = {};
+
+  versions.forEach(version => {
+    const parts = version.split('.');
+    if (parts.length >= 2) {
+      const majorMinor = `${parts[0]}.${parts[1]}`;
+      if (!groups[majorMinor]) {
+        groups[majorMinor] = [];
+      }
+      groups[majorMinor].push(version);
+    }
+  });
+
+  return groups;
+};
+
+/**
+ * Displays versions in table format with first version of each release as column header
+ * Breaks into multiple tables if columns exceed MAX_COLUMNS_PER_TABLE
+ */
+const displayVersionTable = (versions) => {
+  const groups = groupVersionsByRelease(versions);
+
+  // Sort release groups by version (descending)
+  const sortedKeys = Object.keys(groups).sort((a, b) => {
+    const [aMajor, aMinor] = a.split('.').map(Number);
+    const [bMajor, bMinor] = b.split('.').map(Number);
+    if (bMajor !== aMajor) return bMajor - aMajor;
+    return bMinor - aMinor;
+  });
+
+  // Sort versions within each group (descending)
+  sortedKeys.forEach(key => {
+    groups[key].sort((a, b) => {
+      const aParts = a.split('.').map(n => parseInt(n) || 0);
+      const bParts = b.split('.').map(n => parseInt(n) || 0);
+      for (let i = 0; i < Math.max(aParts.length, bParts.length); i++) {
+        const aVal = aParts[i] || 0;
+        const bVal = bParts[i] || 0;
+        if (bVal !== aVal) return bVal - aVal;
+      }
+      return 0;
+    });
+  });
+
+  // Split into chunks of MAX_COLUMNS_PER_TABLE
+  const chunks = [];
+  for (let i = 0; i < sortedKeys.length; i += MAX_COLUMNS_PER_TABLE) {
+    chunks.push(sortedKeys.slice(i, i + MAX_COLUMNS_PER_TABLE));
+  }
+
+  // Display each chunk as a separate table
+  chunks.forEach((chunkKeys, chunkIndex) => {
+    // Find max rows needed for this chunk
+    const maxRows = Math.max(...chunkKeys.map(key => groups[key].length));
+
+    // Build table data
+    const tableData = [];
+    for (let row = 0; row < maxRows; row++) {
+      const rowObj = {};
+      chunkKeys.forEach(key => {
+        // Use major.minor.x format as header (e.g., "1.5.x")
+        const header = `${key}.x`;
+        const value = groups[key][row] || '';
+        rowObj[header] = value;
+      });
+      tableData.push(rowObj);
+    }
+
+    if (chunks.length > 1) {
+      console.log(`\n${P_OK}Table ${chunkIndex + 1} of ${chunks.length}${P_END}`);
+    }
+    console.table(tableData);
+  });
+};
+
 exports.list = async (local, remote) => {
   try {
     let versions;
 
-    const result = (message, v) => {
-      console.log(`${P_OK}${message}${P_END}` + '\n');
-      console.log(v.join('\n'));
-    }
-
     if (remote) {
       const data = await fetchAllVersions();
       versions = formatVersions(data);
 
-      return result('List of all available terraform versions', versions)
+      console.log(`${P_OK}List of all available terraform versions${P_END}\n`);
+      return displayVersionTable(versions);
     }
 
     if (local) {

package/lib/modules/terraform-command.js

@@ -0,0 +1,162 @@
+const fs = require('fs');
+const {spawn} = require('child_process');
+const {P_END, P_OK, P_ERROR, P_WARN, P_INFO} = require('../utils/colors');
+
+/**
+ * Removes comments from Terraform content
+ * Handles: # comments, // comments, and block comments
+ */
+const removeComments = (content) => {
+  // Remove block comments /* */
+  content = content.replace(/\/\*[\s\S]*?\*\//g, '');
+
+  // Remove single line comments (# and //)
+  const lines = content.split('\n');
+  const cleanedLines = lines.map(line => {
+    // Find position of # or // that's not inside a string
+    let inString = false;
+    let stringChar = '';
+    let commentStart = -1;
+
+    for (let i = 0; i < line.length; i++) {
+      const char = line[i];
+      const nextChar = line[i + 1];
+
+      if (!inString && (char === '"' || char === "'")) {
+        inString = true;
+        stringChar = char;
+      } else if (inString && char === stringChar && line[i - 1] !== '\\') {
+        inString = false;
+      } else if (!inString) {
+        if (char === '#' || (char === '/' && nextChar === '/')) {
+          commentStart = i;
+          break;
+        }
+      }
+    }
+
+    if (commentStart !== -1) {
+      return line.substring(0, commentStart);
+    }
+    return line;
+  });
+
+  return cleanedLines.join('\n');
+};
+
+/**
+ * Extracts terraform targets from file content
+ * Returns array of target strings like "aws_instance.example", "module.vpc", etc.
+ */
+const extractTargets = (content) => {
+  const targets = [];
+
+  // Remove comments first
+  const cleanContent = removeComments(content);
+
+  // Pattern for resource blocks: resource "type" "name"
+  const resourcePattern = /resource\s+"([^"]+)"\s+"([^"]+)"/g;
+  let match;
+  while ((match = resourcePattern.exec(cleanContent)) !== null) {
+    targets.push(`${match[1]}.${match[2]}`);
+  }
+
+  // Pattern for data blocks: data "type" "name"
+  const dataPattern = /data\s+"([^"]+)"\s+"([^"]+)"/g;
+  while ((match = dataPattern.exec(cleanContent)) !== null) {
+    targets.push(`data.${match[1]}.${match[2]}`);
+  }
+
+  // Pattern for module blocks: module "name"
+  const modulePattern = /module\s+"([^"]+)"/g;
+  while ((match = modulePattern.exec(cleanContent)) !== null) {
+    targets.push(`module.${match[1]}`);
+  }
+
+  return targets;
+};
+
+/**
+ * Extracts targets from one or more terraform files
+ */
+const extractTargetsFromFiles = (files) => {
+  const allTargets = [];
+  const fileList = Array.isArray(files) ? files : [files];
+
+  fileList.forEach(filename => {
+    if (!fs.existsSync(filename)) {
+      console.log(`${P_WARN}Warning: File '${filename}' not found, skipping${P_END}`);
+      return;
+    }
+
+    const content = fs.readFileSync(filename, 'utf8');
+    const targets = extractTargets(content);
+
+    if (targets.length > 0) {
+      console.log(`${P_INFO}Found ${targets.length} target(s) in '${filename}':${P_END}`);
+      targets.forEach(target => {
+        console.log(`  - ${target}`);
+        if (!allTargets.includes(target)) {
+          allTargets.push(target);
+        }
+      });
+    } else {
+      console.log(`${P_WARN}No targets found in '${filename}'${P_END}`);
+    }
+  });
+
+  return allTargets;
+};
+
+/**
+ * Runs a terraform command (plan, apply, destroy) with optional file-based targets
+ * @param {string} command - The terraform command (plan, apply, destroy)
+ * @param {string|string[]} files - Optional file(s) to extract targets from
+ * @param {string[]} extraArgs - Additional arguments to pass to terraform
+ */
+exports.runTerraformCommand = async (command, files, extraArgs = []) => {
+  try {
+    const args = [command];
+
+    // Extract targets from files if provided
+    if (files && (Array.isArray(files) ? files.length > 0 : true)) {
+      console.log(`${P_OK}Extracting targets from file(s)...${P_END}\n`);
+      const targets = extractTargetsFromFiles(files);
+
+      if (targets.length > 0) {
+        console.log(`\n${P_OK}Total unique targets: ${targets.length}${P_END}\n`);
+        targets.forEach(target => {
+          args.push('-target', target);
+        });
+      } else {
+        console.log(`${P_WARN}No targets extracted from files. Running without file-based targets.${P_END}\n`);
+      }
+    }
+
+    // Add any extra arguments passed through
+    if (extraArgs && extraArgs.length > 0) {
+      args.push(...extraArgs);
+    }
+
+    console.log(`${P_OK}Running: terraform ${args.join(' ')}${P_END}\n`);
+
+    // Execute terraform command
+    const tf = spawn('terraform', args, {
+      stdio: 'inherit',
+      cwd: process.cwd()
+    });
+
+    tf.on('error', (err) => {
+      console.log(`${P_ERROR}Error executing terraform: ${err.message}${P_END}`);
+      process.exit(1);
+    });
+
+    tf.on('close', (code) => {
+      process.exit(code);
+    });
+
+  } catch (err) {
+    console.log(`${P_ERROR}Error: ${err.message}${P_END}`);
+    process.exit(1);
+  }
+};

package/package.json

@@ -1,6 +1,10 @@
 {
   "name": "tfv",
-  "version": "4.0.4",
+  "version": "5.0.0",
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
   "description": "Terraform version manager",
   "main": "index.js",
   "directories": {