@dotenvx/dotenvx 0.42.0 → 0.43.1

package/README.md

@@ -32,7 +32,7 @@ brew install dotenvx/brew/dotenvx
 ```
 > * [other global ways to install](https://dotenvx.com/docs/install)
 >
-> Intall globally as a cli to unlock dotenv for ANY language, framework, or platform. 💥
+> Install globally as a cli to unlock dotenv for ANY language, framework, or platform. 💥
 >
 > I am using (and recommending) this approach going forward. – [motdotla](https://github.com/motdotla)
 

package/package.json

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

package/src/lib/helpers/dotenvOptionPaths.js

@@ -0,0 +1,21 @@
+const resolveHome = require('./resolveHome')
+
+function dotenvOptionPaths (options) {
+  let optionPaths = ['.env']
+
+  if (options && options.path) {
+    if (!Array.isArray(options.path)) {
+      optionPaths = [resolveHome(options.path)]
+    } else {
+      optionPaths = [] // reset default
+
+      for (const filepath of options.path) {
+        optionPaths.push(resolveHome(filepath))
+      }
+    }
+  }
+
+  return optionPaths
+}
+
+module.exports = dotenvOptionPaths

package/src/lib/helpers/parseDecryptEvalExpand.js

@@ -7,13 +7,10 @@ function parseDecryptEvalExpand (src, privateKey = null) {
   // parse
   const parsed = dotenv.parse(src)
 
-  // inline decrypt
-  for (const key in parsed) {
-    const value = parsed[key]
-
-    // handle inline encrypted values
-    if (privateKey && privateKey.length > 0) {
-      // privateKey
+  // handle inline encrypted values
+  if (privateKey && privateKey.length > 0) {
+    for (const key in parsed) {
+      const value = parsed[key]
       parsed[key] = decryptValue(value, privateKey)
     }
   }

package/src/lib/helpers/replace.js

@@ -6,8 +6,19 @@ function replace (src, key, value) {
 
   const parsed = dotenv.parse(src)
   if (Object.prototype.hasOwnProperty.call(parsed, key)) {
-    // replace
-    const regex = new RegExp(`^${key}=(?:(["'\`])[^\\1]*\\1|[^\\n]*)(\\n[^A-Z0-9_].*)*`, 'm')
+    const regex = new RegExp(
+      `^${key}=` + // start of line with key
+      '(?:' + // begin non-capturing group for handling both quoted and unquoted values
+        '(["\'`])' + // capture opening quote (' or " or `)
+        '[^\\1]*' + // match any character except the quote captured initially
+        '\\1' + // match the same closing quote as captured at the start
+      '|' + // OR
+        '[^#\\n]*' + // match any characters until a # (comment) or newline
+      ')' + // end non-capturing group
+      '(\\n[^A-Z0-9_].*)*', // match subsequent lines that don't start with a letter, number, or underscore (continuation lines)
+      'm' // apply multiline mode, so ^ and $ match start and end of lines, not just the whole string
+    )
+
     output = src.replace(regex, formatted)
   } else {
     // append

package/src/lib/helpers/resolveHome.js

@@ -0,0 +1,12 @@
+const os = require('os')
+const path = require('path')
+
+function resolveHome (filepath) {
+  if (filepath[0] === '~') {
+    return path.join(os.homedir(), filepath.slice(1))
+  }
+
+  return filepath
+}
+
+module.exports = resolveHome

package/src/lib/main.js

@@ -1,10 +1,11 @@
+const path = require('path')
 const logger = require('./../shared/logger')
 const dotenv = require('dotenv')
-const dotenvExpand = require('dotenv-expand')
 
 // services
 const Ls = require('./services/ls')
 const Get = require('./services/get')
+const Run = require('./services/run')
 const Sets = require('./services/sets')
 const Status = require('./services/status')
 const Encrypt = require('./services/encrypt')
@@ -13,25 +14,119 @@ const Settings = require('./services/settings')
 const VaultEncrypt = require('./services/vaultEncrypt')
 
 // helpers
-const dotenvEval = require('./helpers/dotenvEval')
+const dotenvOptionPaths = require('./helpers/dotenvOptionPaths')
 
 // proxies to dotenv
-const config = function (options) {
-  const env = dotenv.config(options)
+const config = function (options = {}) {
+  // allow user to set processEnv to write to
+  let processEnv = process.env
+  if (options && options.processEnv != null) {
+    processEnv = options.processEnv
+  }
+
+  // overload
+  const overload = options.overload || options.override
 
-  // if processEnv passed also pass to expand
-  if (options && options.processEnv) {
-    env.processEnv = options.processEnv
+  // DOTENV_KEY
+  let DOTENV_KEY = process.env.DOTENV_KEY
+  if (options && options.DOTENV_KEY) {
+    DOTENV_KEY = options.DOTENV_KEY
   }
-  const expanded = dotenvExpand.expand(env)
 
-  // if processEnv passed also pass to eval
-  if (options && options.processEnv) {
-    expanded.processEnv = options.processEnv
+  // debug -> log level
+  if (options && options.debug) {
+    logger.level = 'debug'
+    logger.debug('setting log level to debug')
   }
-  const evaluated = dotenvEval.eval(expanded)
 
-  return evaluated
+  // build envs using user set option.path
+  const optionPaths = dotenvOptionPaths(options) // [ '.env' ]
+
+  try {
+    const envs = []
+    for (const optionPath of optionPaths) {
+      // if DOTENV_KEY is set then assume we are checking envVaultFile
+      if (DOTENV_KEY) {
+        envs.push({ type: 'envVaultFile', value: path.join(path.dirname(optionPath), '.env.vault') })
+      } else {
+        envs.push({ type: 'envFile', value: optionPath })
+      }
+    }
+
+    const {
+      processedEnvs,
+      readableFilepaths,
+      uniqueInjectedKeys
+    } = new Run(envs, overload, DOTENV_KEY, processEnv).run()
+
+    let lastError
+    const parsedAll = {}
+
+    for (const processedEnv of processedEnvs) {
+      if (processedEnv.type === 'envVaultFile') {
+        logger.verbose(`loading env from encrypted ${processedEnv.filepath} (${path.resolve(processedEnv.filepath)})`)
+        logger.debug(`decrypting encrypted env from ${processedEnv.filepath} (${path.resolve(processedEnv.filepath)})`)
+      }
+
+      if (processedEnv.type === 'envFile') {
+        logger.verbose(`loading env from ${processedEnv.filepath} (${path.resolve(processedEnv.filepath)})`)
+      }
+
+      if (processedEnv.error) {
+        lastError = processedEnv.error
+
+        if (processedEnv.error.code === 'MISSING_ENV_FILE') {
+          // do not warn for conventions (too noisy)
+          if (!options.convention) {
+            logger.warnv(processedEnv.error)
+            logger.help(`? add one with [echo "HELLO=World" > ${processedEnv.filepath}] and re-run [dotenvx run -- yourcommand]`)
+          }
+        } else {
+          logger.warnv(processedEnv.error)
+        }
+      } else {
+        Object.assign(parsedAll, processedEnv.injected)
+        Object.assign(parsedAll, processedEnv.preExisted) // preExisted 'wins'
+
+        // debug parsed
+        const parsed = processedEnv.parsed
+        logger.debug(parsed)
+
+        // verbose/debug injected key/value
+        const injected = processedEnv.injected
+        for (const [key, value] of Object.entries(injected)) {
+          logger.verbose(`${key} set`)
+          logger.debug(`${key} set to ${value}`)
+        }
+
+        // verbose/debug preExisted key/value
+        const preExisted = processedEnv.preExisted
+        for (const [key, value] of Object.entries(preExisted)) {
+          logger.verbose(`${key} pre-exists (protip: use --overload to override)`)
+          logger.debug(`${key} pre-exists as ${value} (protip: use --overload to override)`)
+        }
+      }
+    }
+
+    let msg = `injecting env (${uniqueInjectedKeys.length})`
+    if (readableFilepaths.length > 0) {
+      msg += ` from ${readableFilepaths.join(', ')}`
+    }
+    logger.successv(msg)
+
+    if (lastError) {
+      return { parsed: parsedAll, error: lastError }
+    } else {
+      return { parsed: parsedAll }
+    }
+  } catch (error) {
+    logger.error(error.message)
+    if (error.help) {
+      logger.help(error.help)
+    }
+
+    return { parsed: {}, error }
+  }
 }
 
 const configDotenv = function (options) {