@dotenvx/dotenvx 0.20.2 → 0.21.0

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.20.2",
+  "version": "0.21.0",
   "name": "@dotenvx/dotenvx",
   "description": "a better dotenv–from the creator of `dotenv`",
   "author": "@motdotla",
@@ -42,6 +42,7 @@
     "ora": "^5.4.1",
     "undici": "^5.28.3",
     "update-notifier": "^5.1.0",
+    "which": "^4.0.0",
     "winston": "^3.11.0",
     "xxhashjs": "^0.2.2"
   },

package/src/cli/actions/decrypt.js

@@ -1,10 +1,10 @@
 const fs = require('fs')
+const dotenv = require('dotenv')
 
-const main = require('./../../lib/main')
 const logger = require('./../../shared/logger')
 const helpers = require('./../helpers')
 const createSpinner = require('./../../shared/createSpinner')
-const parseEncryptionKeyFromDotenvKey = require('./../../lib/helpers/parseEncryptionKeyFromDotenvKey')
+const libDecrypt = require('./../../lib/helpers/decrypt')
 
 const spinner = createSpinner('decrypting')
 
@@ -37,8 +37,8 @@ async function decrypt () {
     process.exit(1)
   }
 
-  const dotenvKeys = (main.configDotenv({ path: keysFilepath }).parsed || {})
-  const dotenvVault = (main.configDotenv({ path: vaultFilepath }).parsed || {})
+  const dotenvKeys = dotenv.configDotenv({ path: keysFilepath }).parsed
+  const dotenvVault = dotenv.configDotenv({ path: vaultFilepath }).parsed
 
   Object.entries(dotenvKeys).forEach(([dotenvKey, value]) => {
     // determine environment
@@ -51,10 +51,8 @@ async function decrypt () {
 
     // give warning if not found
     if (ciphertext && ciphertext.length >= 1) {
-      const key = parseEncryptionKeyFromDotenvKey(value.trim())
-
       // Decrypt
-      const decrypted = main.decrypt(ciphertext, key)
+      const decrypted = libDecrypt(ciphertext, value.trim())
 
       // envFilename
       let envFilename = `.env.${environment}`

package/src/cli/actions/genexample.js

@@ -1,6 +1,6 @@
 const fs = require('fs')
-const helpers = require('./../helpers')
 const main = require('./../../lib/main')
+const helpers = require('./../helpers')
 const logger = require('./../../shared/logger')
 const createSpinner = require('./../../shared/createSpinner')
 
@@ -8,84 +8,44 @@ const spinner = createSpinner('generating')
 
 const ENCODING = 'utf8'
 
-async function genexample () {
+async function genexample (directory) {
   spinner.start()
   await helpers.sleep(500) // better dx
 
+  logger.debug(`directory: ${directory}`)
+
   const options = this.opts()
   logger.debug(`options: ${JSON.stringify(options)}`)
 
-  let optionEnvFile = options.envFile
-  if (!Array.isArray(optionEnvFile)) {
-    optionEnvFile = [optionEnvFile]
-  }
-
-  // must be at least one .env* file
-  if (optionEnvFile.length < 1) {
-    spinner.fail('no .env* files found')
-    logger.help('? add one with [echo "HELLO=World" > .env] and then run [dotenvx genexample]')
-    process.exit(1)
-  }
-
-  const keys = new Set()
-  const addedKeys = new Set()
+  try {
+    const {
+      envExampleFile,
+      envFile,
+      exampleFilepath,
+      addedKeys
+    } = main.genexample(directory, options.envFile)
 
-  for (const envFilepath of optionEnvFile) {
-    const filepath = helpers.resolvePath(envFilepath)
+    logger.verbose(`loading env from ${envFile}`)
 
-    logger.verbose(`loading env from ${filepath}`)
+    // TODO: display pre-existing
+    // TODO: display added/appended/injected
 
-    try {
-      const src = fs.readFileSync(filepath, { encoding: ENCODING })
-      const parsed = main.parse(src)
-      Object.keys(parsed).forEach(key => { keys.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 genexample]'
-      if (fs.existsSync(vaultFilepath)) {
-        developmentHelp = '? in development: use [dotenvx decrypt] to decrypt .env.vault to .env and then re-run [dotenvx genexample]'
-      }
+    fs.writeFileSync(exampleFilepath, envExampleFile, ENCODING)
 
-      switch (e.code) {
-        // missing .env
-        case 'ENOENT':
-          logger.warn(`missing ${envFilepath} file (${filepath})`)
-          logger.help(developmentHelp)
-          break
-
-        // unhandled error
-        default:
-          logger.warn(e)
-          break
-      }
-    }
-  }
-
-  const exampleFilename = '.env.example'
-  const exampleFilepath = helpers.resolvePath(exampleFilename)
-  if (!fs.existsSync(exampleFilepath)) {
-    logger.verbose(`creating ${exampleFilename}`)
-    fs.writeFileSync(exampleFilename, `# ${exampleFilename}\n`)
-  }
-
-  const currentEnvExample = (main.configDotenv({ path: exampleFilepath }).parsed || {})
-  const keysArray = Array.from(keys)
-
-  keysArray.forEach(key => {
-    if (key in currentEnvExample) {
-      logger.verbose(`pre-existing ${key} in ${exampleFilename}`)
+    if (addedKeys.length > 0) {
+      spinner.succeed(`updated .env.example (${addedKeys.length})`)
     } else {
-      addedKeys.add(key)
-      logger.verbose(`appending ${key} to ${exampleFilename}`)
-      fs.appendFileSync('.env.example', `${key}=""\n`, ENCODING)
+      spinner.done('no changes (.env.example)')
     }
-  })
-
-  if (addedKeys.size > 0) {
-    spinner.succeed(`updated ${exampleFilename} (${addedKeys.size})`)
-  } else {
-    spinner.done(`no changes (${exampleFilename})`)
+  } catch (error) {
+    spinner.fail(error.message)
+    if (error.help) {
+      logger.help(error.help)
+    }
+    if (error.code) {
+      logger.debug(`ERROR_CODE: ${error.code}`)
+    }
+    process.exit(1)
   }
 }
 

package/src/cli/actions/run.js

@@ -1,5 +1,6 @@
 const path = require('path')
 const execa = require('execa')
+const which = require('which')
 const logger = require('./../../shared/logger')
 
 const RunDefault = require('./../../lib/services/runDefault')
@@ -35,8 +36,13 @@ const executeCommand = async function (commandArgs, env) {
   }
 
   try {
-    const systemCommandPath = execa.sync('which', [commandArgs[0]]).stdout
-    logger.debug(`system command path [${systemCommandPath}]`)
+    let systemCommandPath = commandArgs[0]
+    try {
+      systemCommandPath = which.sync(`${commandArgs[0]}`)
+      logger.debug(`expanding process command to [${systemCommandPath} ${commandArgs.slice(1).join(' ')}]`)
+    } catch (e) {
+      logger.debug(`could not expand process command. using [${systemCommandPath} ${commandArgs.slice(1).join(' ')}]`)
+    }
 
     // commandProcess = execa(commandArgs[0], commandArgs.slice(1), {
     commandProcess = execa(systemCommandPath, commandArgs.slice(1), {

package/src/cli/dotenvx.js

@@ -95,6 +95,7 @@ program.command('prebuild')
 // dotenvx genexample
 program.command('genexample')
   .description('generate .env.example')
+  .argument('[directory]', 'directory to generate from', '.')
   .option('-f, --env-file <paths...>', 'path(s) to your env file(s)', '.env')
   .action(require('./actions/genexample'))
 

package/src/lib/helpers/findEnvFiles.js

@@ -0,0 +1,27 @@
+const fs = require('fs')
+
+const RESERVED_ENV_FILES = ['.env.vault', '.env.project', '.env.keys', '.env.me', '.env.x', '.env.example']
+
+function findEnvFiles (directory) {
+  try {
+    const files = fs.readdirSync(directory)
+    const envFiles = files.filter(file =>
+      file.startsWith('.env') &&
+      !file.endsWith('.previous') &&
+      !RESERVED_ENV_FILES.includes(file)
+    )
+
+    return envFiles
+  } catch (e) {
+    if (e.code === 'ENOENT') {
+      const error = new Error(`missing directory (${directory})`)
+      error.code = 'MISSING_DIRECTORY'
+
+      throw error
+    } else {
+      throw e
+    }
+  }
+}
+
+module.exports = findEnvFiles

package/src/lib/main.js

@@ -1,112 +1,26 @@
 const logger = require('./../shared/logger')
 const dotenv = require('dotenv')
-const dotenvExpand = require('dotenv-expand')
 
 // services
 const Encrypt = require('./services/encrypt')
 const Ls = require('./services/ls')
 const Get = require('./services/get')
+const Genexample = require('./services/genexample')
 
+// proxies to dotenv
 const config = function (options) {
   return dotenv.config(options)
 }
 
-const decrypt = function (encrypted, keyStr) {
-  try {
-    return dotenv.decrypt(encrypted, keyStr)
-  } catch (e) {
-    switch (e.code) {
-      case 'DECRYPTION_FAILED':
-        // more helpful error when decryption fails
-        logger.error('[DECRYPTION_FAILED] Unable to decrypt .env.vault with DOTENV_KEY.')
-        logger.help('[DECRYPTION_FAILED] Run with debug flag [dotenvx run --debug -- yourcommand] or manually run [echo $DOTENV_KEY] to compare it to the one in .env.keys.')
-        logger.debug(`[DECRYPTION_FAILED] DOTENV_KEY is ${process.env.DOTENV_KEY}`)
-        process.exit(1)
-        break
-      default:
-        throw e
-    }
-  }
-}
-
 const configDotenv = function (options) {
   return dotenv.configDotenv(options)
 }
 
 const parse = function (src) {
-  const result = dotenv.parse(src)
-
-  logger.debug(result)
-
-  return result
-}
-
-const parseExpand = function (src, overload) {
-  const parsed = dotenv.parse(src)
-
-  // consider moving this logic straight into dotenv-expand
-  let inputParsed = {}
-  if (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]
-  }
-
-  logger.debug(result)
-
-  return result
-}
-
-const inject = function (processEnv = {}, parsed = {}, overload = false) {
-  if (typeof parsed !== 'object') {
-    throw new Error('OBJECT_REQUIRED: Please check the parsed argument being passed to inject')
-  }
-
-  const injected = new Set()
-  const preExisting = new Set()
-
-  // set processEnv
-  for (const key of Object.keys(parsed)) {
-    if (Object.prototype.hasOwnProperty.call(processEnv, key)) {
-      if (overload === true) {
-        processEnv[key] = parsed[key]
-        injected.add(key)
-
-        logger.verbose(`${key} set`)
-        logger.debug(`${key} set to ${parsed[key]}`)
-      } else {
-        preExisting.add(key)
-
-        logger.verbose(`${key} pre-exists (protip: use --overload to override)`)
-        logger.debug(`${key} pre-exists as ${processEnv[key]} (protip: use --overload to override)`)
-      }
-    } else {
-      processEnv[key] = parsed[key]
-      injected.add(key)
-
-      logger.verbose(`${key} set`)
-      logger.debug(`${key} set to ${parsed[key]}`)
-    }
-  }
-
-  return {
-    injected,
-    preExisting
-  }
+  return dotenv.parse(src)
 }
 
+// actions related
 const encrypt = function (directory, envFile) {
   return new Encrypt(directory, envFile).run()
 }
@@ -115,18 +29,43 @@ const ls = function (directory, envFile) {
   return new Ls(directory, envFile).run()
 }
 
+const genexample = function (directory, envFile) {
+  return new Genexample(directory, envFile).run()
+}
+
 const get = function (key, envFile, overload, all) {
   return new Get(key, envFile, overload, all).run()
 }
 
+// misc/cleanup
+const decrypt = function (encrypted, keyStr) {
+  try {
+    return dotenv.decrypt(encrypted, keyStr)
+  } catch (e) {
+    switch (e.code) {
+      case 'DECRYPTION_FAILED':
+        // more helpful error when decryption fails
+        logger.error('[DECRYPTION_FAILED] Unable to decrypt .env.vault with DOTENV_KEY.')
+        logger.help('[DECRYPTION_FAILED] Run with debug flag [dotenvx run --debug -- yourcommand] or manually run [echo $DOTENV_KEY] to compare it to the one in .env.keys.')
+        logger.debug(`[DECRYPTION_FAILED] DOTENV_KEY is ${process.env.DOTENV_KEY}`)
+        process.exit(1)
+        break
+      default:
+        throw e
+    }
+  }
+}
+
 module.exports = {
+  // dotenv proxies
   config,
   configDotenv,
-  decrypt,
   parse,
-  parseExpand,
-  inject,
+  // actions related
   encrypt,
   ls,
-  get
+  get,
+  genexample,
+  // misc/cleanup
+  decrypt
 }

package/src/lib/services/encrypt.js

@@ -6,12 +6,13 @@ const DotenvKeys = require('./../helpers/dotenvKeys')
 const DotenvVault = require('./../helpers/dotenvVault')
 
 const ENCODING = 'utf8'
-const RESERVED_ENV_FILES = ['.env.vault', '.env.project', '.env.keys', '.env.me', '.env.x']
+
+const findEnvFiles = require('../helpers/findEnvFiles')
 
 class Encrypt {
   constructor (directory = '.', envFile) {
     this.directory = directory
-    this.envFile = envFile || this._findEnvFiles()
+    this.envFile = envFile || findEnvFiles(directory)
     // calculated
     this.envKeysFilepath = path.resolve(this.directory, '.env.keys')
     this.envVaultFilepath = path.resolve(this.directory, '.env.vault')
@@ -112,17 +113,6 @@ class Encrypt {
 
     return dotenv.configDotenv(options).parsed
   }
-
-  _findEnvFiles () {
-    const files = fs.readdirSync(this.directory)
-    const envFiles = files.filter(file =>
-      file.startsWith('.env') &&
-      !file.endsWith('.previous') &&
-      !RESERVED_ENV_FILES.includes(file)
-    )
-
-    return envFiles
-  }
 }
 
 module.exports = Encrypt

package/src/lib/services/genexample.js

@@ -0,0 +1,94 @@
+const fs = require('fs')
+const path = require('path')
+const dotenv = require('dotenv')
+
+const ENCODING = 'utf8'
+
+const findEnvFiles = require('../helpers/findEnvFiles')
+
+class Genexample {
+  constructor (directory = '.', envFile) {
+    this.directory = directory
+    this.envFile = envFile || findEnvFiles(directory)
+  }
+
+  run () {
+    if (this.envFile.length < 1) {
+      const code = 'MISSING_ENV_FILES'
+      const message = 'no .env* files found'
+      const help = '? add one with [echo "HELLO=World" > .env] and then run [dotenvx genexample]'
+
+      const error = new Error(message)
+      error.code = code
+      error.help = help
+      throw error
+    }
+
+    const keys = new Set()
+    const addedKeys = new Set()
+    const envFilepaths = this._envFilepaths()
+
+    for (const envFilepath of envFilepaths) {
+      const filepath = path.resolve(this.directory, envFilepath)
+      if (!fs.existsSync(filepath)) {
+        const code = 'MISSING_ENV_FILE'
+        const message = `file does not exist at [${filepath}]`
+        const help = `? add it with [echo "HELLO=World" > ${envFilepath}] and then run [dotenvx genexample]`
+
+        const error = new Error(message)
+        error.code = code
+        error.help = help
+        throw error
+      }
+
+      const parsed = dotenv.configDotenv({ path: filepath }).parsed
+      for (const key of Object.keys(parsed)) {
+        keys.add(key)
+      }
+    }
+
+    let envExampleFile = ''
+    const exampleFilename = '.env.example'
+    const exampleFilepath = path.resolve(this.directory, exampleFilename)
+    if (!fs.existsSync(exampleFilepath)) {
+      envExampleFile += `# ${exampleFilename}\n`
+    } else {
+      envExampleFile = fs.readFileSync(exampleFilepath, ENCODING)
+    }
+
+    const currentEnvExample = dotenv.configDotenv({ path: exampleFilepath }).parsed
+    const injected = {}
+    const preExisted = {}
+
+    for (const key of [...keys]) {
+      if (key in currentEnvExample) {
+        preExisted[key] = currentEnvExample[key]
+      } else {
+        envExampleFile += `${key}=""\n`
+
+        addedKeys.add(key)
+
+        injected[key] = ''
+      }
+    }
+
+    return {
+      envExampleFile,
+      envFile: this.envFile,
+      exampleFilepath,
+      addedKeys: [...addedKeys],
+      injected,
+      preExisted
+    }
+  }
+
+  _envFilepaths () {
+    if (!Array.isArray(this.envFile)) {
+      return [this.envFile]
+    }
+
+    return this.envFile
+  }
+}
+
+module.exports = Genexample