@dotenvx/dotenvx 0.35.1 → 0.36.1

package/README.md

@@ -732,6 +732,7 @@ $ dotenvx hub push
 * [`dotenvx get`](https://dotenvx.com/docs/features/get) – return a single environment variable
 * [`dotenvx set`](https://dotenvx.com/docs/features/set) – set a single environment variable
 * [`dotenvx ls`](https://dotenvx.com/docs/features/ls) – list all .env files in your repo
+* [`dotenvx status`](https://dotenvx.com/docs/features/status) – compare your .env* content(s) to your .env.vault decrypted content(s)
 * [`dotenvx settings`](https://dotenvx.com/docs/features/settings) – print current dotenvx settings
 
  

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.35.1",
+  "version": "0.36.1",
   "name": "@dotenvx/dotenvx",
   "description": "a better dotenv–from the creator of `dotenv`",
   "author": "@motdotla",
@@ -32,6 +32,7 @@
     "chalk": "^4.1.2",
     "commander": "^11.1.0",
     "conf": "^10.2.0",
+    "diff": "^5.2.0",
     "dotenv": "^16.4.5",
     "dotenv-expand": "^11.0.6",
     "execa": "^5.1.1",

package/src/cli/actions/decrypt.js

@@ -1,94 +1,70 @@
 const fs = require('fs')
-const dotenv = require('dotenv')
 
 const logger = require('./../../shared/logger')
 const createSpinner = require('./../../shared/createSpinner')
-
-const libDecrypt = require('./../../lib/helpers/decrypt')
 const sleep = require('./../../lib/helpers/sleep')
-const resolvePath = require('./../../lib/helpers/resolvePath')
 
-const spinner = createSpinner('decrypting')
+const Decrypt = require('./../../lib/services/decrypt')
 
-// constants
-const ENCODING = 'utf8'
+const spinner = createSpinner('decrypting')
 
-async function decrypt () {
+async function decrypt (directory) {
   spinner.start()
   await sleep(500) // better dx
 
+  logger.debug(`directory: ${directory}`)
+
   const options = this.opts()
   logger.debug(`options: ${JSON.stringify(options)}`)
 
-  const vaultFilepath = resolvePath('.env.vault')
-  const keysFilepath = resolvePath('.env.keys')
-  const changedEnvFilenames = new Set()
-  const unchangedEnvFilenames = new Set()
-
-  // logger.verbose(`checking for .env.vault`)
-  if (!fs.existsSync(vaultFilepath)) {
-    spinner.fail(`.env.vault file missing: ${vaultFilepath}`)
-    logger.help('? generate one with [dotenvx encrypt]')
-    process.exit(1)
-  }
-
-  // logger.verbose(`checking for .env.keys`)
-  if (!fs.existsSync(keysFilepath)) {
-    spinner.fail(`.env.keys file missing: ${keysFilepath}`)
-    logger.help('? a .env.keys file must be present in order to decrypt your .env.vault contents to .env file(s)')
-    process.exit(1)
-  }
-
-  const dotenvKeys = dotenv.configDotenv({ path: keysFilepath }).parsed
-  const dotenvVault = dotenv.configDotenv({ path: vaultFilepath }).parsed
-
-  Object.entries(dotenvKeys).forEach(([dotenvKey, value]) => {
-    // determine environment
-    const environment = dotenvKey.replace('DOTENV_KEY_', '').toLowerCase()
-    // determine corresponding vault key
-    const vaultKey = `DOTENV_VAULT_${environment.toUpperCase()}`
-
-    // attempt to find ciphertext
-    const ciphertext = dotenvVault[vaultKey]
-
-    // give warning if not found
-    if (ciphertext && ciphertext.length >= 1) {
-      // Decrypt
-      const decrypted = libDecrypt(ciphertext, value.trim())
-
-      // envFilename
-      // replace _ with . to support filenames like .env.development.local
-      let envFilename = `.env.${environment.replace('_', '.')}`
-      if (environment === 'development') {
-        envFilename = '.env'
-      }
-
-      // check if exists
-      if (fs.existsSync(envFilename) && (fs.readFileSync(envFilename, { encoding: ENCODING }).toString() === decrypted)) {
-        unchangedEnvFilenames.add(envFilename)
+  try {
+    const {
+      processedEnvs,
+      changedFilenames,
+      unchangedFilenames
+    } = new Decrypt(directory, options.environment).run()
+
+    for (const env of processedEnvs) {
+      if (env.warning) {
+        const warning = env.warning
+        logger.warn(warning.message)
       } else {
-        changedEnvFilenames.add(envFilename)
-        fs.writeFileSync(envFilename, decrypted)
+        if (env.shouldWrite) {
+          logger.debug(`writing ${env.filepath}`)
+          fs.writeFileSync(env.filepath, env.decrypted)
+        } else {
+          logger.debug(`no changes for ${env.filename}`)
+        }
       }
-    } else {
-      logger.warn(`${vaultKey} missing in .env.vault: ${vaultFilepath}`)
     }
-  })
 
-  let changedMsg = ''
-  if (changedEnvFilenames.size > 0) {
-    changedMsg = `decrypted (${Array.from(changedEnvFilenames).join(',')})`
-  }
+    let changedMsg = ''
+    if (changedFilenames.length > 0) {
+      changedMsg = `decrypted (${changedFilenames.join(', ')})`
+    }
 
-  let unchangedMsg = ''
-  if (unchangedEnvFilenames.size > 0) {
-    unchangedMsg = `no changes (${Array.from(unchangedEnvFilenames).join(',')})`
-  }
+    let unchangedMsg = ''
+    if (unchangedFilenames.length > 0) {
+      unchangedMsg = `no changes (${unchangedFilenames.join(', ')})`
+    }
 
-  if (changedMsg.length > 0) {
-    spinner.succeed(`${changedMsg} ${unchangedMsg}`)
-  } else {
-    spinner.done(`${unchangedMsg}`)
+    if (changedMsg.length > 0) {
+      spinner.succeed(`${changedMsg} ${unchangedMsg}`)
+    } else {
+      spinner.done(`${unchangedMsg}`)
+    }
+  } catch (error) {
+    spinner.fail(error.message)
+    if (error.help) {
+      logger.help(error.help)
+    }
+    if (error.debug) {
+      logger.debug(error.debug)
+    }
+    if (error.code) {
+      logger.debug(`ERROR_CODE: ${error.code}`)
+    }
+    process.exit(1)
   }
 }
 

package/src/cli/actions/run.js

@@ -8,7 +8,7 @@ const Run = require('./../../lib/services/run')
 const executeCommand = async function (commandArgs, env) {
   const signals = [
     'SIGHUP', 'SIGQUIT', 'SIGILL', 'SIGTRAP', 'SIGABRT',
-    'SIGBUS', 'SIGFPE', 'SIGUSR1', 'SIGSEGV', 'SIGUSR2', 'SIGTERM'
+    'SIGBUS', 'SIGFPE', 'SIGUSR1', 'SIGSEGV', 'SIGUSR2'
   ]
 
   logger.debug(`executing process command [${commandArgs.join(' ')}]`)
@@ -27,6 +27,19 @@ const executeCommand = async function (commandArgs, env) {
       logger.debug('no command process to send SIGINT to')
     }
   }
+  // handler for SIGTERM
+  const sigtermHandler = () => {
+    logger.debug('received SIGTERM')
+    logger.debug('checking command process')
+    logger.debug(commandProcess)
+
+    if (commandProcess) {
+      logger.debug('sending SIGTERM to command process')
+      commandProcess.kill('SIGTERM') // Send SIGTEM to the command process
+    } else {
+      logger.debug('no command process to send SIGTERM to')
+    }
+  }
 
   const handleOtherSignal = (signal) => {
     logger.debug(`received ${signal}`)
@@ -47,6 +60,7 @@ const executeCommand = async function (commandArgs, env) {
     })
 
     process.on('SIGINT', sigintHandler)
+    process.on('SIGTERM', sigtermHandler)
 
     signals.forEach(signal => {
       process.on(signal, () => handleOtherSignal(signal))
@@ -61,7 +75,7 @@ const executeCommand = async function (commandArgs, env) {
     }
   } catch (error) {
     // no color on these errors as they can be standard errors for things like jest exiting with exitCode 1 for a single failed test.
-    if (error.signal !== 'SIGINT') {
+    if (error.signal !== 'SIGINT' && error.signal !== 'SIGTERM') {
       if (error.code === 'ENOENT') {
         logger.errornocolor(`Unknown command: ${error.command}`)
       } else if (error.message.includes('Command failed with exit code 1')) {
@@ -76,6 +90,8 @@ const executeCommand = async function (commandArgs, env) {
   } finally {
     // Clean up: Remove the SIGINT handler
     process.removeListener('SIGINT', sigintHandler)
+    // Clean up: Remove the SIGTERM handler
+    process.removeListener('SIGTERM', sigtermHandler)
   }
 }
 

package/src/cli/actions/status.js

@@ -0,0 +1,49 @@
+const logger = require('./../../shared/logger')
+
+const main = require('./../../lib/main')
+
+function status (directory) {
+  // debug args
+  logger.debug(`directory: ${directory}`)
+
+  const options = this.opts()
+  logger.debug(`options: ${JSON.stringify(options)}`)
+
+  const { changes, nochanges } = main.status(directory)
+
+  const changeFilenames = []
+  const nochangeFilenames = []
+
+  for (const row of nochanges) {
+    nochangeFilenames.push(row.filename)
+  }
+
+  if (nochangeFilenames.length > 0) {
+    logger.blank(`no changes (${nochangeFilenames.join(', ')})`)
+  }
+
+  for (const row of changes) {
+    changeFilenames.push(row.filename)
+  }
+
+  if (changeFilenames.length > 0) {
+    logger.warn(`changes (${changeFilenames.join(', ')})`)
+  }
+
+  for (const row of changes) {
+    logger.blank('')
+    const padding = '    '
+    logger.blank(`${padding}\`\`\`${row.filename}`)
+    const paddedResult = row.coloredDiff.split('\n').map(line => padding + line).join('\n')
+    console.log(paddedResult)
+    logger.blank(`${padding}\`\`\``)
+  }
+
+  if (changeFilenames.length > 0) {
+    logger.blank('')
+    const optionalDirectory = directory === '.' ? '' : ` ${directory}`
+    logger.blank(`run [dotenvx encrypt${optionalDirectory}] to apply changes to .env.vault`)
+  }
+}
+
+module.exports = status

package/src/cli/dotenvx.js

@@ -111,8 +111,16 @@ program.command('encrypt')
 // dotenvx decrypt
 program.command('decrypt')
   .description('decrypt .env.vault to .env*')
+  .argument('[directory]', 'directory to decrypt', '.')
+  .option('-e, --environment <environments...>', 'environment(s) to decrypt')
   .action(require('./actions/decrypt'))
 
+// dotenvx status
+program.command('status')
+  .description('compare your .env* content(s) to your .env.vault decrypted content(s)')
+  .argument('[directory]', 'directory to check status against', '.')
+  .action(require('./actions/status'))
+
 // dotenvx genexample
 program.command('genexample')
   .description('generate .env.example')

package/src/lib/helpers/arrayToTree.js

@@ -1,3 +1,5 @@
+const path = require('path')
+
 class ArrayToTree {
   constructor (arr) {
     this.arr = arr
@@ -7,7 +9,8 @@ class ArrayToTree {
     const tree = {}
 
     for (let i = 0; i < this.arr.length; i++) {
-      const parts = this.arr[i].split('/')
+      const normalizedPath = path.normalize(this.arr[i]) // normalize any strange paths
+      const parts = normalizedPath.split(path.sep) // use the platform-specific path segment separator
       let current = tree
 
       for (let j = 0; j < parts.length; j++) {

package/src/lib/helpers/containsDirectory.js

@@ -0,0 +1,7 @@
+const path = require('path')
+
+function containsDirectory (filepath) {
+  return filepath.includes(path.sep)
+}
+
+module.exports = containsDirectory

package/src/lib/main.js

@@ -7,6 +7,7 @@ const Encrypt = require('./services/encrypt')
 const Ls = require('./services/ls')
 const Get = require('./services/get')
 const Sets = require('./services/sets')
+const Status = require('./services/status')
 const Genexample = require('./services/genexample')
 const Settings = require('./services/settings')
 
@@ -61,6 +62,10 @@ const set = function (key, value, envFile) {
   return new Sets(key, value, envFile).run()
 }
 
+const status = function (directory) {
+  return new Status(directory).run()
+}
+
 const settings = function (key = null) {
   return new Settings(key).run()
 }
@@ -94,6 +99,7 @@ module.exports = {
   ls,
   get,
   set,
+  status,
   genexample,
   // settings
   settings,

package/src/lib/services/decrypt.js

@@ -0,0 +1,126 @@
+const fs = require('fs')
+const path = require('path')
+const dotenv = require('dotenv')
+
+const ENCODING = 'utf8'
+
+const libDecrypt = require('./../../lib/helpers/decrypt')
+
+class Decrypt {
+  constructor (directory = '.', environment) {
+    this.directory = directory
+    this.environment = environment
+
+    this.envKeysFilepath = path.resolve(this.directory, '.env.keys')
+    this.envVaultFilepath = path.resolve(this.directory, '.env.vault')
+
+    this.processedEnvs = []
+    this.changedFilenames = new Set()
+    this.unchangedFilenames = new Set()
+  }
+
+  run () {
+    if (!fs.existsSync(this.envVaultFilepath)) {
+      const code = 'MISSING_ENV_VAULT_FILE'
+      const message = `missing .env.vault (${this.envVaultFilepath})`
+      const help = `? generate one with [dotenvx encrypt ${this.directory}]`
+
+      const error = new Error(message)
+      error.code = code
+      error.help = help
+      throw error
+    }
+
+    if (!fs.existsSync(this.envKeysFilepath)) {
+      const code = 'MISSING_ENV_KEYS_FILE'
+      const message = `missing .env.keys (${this.envKeysFilepath})`
+      const help = '? a .env.keys file must be present in order to decrypt your .env.vault contents to .env file(s)'
+
+      const error = new Error(message)
+      error.code = code
+      error.help = help
+      throw error
+    }
+
+    const dotenvKeys = dotenv.configDotenv({ path: this.envKeysFilepath }).parsed
+    const dotenvVault = dotenv.configDotenv({ path: this.envVaultFilepath }).parsed
+    const environments = this._environments()
+
+    if (environments.length > 0) {
+      // iterate over the environments
+      for (const environment of environments) {
+        const value = dotenvKeys[`DOTENV_KEY_${environment.toUpperCase()}`]
+        const row = this._processRow(value, dotenvVault, environment)
+
+        this.processedEnvs.push(row)
+      }
+    } else {
+      for (const [dotenvKey, value] of Object.entries(dotenvKeys)) {
+        const environment = dotenvKey.replace('DOTENV_KEY_', '').toLowerCase()
+        const row = this._processRow(value, dotenvVault, environment)
+
+        this.processedEnvs.push(row)
+      }
+    }
+
+    return {
+      processedEnvs: this.processedEnvs,
+      changedFilenames: [...this.changedFilenames],
+      unchangedFilenames: [...this.unchangedFilenames]
+    }
+  }
+
+  _processRow (value, dotenvVault, environment) {
+    environment = environment.toLowerCase() // important so we don't later write .env.DEVELOPMENT for example
+    const vaultKey = `DOTENV_VAULT_${environment.toUpperCase()}`
+    const ciphertext = dotenvVault[vaultKey] // attempt to find ciphertext
+
+    const row = {}
+    row.environment = environment
+    row.dotenvKey = value ? value.trim() : value
+    row.ciphertext = ciphertext
+
+    if (ciphertext && ciphertext.length >= 1) {
+      // Decrypt
+      const decrypted = libDecrypt(ciphertext, value.trim())
+      row.decrypted = decrypted
+
+      // envFilename
+      // replace _ with . to support filenames like .env.development.local
+      let envFilename = `.env.${environment.replace('_', '.')}`
+      if (environment === 'development') {
+        envFilename = '.env'
+      }
+      row.filename = envFilename
+      row.filepath = path.resolve(this.directory, envFilename)
+
+      // check if exists and is changing
+      if (fs.existsSync(row.filepath) && (fs.readFileSync(row.filepath, { encoding: ENCODING }).toString() === decrypted)) {
+        this.unchangedFilenames.add(envFilename)
+      } else {
+        row.shouldWrite = true
+        this.changedFilenames.add(envFilename)
+      }
+    } else {
+      const message = `${vaultKey} missing in .env.vault: ${this.envVaultFilepath}`
+      const warning = new Error(message)
+      row.warning = warning
+    }
+
+    return row
+  }
+
+  _environments () {
+    if (this.environment === undefined) {
+      return []
+    }
+
+    if (!Array.isArray(this.environment)) {
+      return [this.environment]
+    }
+
+    return this.environment
+  }
+}
+
+module.exports = Decrypt

package/src/lib/services/status.js

@@ -0,0 +1,105 @@
+const fs = require('fs')
+const path = require('path')
+const diff = require('diff')
+const chalk = require('chalk')
+
+const Ls = require('./ls')
+const Decrypt = require('./decrypt')
+
+const containsDirectory = require('./../helpers/containsDirectory')
+const guessEnvironment = require('./../helpers/guessEnvironment')
+
+const ENCODING = 'utf8'
+
+class Status {
+  constructor (directory = '.') {
+    this.directory = directory
+    this.changes = []
+    this.nochanges = []
+  }
+
+  run () {
+    // get list of .env files
+    const files = new Ls(this.directory).run()
+    // iterate over each one
+    for (const filename of files) {
+      // skip file if directory
+      if (containsDirectory(filename)) {
+        continue
+      }
+
+      // skip file if .env.keys
+      if (filename.endsWith('.env.keys')) {
+        continue
+      }
+
+      // skip file if .env.vault
+      if (filename.endsWith('.env.vault')) {
+        continue
+      }
+
+      // skip file if .env.example
+      if (filename.endsWith('.env.example')) {
+        continue
+      }
+
+      // skip file if *.previous
+      if (filename.endsWith('.previous')) {
+        continue
+      }
+
+      const filepath = path.resolve(this.directory, filename)
+
+      const row = {}
+      row.filename = filename
+      row.filepath = filepath
+      row.environment = guessEnvironment(filepath)
+
+      // grab raw
+      row.raw = fs.readFileSync(filepath, { encoding: ENCODING })
+
+      // grab decrypted
+      const { processedEnvs } = new Decrypt(this.directory, row.environment).run()
+      row.decrypted = processedEnvs[0].decrypted
+
+      // differences
+      row.differences = diff.diffWords(row.decrypted, row.raw)
+
+      // any changes?
+      const hasChanges = this._hasChanges(row.differences)
+
+      if (hasChanges) {
+        row.coloredDiff = row.differences.map(this._colorizeDiff).join('')
+        this.changes.push(row)
+      } else {
+        this.nochanges.push(row)
+      }
+    }
+
+    return {
+      changes: this.changes,
+      nochanges: this.nochanges
+    }
+  }
+
+  _colorizeDiff (part) {
+    // If the part was added, color it green
+    if (part.added) {
+      return chalk.green(part.value)
+    }
+
+    // If the part was removed, color it red
+    if (part.removed) {
+      return chalk.red(part.value)
+    }
+
+    // No color for unchanged parts
+    return part.value
+  }
+
+  _hasChanges (differences) {
+    return differences.some(part => part.added || part.removed)
+  }
+}
+
+module.exports = Status