@dotenvx/dotenvx 0.22.0 → 0.24.0

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.22.0",
+  "version": "0.24.0",
   "name": "@dotenvx/dotenvx",
   "description": "a better dotenv–from the creator of `dotenv`",
   "author": "@motdotla",

package/src/cli/actions/precommit.js

@@ -6,8 +6,28 @@ function precommit () {
   const options = this.opts()
   logger.debug(`options: ${JSON.stringify(options)}`)
 
-  const precommit = new Precommit(options)
-  precommit.run()
+  try {
+    const {
+      successMessage,
+      warnings
+    } = new Precommit(options).run()
+
+    for (const warning of warnings) {
+      logger.warnv(warning.message)
+      if (warning.help) {
+        logger.help(warning.help)
+      }
+    }
+
+    logger.successvp(successMessage)
+  } catch (error) {
+    logger.errorvp(error.message)
+    if (error.help) {
+      logger.help(error.help)
+    }
+
+    process.exit(1)
+  }
 }
 
 module.exports = precommit

package/src/lib/helpers/dotenvEval.js

@@ -0,0 +1,54 @@
+const { execSync } = require('child_process')
+
+function _chomp (value) {
+  return value.replace(/\r?\n|\r/, '')
+}
+
+function interpolate (value, processEnv, parsed) {
+  const matches = value.match(/\$\([^()]+\)/) || []
+
+  return matches.reduce(function (newValue, match) {
+    // get command
+    const command = match.substring(2, match.length - 1)
+    // execute command
+    const value = _chomp(execSync(command).toString())
+    // replace with command value
+    return newValue.replace(match, value)
+  }, value)
+}
+
+function evaluate (options) {
+  let processEnv = process.env
+  if (options && options.processEnv != null) {
+    processEnv = options.processEnv
+  }
+
+  for (const key in options.parsed) {
+    let value = options.parsed[key]
+
+    const inProcessEnv = Object.prototype.hasOwnProperty.call(processEnv, key)
+
+    if (inProcessEnv) {
+      if (processEnv[key] === options.parsed[key]) {
+        // assume was set to processEnv from the .env file if the values match and therefore interpolate
+        value = interpolate(value, processEnv, options.parsed)
+      } else {
+        // do not interpolate - assume processEnv had the intended value even if containing a $.
+        value = processEnv[key]
+      }
+    } else {
+      // not inProcessEnv so assume interpolation for this .env key
+      value = interpolate(value, processEnv, options.parsed)
+    }
+
+    options.parsed[key] = value
+  }
+
+  for (const processKey in options.parsed) {
+    processEnv[processKey] = options.parsed[processKey]
+  }
+
+  return options
+}
+
+module.exports.eval = evaluate

package/src/lib/helpers/dotenvVault.js

@@ -3,6 +3,7 @@ const path = require('path')
 const encrypt = require('./encrypt')
 const changed = require('./changed')
 const guessEnvironment = require('./guessEnvironment')
