@dotenvx/dotenvx 0.19.1 → 0.20.1

package/package.json

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

package/src/cli/actions/run.js

@@ -1,10 +1,13 @@
 const fs = require('fs')
+const path = require('path')
 const execa = require('execa')
 const logger = require('./../../shared/logger')
 const helpers = require('./../helpers')
 const main = require('./../../lib/main')
 const parseEncryptionKeyFromDotenvKey = require('./../../lib/helpers/parseEncryptionKeyFromDotenvKey')
 
+const RunDefault = require('./../../lib/services/runDefault')
+
 const ENCODING = 'utf8'
 const REPORT_ISSUE_LINK = 'https://github.com/dotenvx/dotenvx/issues/new'
 
@@ -36,7 +39,11 @@ const executeCommand = async function (commandArgs, env) {
   }
 
   try {
-    commandProcess = execa(commandArgs[0], commandArgs.slice(1), {
+    const systemCommandPath = execa.sync('which', [commandArgs[0]]).stdout
+    logger.debug(`system command path [${systemCommandPath}]`)
+
+    // commandProcess = execa(commandArgs[0], commandArgs.slice(1), {
+    commandProcess = execa(systemCommandPath, commandArgs.slice(1), {
       stdio: 'inherit',
       env: { ...process.env, ...env }
     })
@@ -156,55 +163,48 @@ async function run () {
       }
     }
   } else {
-    // convert to array if needed
-    let optionEnvFile = options.envFile
-    if (!Array.isArray(optionEnvFile)) {
-      optionEnvFile = [optionEnvFile]
-    }
-
-    const readableFilepaths = new Set()
-    const injected = new Set()
+    const { files, readableFilepaths, uniqueInjectedKeys } = new RunDefault(options.envFile, options.env, options.overload).run()
 
-    for (const envFilepath of optionEnvFile) {
-      const filepath = helpers.resolvePath(envFilepath)
+    for (const file of files) {
+      const filepath = file.filepath
 
-      logger.verbose(`loading env from ${filepath}`)
+      logger.verbose(`loading env from ${filepath} (${path.resolve(filepath)})`)
 
-      try {
-        const src = fs.readFileSync(filepath, { encoding: ENCODING })
-        const parsed = main.parseExpand(src, options.overload)
-        const result = main.inject(process.env, parsed, options.overload)
-
-        readableFilepaths.add(envFilepath)
-        result.injected.forEach(key => injected.add(key))
-      } catch (e) {
-        // calculate development help message depending on state of repo
-        const vaultFilepath = helpers.resolvePath('.env.vault')
-        let developmentHelp = `? in development: add one with [echo "HELLO=World" > .env] and re-run [dotenvx run -- ${commandArgs.join(' ')}]`
-        if (fs.existsSync(vaultFilepath)) {
-          developmentHelp = `? in development: use [dotenvx decrypt] to decrypt .env.vault to .env and then re-run [dotenvx run -- ${commandArgs.join(' ')}]`
+      if (file.error) {
+        if (file.error.code === 'MISSING_ENV_FILE') {
+          logger.warnv(file.error)
+          logger.help(`? in development: add one with [echo "HELLO=World" > ${filepath}] and re-run [dotenvx run -- ${commandArgs.join(' ')}]`)
+          logger.help('? for production: set [DOTENV_KEY] on your server and re-deploy')
+          logger.help('? for ci: set [DOTENV_KEY] on your ci and re-build')
+        } else {
+          logger.warnv(file.error)
+        }
+      } else {
+        // debug parsed
+        const parsed = file.parsed
+        logger.debug(parsed)
+
+        // verbose/debug injected key/value
+        const injected = file.injected
+        for (const [key, value] of Object.entries(injected)) {
+          logger.verbose(`${key} set`)
+          logger.debug(`${key} set to ${value}`)
         }
 
-        switch (e.code) {
-          // missing .env
-          case 'ENOENT':
-            logger.warnv(`missing ${envFilepath} file (${filepath})`)
-            logger.help(developmentHelp)
-            logger.help('? for production: set [DOTENV_KEY] on your server and re-deploy')
-            logger.help('? for ci: set [DOTENV_KEY] on your ci and re-build')
-            break
-
-          // unhandled error
-          default:
-            logger.warn(e)
-            break
+        // verbose/debug preExisted key/value
+        const preExisted = file.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)`)
         }
       }
     }
 
-    if (readableFilepaths.size > 0) {
-      logger.successv(`injecting env (${injected.size}) from ${[...readableFilepaths]}`)
+    let msg = `injecting env (${uniqueInjectedKeys.length})`
+    if (readableFilepaths.length > 0) {
+      msg += ` from ${readableFilepaths}`
     }
+    logger.successv(msg)
   }
 
   // Extract command and arguments after '--'

package/src/cli/dotenvx.js

@@ -56,6 +56,7 @@ program.command('run')
   .addHelpText('after', examples.run)
   .option('-f, --env-file <paths...>', 'path(s) to your env file(s)', '.env')
   .option('-fv, --env-vault-file <path>', 'path to your .env.vault file', '.env.vault')
+  .option('-e, --env <strings...>', 'environment variable(s) set as string (example: "HELLO=World")')
   .option('-o, --overload', 'override existing env variables')
   .action(require('./actions/run'))
 

package/src/lib/services/runDefault.js

@@ -0,0 +1,155 @@
+const fs = require('fs')
+const path = require('path')
+const dotenv = require('dotenv')
+const dotenvExpand = require('dotenv-expand')
+
+const ENCODING = 'utf8'
+
+class RunDefault {
+  constructor (envFile = '.env', env = [], overload = false) {
+    this.envFile = envFile
+    this.env = env
+    this.overload = overload
+  }
+
+  run () {
+    const strings = []
+    const files = []
+    const readableFilepaths = new Set()
+    const uniqueInjectedKeys = new Set()
+
+    const envs = this._envs()
+    for (const env of envs) {
+      const row = {}
+      row.string = env
+
+      try {
+        const parsed = this._parseExpand(env)
+        row.parsed = parsed
+
+        const { injected, preExisted } = this._inject(process.env, parsed)
+        row.injected = injected
+        row.preExisted = preExisted
+
+        for (const key of Object.keys(injected)) {
+          uniqueInjectedKeys.add(key) // track uniqueInjectedKeys across multiple files
+        }
+      } catch (e) {
+        row.error = e
+      }
+
+      strings.push(row)
+    }
+
+    const envFilepaths = this._envFilepaths()
+    for (const envFilepath of envFilepaths) {
+      const row = {}
+      row.filepath = envFilepath
+
+      const filepath = path.resolve(envFilepath)
+      try {
+        const src = fs.readFileSync(filepath, { encoding: ENCODING })
+        readableFilepaths.add(envFilepath)
+
+        const parsed = this._parseExpand(src)
+        row.parsed = parsed
+
+        const { injected, preExisted } = this._inject(process.env, parsed)
+        row.injected = injected
+        row.preExisted = preExisted
+
+        for (const key of Object.keys(injected)) {
+          uniqueInjectedKeys.add(key) // track uniqueInjectedKeys across multiple files
+        }
+      } catch (e) {
+        if (e.code === 'ENOENT') {
+          const error = new Error(`missing ${envFilepath} file (${filepath})`)
+          error.code = 'MISSING_ENV_FILE'
+
+          row.error = error
+        } else {
+          row.error = e
+        }
+      }
+
+      files.push(row)
+    }
+
+    return {
+      files,
+      strings,
+      readableFilepaths: [...readableFilepaths], // array
+      uniqueInjectedKeys: [...uniqueInjectedKeys]
+    }
+  }
+
+  _envFilepaths () {
+    if (!Array.isArray(this.envFile)) {
+      return [this.envFile]
+    }
+
+    return this.envFile
+  }
+
+  _envs () {
+    if (!Array.isArray(this.env)) {
+      return [this.env]
+    }
+
+    return this.env
+  }
+
+  _parseExpand (src) {
+    const parsed = dotenv.parse(src)
+
+    // consider moving this logic straight into dotenv-expand
+    let inputParsed = {}
+    if (this.overload) {
+      inputParsed = { ...process.env, ...parsed }
+    } else {
+      inputParsed = { ...parsed, ...process.env }
+    }
+
+    const expandPlease = {
+      processEnv: {},
+      parsed: inputParsed
+    }
+    const expanded = dotenvExpand.expand(expandPlease).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]
+    }
+
+    return result
+  }
+
+  _inject (processEnv = {}, parsed = {}) {
+    const injected = {}
+    const preExisted = {}
+
+    // set processEnv
+    for (const key of Object.keys(parsed)) {
+      if (processEnv[key]) {
+        if (this.overload === true) {
+          processEnv[key] = parsed[key]
+
+          injected[key] = parsed[key] // track injected key/value
+        } else {
+          preExisted[key] = processEnv[key] // track preExisted key/value
+        }
+      } else {
+        processEnv[key] = parsed[key]
+        injected[key] = parsed[key] // track injected key/value
+      }
+    }
+
+    return {
+      injected,
+      preExisted
+    }
+  }
+}
+
+module.exports = RunDefault