@dotenvx/dotenvx 0.19.0 → 0.20.0

package/package.json

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

package/src/cli/actions/precommit.js

@@ -1,11 +1,5 @@
-const fs = require('fs')
-const path = require('path')
-const ignore = require('ignore')
-
 const logger = require('./../../shared/logger')
 
-const helpers = require('./../helpers')
-
 const Precommit = require('./../../lib/services/precommit')
 
 function precommit () {
@@ -14,102 +8,6 @@ function precommit () {
 
   const precommit = new Precommit(options)
   precommit.run()
-
-  // 0. handle the --install flag
-  if (options.install) {
-    installPrecommitHook()
-    return
-  }
-
-  // 1. check for .gitignore file
-  if (!fs.existsSync('.gitignore')) {
-    logger.errorvp('.gitignore missing')
-    logger.help2('? add it with [touch .gitignore]')
-    process.exit(1)
-  }
-
-  // 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
-      }
-    }
-  })
-
-  // 3. outpout success
-  if (warningCount > 0) {
-    logger.successvp(`success (with ${helpers.pluralize('warning', warningCount)})`)
-  } else {
-    logger.successvp('success')
-  }
-}
-
-function installPrecommitHook () {
-  const hookScript = `#!/bin/sh
-
-if ! command -v dotenvx &> /dev/null
-then
-  echo "[dotenvx][precommit] 'dotenvx' command not found"
-  echo "[dotenvx][precommit] ? install it with [brew install dotenvx/brew/dotenvx]"
-  echo "[dotenvx][precommit] ? other install options [https://dotenvx.com/docs/install]"
-  exit 1
-fi
-
-dotenvx precommit`
-  const hookPath = path.join('.git', 'hooks', 'pre-commit')
-
-  try {
-    // Check if the pre-commit file already exists
-    if (fs.existsSync(hookPath)) {
-      // Read the existing content of the file
-      const existingContent = fs.readFileSync(hookPath, 'utf8')
-
-      // Check if 'dotenvx precommit' already exists in the file
-      if (!existingContent.includes('dotenvx precommit')) {
-        // Append 'dotenvx precommit' to the existing file
-        fs.appendFileSync(hookPath, '\n' + hookScript)
-        logger.successvp(`dotenvx precommit appended [${hookPath}]`)
-      } else {
-        logger.warnvp(`dotenvx precommit exists [${hookPath}]`)
-      }
-    } else {
-      // If the pre-commit file doesn't exist, create a new one with the hookScript
-      fs.writeFileSync(hookPath, hookScript)
-      fs.chmodSync(hookPath, '755') // Make the file executable
-      logger.successvp(`dotenvx precommit installed [${hookPath}]`)
-    }
-  } catch (err) {
-    logger.errorvp(`Failed to modify pre-commit hook: ${err.message}`)
-  }
 }
 
 module.exports = precommit

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'
 
@@ -156,55 +159,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}`)
-
-      try {
-        const src = fs.readFileSync(filepath, { encoding: ENCODING })
-        const parsed = main.parseExpand(src, options.overload)
-        const result = main.inject(process.env, parsed, options.overload)
+      logger.verbose(`loading env from ${filepath} (${path.resolve(filepath)})`)
 
-        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/precommit.js

@@ -1,4 +1,8 @@
+/* istanbul ignore file */
+const fs = require('fs')
+const ignore = require('ignore')
 const logger = require('./../../shared/logger')
+const helpers = require('./../../cli/helpers')
 
 const InstallPrecommitHook = require('./../helpers/installPrecommitHook')
 
@@ -14,7 +18,56 @@ class Precommit {
       return true
     }
 
-    logger.info('implement')
+    // 1. check for .gitignore file
+    if (!fs.existsSync('.gitignore')) {
+      logger.errorvp('.gitignore missing')
+      logger.help2('? add it with [touch .gitignore]')
+      process.exit(1)
+    }
+
+    // 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
+        }
+      }
+    })
+
+    // 3. outpout success
+    if (warningCount > 0) {
+      logger.successvp(`success (with ${helpers.pluralize('warning', warningCount)})`)
+    } else {
+      logger.successvp('success')
+    }
   }
 
   /* istanbul ignore next */

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