+const removePersonal = require('./removePersonal')
 
 class DotenvVault {
   constructor (dotenvFiles = {}, dotenvKeys = {}, dotenvVaults = {}) {
@@ -23,8 +24,10 @@ class DotenvVault {
       let ciphertext = this.dotenvVaults[vault]
       const dotenvKey = this.dotenvKeys[`DOTENV_KEY_${environment.toUpperCase()}`]
 
-      if (!ciphertext || ciphertext.length === 0 || changed(ciphertext, raw, dotenvKey)) {
-        ciphertext = encrypt(raw, dotenvKey)
+      const cleanRaw = removePersonal(raw)
+
+      if (!ciphertext || ciphertext.length === 0 || changed(ciphertext, cleanRaw, dotenvKey)) {
+        ciphertext = encrypt(cleanRaw, dotenvKey)
         this.dotenvVaults[vault] = ciphertext
         addedVaults.add(vault) // for info logging to user
 

package/src/lib/helpers/installPrecommitHook.js

@@ -1,8 +1,6 @@
 const fs = require('fs')
 const path = require('path')
 
-const logger = require('./../../shared/logger')
-
 const HOOK_SCRIPT = `#!/bin/sh
 
 if ! command -v dotenvx &> /dev/null
@@ -21,20 +19,30 @@ class InstallPrecommitHook {
   }
 
   run () {
+    let successMessage
+
     try {
       // Check if the pre-commit file already exists
       if (this._exists()) {
         // Check if 'dotenvx precommit' already exists in the file
-        if (!this._currentHook().includes('dotenvx precommit')) {
-          this._appendHook()
+        if (this._currentHook().includes('dotenvx precommit')) {
+          // do nothing
+          successMessage = `dotenvx precommit exists [${this.hookPath}]`
         } else {
-          logger.warnvp(`dotenvx precommit exists [${this.hookPath}]`)
+          this._appendHook()
+          successMessage = `dotenvx precommit appended [${this.hookPath}]`
         }
       } else {
         this._createHook()
+        successMessage = `dotenvx precommit installed [${this.hookPath}]`
+      }
+
+      return {
+        successMessage
       }
     } catch (err) {
-      logger.errorvp(`failed to modify pre-commit hook: ${err.message}`)
+      const error = new Error(`failed to modify pre-commit hook: ${err.message}`)
+      throw error
     }
   }
 
@@ -50,13 +58,11 @@ class InstallPrecommitHook {
     // If the pre-commit file doesn't exist, create a new one with the hookScript
     fs.writeFileSync(this.hookPath, HOOK_SCRIPT)
     fs.chmodSync(this.hookPath, '755') // Make the file executable
-    logger.successvp(`dotenvx precommit installed [${this.hookPath}]`)
   }
 
   _appendHook () {
     // Append 'dotenvx precommit' to the existing file
     fs.appendFileSync(this.hookPath, '\n' + HOOK_SCRIPT)
-    logger.successvp(`dotenvx precommit appended [${this.hookPath}]`)
   }
 }
 

package/src/lib/helpers/{parseExpand.js → parseExpandAndEval.js}

@@ -1,7 +1,8 @@
 const dotenv = require('dotenv')
 const dotenvExpand = require('dotenv-expand')
+const dotenvEval = require('./dotenvEval')
 
-function parseExpand (src, overload) {
+function parseExpandAndEval (src, overload) {
   const parsed = dotenv.parse(src)
 
   // consider moving this logic straight into dotenv-expand
@@ -18,13 +19,26 @@ function parseExpand (src, overload) {
   }
   const expanded = dotenvExpand.expand(expandPlease).parsed
 
+  let inputExpanded = {}
+  if (overload) {
+    inputExpanded = { ...process.env, ...expanded }
+  } else {
+    inputExpanded = { ...expanded, ...process.env }
+  }
+
+  const evaluatePlease = {
+    processEnv: {},
+    parsed: inputExpanded
+  }
+  const evaluated = dotenvEval.eval(evaluatePlease).parsed
+
   // but then for logging only log the original keys existing in parsed. this feels unnecessarily complex - like dotenv-expand should support the ability to inject additional `process.env` or objects as it sees fit to the object it wants to expand
   const result = {}
   for (const key in parsed) {
-    result[key] = expanded[key]
+    result[key] = evaluated[key]
   }
 
   return result
 }
 
-module.exports = parseExpand
+module.exports = parseExpandAndEval

package/src/lib/helpers/pluralize.js

@@ -0,0 +1,10 @@
+function pluralize (word, count) {
+  // simple pluralization: add 's' at the end
+  if (count === 0 || count > 1) {
+    return word + 's'
+  } else {
+    return word
+  }
+}
+
+module.exports = pluralize

package/src/lib/helpers/removePersonal.js

@@ -0,0 +1,9 @@
+const SPLIT_REGEX = /#\s*personal\.dotenv\s*/i
+
+function removePersonal (raw) {
+  const parts = raw.split(SPLIT_REGEX)
+
+  return parts[0]
+}
+
+module.exports = removePersonal

package/src/lib/main.js

@@ -8,6 +8,9 @@ const Ls = require('./services/ls')
 const Get = require('./services/get')
 const Genexample = require('./services/genexample')
 
+// helpers
+const dotenvEval = require('./helpers/dotenvEval')
+
 // proxies to dotenv
 const config = function (options) {
   const env = dotenv.config(options)
@@ -18,7 +21,13 @@ const config = function (options) {
   }
   const expanded = dotenvExpand.expand(env)
 
-  return expanded
+  // if processEnv passed also pass to eval
+  if (options && options.processEnv) {
+    expanded.processEnv = options.processEnv
+  }
+  const evaluated = dotenvEval.eval(expanded)
+
+  return evaluated
 }
 
 const configDotenv = function (options) {

package/src/lib/services/precommit.js

@@ -1,9 +1,8 @@
 /* istanbul ignore file */
 const fs = require('fs')
 const ignore = require('ignore')
-const logger = require('./../../shared/logger')
-const helpers = require('./../../cli/helpers')
 
+const pluralize = require('./../helpers/pluralize')
 const InstallPrecommitHook = require('./../helpers/installPrecommitHook')
 
 class Precommit {
@@ -13,66 +12,59 @@ class Precommit {
 
   run () {
     if (this.install) {
-      this._installPrecommitHook()
+      const {
+        successMessage
+      } = this._installPrecommitHook()
 
-      return true
-    }
+      return {
+        successMessage,
+        warnings: []
+      }
+    } else {
+      const warnings = []
 
-    // 1. check for .gitignore file
-    if (!fs.existsSync('.gitignore')) {
-      logger.errorvp('.gitignore missing')
-      logger.help2('? add it with [touch .gitignore]')
-      process.exit(1)
-    }
+      // 1. check for .gitignore file
+      if (!fs.existsSync('.gitignore')) {
+        const error = new Error('.gitignore missing')
+        error.help = '? add it with [touch .gitignore]'
+        throw error
+      }
 
-    // 2. check .env* files against .gitignore file
-    let warningCount = 0
-    const ig = ignore().add(fs.readFileSync('.gitignore').toString())
-    const files = fs.readdirSync(process.cwd())
-    const dotenvFiles = files.filter(file => file.match(/^\.env(\..+)?$/))
-    dotenvFiles.forEach(file => {
-      // check if that file is being ignored
-      if (ig.ignores(file)) {
-        switch (file) {
-          case '.env.example':
-            warningCount += 1
-            logger.warnv(`${file} (currently ignored but should not be)`)
-            logger.help2(`? add !${file} to .gitignore with [echo "!${file}" >> .gitignore]`)
-            break
-          case '.env.vault':
-            warningCount += 1
-            logger.warnv(`${file} (currently ignored but should not be)`)
-            logger.help2(`? add !${file} to .gitignore with [echo "!${file}" >> .gitignore]`)
-            break
-          default:
-            break
-        }
-      } else {
-        switch (file) {
-          case '.env.example':
-            break
-          case '.env.vault':
-            break
-          default:
-            logger.errorvp(`${file} not properly gitignored`)
-            logger.help2(`? add ${file} to .gitignore with [echo ".env*" >> .gitignore]`)
-            process.exit(1) // 3.1 exit early with error code
-            break
+      // 2. check .env* files against .gitignore file
+      const ig = ignore().add(fs.readFileSync('.gitignore').toString())
+      const files = fs.readdirSync(process.cwd())
+      const dotenvFiles = files.filter(file => file.match(/^\.env(\..+)?$/))
+      dotenvFiles.forEach(file => {
+        // check if that file is being ignored
+        if (ig.ignores(file)) {
+          if (file === '.env.example' || file === '.env.vault') {
+            const warning = new Error(`${file} (currently ignored but should not be)`)
+            warning.help = `? add !${file} to .gitignore with [echo "!${file}" >> .gitignore]`
+            warnings.push(warning)
+          }
+        } else {
+          if (file !== '.env.example' && file !== '.env.vault') {
+            const error = new Error(`${file} not properly gitignored`)
+            error.help = `? add ${file} to .gitignore with [echo ".env*" >> .gitignore]`
+            throw error
+          }
         }
+      })
+
+      let successMessage = 'success'
+      if (warnings.length > 0) {
+        successMessage = `success (with ${pluralize('warning', warnings.length)})`
       }
-    })
 
-    // 3. outpout success
-    if (warningCount > 0) {
-      logger.successvp(`success (with ${helpers.pluralize('warning', warningCount)})`)
-    } else {
-      logger.successvp('success')
+      return {
+        successMessage,
+        warnings
+      }
     }
   }
 
-  /* istanbul ignore next */
   _installPrecommitHook () {
-    new InstallPrecommitHook().run()
+    return new InstallPrecommitHook().run()
   }
 }
 

package/src/lib/services/runDefault.js

@@ -4,7 +4,7 @@ const path = require('path')
 const ENCODING = 'utf8'
 
 const inject = require('./../helpers/inject')
-const parseExpand = require('./../helpers/parseExpand')
+const parseExpandAndEval = require('./../helpers/parseExpandAndEval')
 
 class RunDefault {
   constructor (envFile = '.env', env = [], overload = false) {
@@ -25,7 +25,7 @@ class RunDefault {
       row.string = env
 
       try {
-        const parsed = parseExpand(env, this.overload)
+        const parsed = parseExpandAndEval(env, this.overload)
         row.parsed = parsed
 
         const { injected, preExisted } = inject(process.env, parsed, this.overload)
@@ -52,7 +52,7 @@ class RunDefault {
         const src = fs.readFileSync(filepath, { encoding: ENCODING })
         readableFilepaths.add(envFilepath)
 
-        const parsed = parseExpand(src, this.overload)
+        const parsed = parseExpandAndEval(src, this.overload)
         row.parsed = parsed
 
         const { injected, preExisted } = inject(process.env, parsed, this.overload)

package/src/lib/services/runVault.js

@@ -4,7 +4,7 @@ const dotenv = require('dotenv')
 
 const inject = require('./../helpers/inject')
 const decrypt = require('./../helpers/decrypt')
-const parseExpand = require('./../helpers/parseExpand')
+const parseExpandAndEval = require('./../helpers/parseExpandAndEval')
 const parseEnvironmentFromDotenvKey = require('./../helpers/parseEnvironmentFromDotenvKey')
 
 const ENCODING = 'utf8'
@@ -43,7 +43,7 @@ class RunVault {
       const row = {}
       row.string = env
 
-      const parsed = parseExpand(env, this.overload)
+      const parsed = parseExpandAndEval(env, this.overload)
       row.parsed = parsed
 
       const { injected, preExisted } = inject(process.env, parsed, this.overload)
@@ -77,7 +77,7 @@ class RunVault {
     }
 
     // parse this. it's the equivalent of the .env file
-    const parsed = parseExpand(decrypted, this.overload)
+    const parsed = parseExpandAndEval(decrypted, this.overload)
     const { injected, preExisted } = inject(process.env, parsed, this.overload)
 
     for (const key of Object.keys(injected)) {