@dotenvx/dotenvx 1.8.0 → 1.9.1

package/CHANGELOG.md

@@ -2,11 +2,33 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
-## [Unreleased](https://github.com/dotenvx/dotenvx/compare/v1.8.0...main)
+## [Unreleased](https://github.com/dotenvx/dotenvx/compare/v1.9.1...main)
+
+## 1.9.1
+
+### Added
+
+* warn if private key is missing or blank ([#349](https://github.com/dotenvx/dotenvx/pull/349))
+
+## 1.9.0
+
+### Added
+
+* add `--exclude-key` (`-ek`) option to `dotenvx encrypt` and `dotenvx decrypt` ([#344](https://github.com/dotenvx/dotenvx/pull/344))
+
+### Changed
+
+* preserve comments and spacing on first-time generation of .env.example file ([#346](https://github.com/dotenvx/dotenvx/pull/346))
+
+### Removed
+
+* removed `winston` - logger simplified to use `console.log` going forward ([#347](https://github.com/dotenvx/dotenvx/pull/347))
+
+## 1.8.0
 
 ### Added
 
-* warn when decryption fails on `run` or `get` ([#339](https://github.com/dotenvx/dotenvx/pull/339))
+* warn when decryption fails on `run` ([#339](https://github.com/dotenvx/dotenvx/pull/339))
 * decrypt expanded values as necessary ([#336](https://github.com/dotenvx/dotenvx/pull/336))
 
 ### Changed

package/README.md

@@ -27,31 +27,31 @@ console.log(`Hello ${process.env.HELLO}`)
 
 or install globally - *unlocks dotenv for any language, framework, or platform!*
 
-<details><summary>with brew 🍺</summary><br>
+<details><summary>with curl 🌐 </summary><br>
 
 ```sh
-brew install dotenvx/brew/dotenvx
+curl -sfS https://dotenvx.sh | sh
 dotenvx help
 ```
 
-[![brew installs](https://img.shields.io/github/downloads/dotenvx/dotenvx/total?label=brew%20installs)](https://github.com/dotenvx/homebrew-brew/blob/main/Formula/dotenvx.rb)
-<sup>*homebrew installs sourced from github releases - <a href="https://github.com/dotenvx/homebrew-brew/blob/main/Formula/dotenvx.rb">formula</a></sup>
+[![mac](https://img.shields.io/endpoint?url=https://dotenvx.sh/stats/curl/darwin&label=mac)](https://github.com/dotenvx/dotenvx.sh/blob/main/install.sh)
+[![linux](https://img.shields.io/endpoint?url=https://dotenvx.sh/stats/curl/linux&label=linux)](https://github.com/dotenvx/dotenvx.sh/blob/main/install.sh)
+[![windows](https://img.shields.io/endpoint?url=https://dotenvx.sh/stats/curl/windows&label=windows)](https://github.com/dotenvx/dotenvx.sh/blob/main/install.sh)
+<sup>*curl installs sourced from npm binary packages - <a href="https://www.npmjs.com/package/@dotenvx/dotenvx-linux-x86_64">example</a></sup>
 
 &nbsp;
 
 </details>
 
-<details><summary>with curl 🌐 </summary><br>
+<details><summary>with brew 🍺</summary><br>
 
 ```sh
-curl -sfS https://dotenvx.sh | sh
+brew install dotenvx/brew/dotenvx
 dotenvx help
 ```
 
-[![mac](https://img.shields.io/endpoint?url=https://dotenvx.sh/stats/curl/darwin&label=mac)](https://github.com/dotenvx/dotenvx.sh/blob/main/install.sh)
-[![linux](https://img.shields.io/endpoint?url=https://dotenvx.sh/stats/curl/linux&label=linux)](https://github.com/dotenvx/dotenvx.sh/blob/main/install.sh)
-[![windows](https://img.shields.io/endpoint?url=https://dotenvx.sh/stats/curl/windows&label=windows)](https://github.com/dotenvx/dotenvx.sh/blob/main/install.sh)
-<sup>*curl installs sourced from npm binary packages - <a href="https://www.npmjs.com/package/@dotenvx/dotenvx-linux-x86_64">example</a></sup>
+[![brew installs](https://img.shields.io/github/downloads/dotenvx/dotenvx/total?label=brew%20installs)](https://github.com/dotenvx/homebrew-brew/blob/main/Formula/dotenvx.rb)
+<sup>*homebrew installs sourced from github releases - <a href="https://github.com/dotenvx/homebrew-brew/blob/main/Formula/dotenvx.rb">formula</a></sup>
 
 &nbsp;
 
@@ -866,7 +866,7 @@ More examples
   </details>
 * <details><summary>`run --verbose`</summary><br>
 
-  Set log level to `verbose`. ([log levels](https://github.com/winstonjs/winston?tab=readme-ov-file#logging))
+  Set log level to `verbose`. ([log levels](https://docs.npmjs.com/cli/v8/using-npm/logging#setting-log-levels))
 
   ```sh
   $ echo "HELLO=production" > .env.production
@@ -882,7 +882,7 @@ More examples
   </details>
 * <details><summary>`run --debug`</summary><br>
 
-  Set log level to `debug`. ([log levels](https://github.com/winstonjs/winston?tab=readme-ov-file#logging))
+  Set log level to `debug`. ([log levels](https://docs.npmjs.com/cli/v8/using-npm/logging#setting-log-levels))
 
   ```sh
   $ echo "HELLO=production" > .env.production
@@ -904,7 +904,7 @@ More examples
   </details>
 * <details><summary>`run --quiet`</summary><br>
 
-  Use `--quiet` to suppress all output (except errors). ([log levels](https://github.com/winstonjs/winston?tab=readme-ov-file#logging))
+  Use `--quiet` to suppress all output (except errors). ([log levels](https://docs.npmjs.com/cli/v8/using-npm/logging#setting-log-levels))
 
   ```sh
   $ echo "HELLO=production" > .env.production
@@ -927,7 +927,7 @@ More examples
   Hello production
   ```
 
-  Available log levels are `error, warn, info, verbose, debug, silly` ([source](https://github.com/winstonjs/winston?tab=readme-ov-file#logging))
+  Available log levels are `error, warn, info, verbose, debug, silly` ([source](https://docs.npmjs.com/cli/v8/using-npm/logging#setting-log-levels))
 
   </details>
 * <details><summary>`run --convention=nextjs`</summary><br>

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.8.0",
+  "version": "1.9.1",
   "name": "@dotenvx/dotenvx",
   "description": "a better dotenv–from the creator of `dotenv`",
   "author": "@motdotla",
@@ -46,7 +46,6 @@
     "picomatch": "^4.0.2",
     "tinyexec": "^0.2.0",
     "which": "^4.0.0",
-    "winston": "^3.11.0",
     "xxhashjs": "^0.2.2"
   },
   "devDependencies": {

package/src/cli/actions/decrypt.js

@@ -13,7 +13,7 @@ function decrypt () {
   if (options.stdout) {
     const {
       processedEnvFiles
-    } = main.decrypt(options.envFile, options.key)
+    } = main.decrypt(options.envFile, options.key, options.excludeKey)
 
     for (const processedEnvFile of processedEnvFiles) {
       process.stdout.write(processedEnvFile.envSrc)
@@ -25,7 +25,7 @@ function decrypt () {
         processedEnvFiles,
         changedFilepaths,
         unchangedFilepaths
-      } = main.decrypt(options.envFile, options.key)
+      } = main.decrypt(options.envFile, options.key, options.excludeKey)
 
       for (const processedEnvFile of processedEnvFiles) {
         logger.verbose(`decrypting ${processedEnvFile.envFilepath} (${processedEnvFile.filepath})`)

package/src/cli/actions/encrypt.js

@@ -15,7 +15,7 @@ function encrypt () {
   if (options.stdout) {
     const {
       processedEnvFiles
-    } = main.encrypt(options.envFile, options.key)
+    } = main.encrypt(options.envFile, options.key, options.excludeKey)
 
     for (const processedEnvFile of processedEnvFiles) {
       process.stdout.write(processedEnvFile.envSrc)
@@ -27,7 +27,7 @@ function encrypt () {
         processedEnvFiles,
         changedFilepaths,
         unchangedFilepaths
-      } = main.encrypt(options.envFile, options.key)
+      } = main.encrypt(options.envFile, options.key, options.excludeKey)
 
       for (const processedEnvFile of processedEnvFiles) {
         logger.verbose(`encrypting ${processedEnvFile.envFilepath} (${processedEnvFile.filepath})`)

package/src/cli/actions/ext/genexample.js

@@ -20,9 +20,6 @@ function genexample (directory) {
 
     logger.verbose(`loading env from ${envFile}`)
 
-    // TODO: display pre-existing
-    // TODO: display added/appended/injected
-
     fs.writeFileSync(exampleFilepath, envExampleFile, ENCODING)
 
     if (addedKeys.length > 0) {

package/src/cli/dotenvx.js

@@ -100,6 +100,7 @@ program.command('encrypt')
   .description('convert .env file(s) to encrypted .env file(s)')
   .option('-f, --env-file <paths...>', 'path(s) to your env file(s)')
   .option('-k, --key <keys...>', 'keys(s) to encrypt (default: all keys in file)')
+  .option('-ek, --exclude-key <excludeKeys...>', 'keys(s) to exclude from encryption (default: none)')
   .option('--stdout', 'send to stdout')
   .action(encryptAction)
 
@@ -109,6 +110,7 @@ program.command('decrypt')
   .description('convert encrypted .env file(s) to plain .env file(s)')
   .option('-f, --env-file <paths...>', 'path(s) to your env file(s)')
   .option('-k, --key <keys...>', 'keys(s) to decrypt (default: all keys in file)')
+  .option('-ek, --exclude-key <excludeKeys...>', 'keys(s) to exclude from decryption (default: none)')
   .option('--stdout', 'send to stdout')
   .action(decryptAction)
 
@@ -132,40 +134,8 @@ program.command('help [command]')
 program.addCommand(require('./commands/ext'))
 
 //
-// DEPRECATED or MOVED
+// MOVED
 //
-const lsAction = require('./actions/ext/ls')
-program.command('ls')
-  .description('DEPRECATED: moved to [dotenvx ext ls]')
-  .argument('[directory]', 'directory to list .env files from', '.')
-  .option('-f, --env-file <filenames...>', 'path(s) to your env file(s)', '.env*')
-  .action(function (...args) {
-    logger.warn('DEPRECATION NOTICE: [ls] has moved to [dotenvx ext ls]')
-
-    lsAction.apply(this, args)
-  })
-
-const genexampleAction = require('./actions/ext/genexample')
-program.command('genexample')
-  .description('DEPRECATED: moved to [dotenvx ext genexample]')
-  .argument('[directory]', 'directory to generate from', '.')
-  .option('-f, --env-file <paths...>', 'path(s) to your env file(s)', '.env')
-  .action(function (...args) {
-    logger.warn('DEPRECATION NOTICE: [genexample] has moved to [dotenvx ext genexample]')
-
-    genexampleAction.apply(this, args)
-  })
-
-const gitignoreAction = require('./actions/ext/gitignore')
-program.command('gitignore')
-  .description('DEPRECATED: moved to [dotenvx ext gitignore]')
-  .addHelpText('after', examples.gitignore)
-  .action(function (...args) {
-    logger.warn('DEPRECATION NOTICE: [gitignore] has moved to [dotenvx ext gitignore]')
-
-    gitignoreAction.apply(this, args)
-  })
-
 const prebuildAction = require('./actions/ext/prebuild')
 program.command('prebuild')
   .description('DEPRECATED: moved to [dotenvx ext prebuild]')
@@ -187,15 +157,6 @@ program.command('precommit')
     precommitAction.apply(this, args)
   })
 
-const scanAction = require('./actions/ext/scan')
-program.command('scan')
-  .description('DEPRECATED: moved to [dotenvx ext scan]')
-  .action(function (...args) {
-    logger.warn('DEPRECATION NOTICE: [scan] has moved to [dotenvx ext scan]')
-
-    scanAction.apply(this, args)
-  })
-
 // overide helpInformation to hide DEPRECATED commands
 program.helpInformation = function () {
   const originalHelp = Command.prototype.helpInformation.call(this)

package/src/lib/helpers/decryptValue.js

@@ -3,35 +3,41 @@ const { decrypt } = require('eciesjs')
 const PREFIX = 'encrypted:'
 
 function decryptValue (value, privateKey) {
+  let decryptedValue
+  let decryptionError
+
   if (!value.startsWith(PREFIX)) {
     return value
   }
 
-  const privateKeys = privateKey.split(',')
-
-  let decryptedValue
-  let decryptionError
-  for (const key of privateKeys) {
-    const secret = Buffer.from(key, 'hex')
-    const encoded = value.substring(PREFIX.length)
-    const ciphertext = Buffer.from(encoded, 'base64')
-
-    try {
-      decryptedValue = decrypt(secret, ciphertext).toString()
-      decryptionError = null // reset to null error (scenario for multiple private keys)
-      break
-    } catch (e) {
-      if (e.message === 'Invalid private key') {
-        decryptionError = new Error('private key looks invalid')
-      } else if (e.message === 'Unsupported state or unable to authenticate data') {
-        decryptionError = new Error('private key looks wrong')
-      } else if (e.message === 'Point of length 65 was invalid. Expected 33 compressed bytes or 65 uncompressed bytes') {
-        decryptionError = new Error('encrypted data looks malformed')
-      } else {
-        decryptionError = new Error(`${e.message}`)
+  privateKey = privateKey || ''
+  if (privateKey.length <= 0) {
+    decryptionError = new Error('private key missing or blank')
+    decryptionError.code = 'DECRYPTION_FAILED'
+  } else {
+    const privateKeys = privateKey.split(',')
+    for (const key of privateKeys) {
+      const secret = Buffer.from(key, 'hex')
+      const encoded = value.substring(PREFIX.length)
+      const ciphertext = Buffer.from(encoded, 'base64')
+
+      try {
+        decryptedValue = decrypt(secret, ciphertext).toString()
+        decryptionError = null // reset to null error (scenario for multiple private keys)
+        break
+      } catch (e) {
+        if (e.message === 'Invalid private key') {
+          decryptionError = new Error('private key looks invalid')
+        } else if (e.message === 'Unsupported state or unable to authenticate data') {
+          decryptionError = new Error('private key looks wrong')
+        } else if (e.message === 'Point of length 65 was invalid. Expected 33 compressed bytes or 65 uncompressed bytes') {
+          decryptionError = new Error('encrypted data looks malformed')
+        } else {
+          decryptionError = new Error(`${e.message}`)
+        }
+
+        decryptionError.code = 'DECRYPTION_FAILED'
       }
-
-      decryptionError.code = 'DECRYPTION_FAILED'
     }
   }
 

package/src/lib/helpers/parseDecryptEvalExpand.js

@@ -4,8 +4,8 @@ const dotenvExpand = require('./dotenvExpand')
 const decryptValue = require('./decryptValue')
 const truncate = require('./truncate')
 
-function warning (e, key, privateKey) {
-  const warning = new Error(`[${e.code}] could not decrypt ${key} using private key ${truncate(privateKey)}`)
+function warning (e, key, privateKey = null) {
+  const warning = new Error(`[${e.code}] could not decrypt ${key} using private key '${truncate(privateKey)}'`)
   warning.code = e.code
   warning.help = `[${e.code}] ? ${e.message}`
 
@@ -17,14 +17,12 @@ function parseDecryptEvalExpand (src, privateKey = null, processEnv = process.en
 
   // parse
   const parsed = dotenv.parse(src)
-  if (privateKey && privateKey.length > 0) {
-    for (const key in parsed) {
-      try {
-        const decryptedValue = decryptValue(parsed[key], privateKey)
-        parsed[key] = decryptedValue
-      } catch (_e) {
-        // do nothing. warnings tracked further below.
-      }
+  for (const key in parsed) {
+    try {
+      const decryptedValue = decryptValue(parsed[key], privateKey)
+      parsed[key] = decryptedValue
+    } catch (_e) {
+      // do nothing. warnings tracked further below.
     }
   }
 
@@ -41,22 +39,20 @@ function parseDecryptEvalExpand (src, privateKey = null, processEnv = process.en
     parsed: evaled
   }
   const expanded = dotenvExpand.expand(inputEvaled)
-  if (privateKey && privateKey.length > 0) {
-    for (const key in expanded.parsed) {
-      try {
-        const decryptedValue = decryptValue(expanded.parsed[key], privateKey)
-        expanded.parsed[key] = decryptedValue
-      } catch (e) {
-        warnings.push(warning(e, key, privateKey))
-      }
+  for (const key in expanded.parsed) {
+    try {
+      const decryptedValue = decryptValue(expanded.parsed[key], privateKey)
+      expanded.parsed[key] = decryptedValue
+    } catch (e) {
+      warnings.push(warning(e, key, privateKey))
     }
-    for (const key in processEnv) {
-      try {
-        const decryptedValue = decryptValue(processEnv[key], privateKey)
-        processEnv[key] = decryptedValue
-      } catch (e) {
-        warnings.push(warning(e, key, privateKey))
-      }
+  }
+  for (const key in processEnv) {
+    try {
+      const decryptedValue = decryptValue(processEnv[key], privateKey)
+      processEnv[key] = decryptedValue
+    } catch (e) {
+      warnings.push(warning(e, key, privateKey))
     }
   }
 

package/src/lib/helpers/truncate.js

@@ -1,6 +1,10 @@
 function truncate (str, showChar = 7) {
-  const visiblePart = str.slice(0, showChar)
-  return visiblePart + '…'
+  if (str && str.length > 0) {
+    const visiblePart = str.slice(0, showChar)
+    return visiblePart + '…'
+  } else {
+    return ''
+  }
 }
 
 module.exports = truncate

package/src/lib/main.js

@@ -189,13 +189,13 @@ const set = function (key, value, envFile, encrypt) {
 }
 
 /** @type {import('./main').encrypt} */
-const encrypt = function (envFile, key) {
-  return new Encrypt(envFile, key).run()
+const encrypt = function (envFile, key, excludeKey) {
+  return new Encrypt(envFile, key, excludeKey).run()
 }
 
 /** @type {import('./main').encrypt} */
-const decrypt = function (envFile, key) {
-  return new Decrypt(envFile, key).run()
+const decrypt = function (envFile, key, excludeKey) {
+  return new Decrypt(envFile, key, excludeKey).run()
 }
 
 /** @type {import('./main').status} */

package/src/lib/services/decrypt.js

@@ -14,10 +14,12 @@ class Decrypt {
   /**
    * @param {string|string[]} [envFile]
    * @param {string|string[]} [key]
+   * @param {string|string[]} [excludeKey]
    **/
-  constructor (envFile = '.env', key = []) {
+  constructor (envFile = '.env', key = [], excludeKey = []) {
     this.envFile = envFile
     this.key = key
+    this.excludeKey = excludeKey
     this.processedEnvFiles = []
     this.changedFilepaths = new Set()
     this.unchangedFilepaths = new Set()
@@ -26,6 +28,7 @@ class Decrypt {
   run () {
     const envFilepaths = this._envFilepaths()
     const keys = this._keys()
+    const excludeKeys = this._excludeKeys()
     for (const envFilepath of envFilepaths) {
       const filepath = path.resolve(envFilepath)
 
@@ -49,17 +52,25 @@ class Decrypt {
         // iterate over all non-encrypted values and encrypt them
         const parsed = dotenv.parse(src)
         for (const [key, value] of Object.entries(parsed)) {
-          if (keys.length < 1 || keys.includes(key)) { // optionally control which key to decrypt
-            const encrypted = isEncrypted(key, value)
-            if (encrypted) {
-              row.keys.push(key) // track key(s)
+          // key excluded - don't decrypt it
+          if (excludeKeys.includes(key)) {
+            continue
+          }
+
+          // key effectively excluded (by not being in the list of includes) - don't encrypt it
+          if (keys.length > 0 && !keys.includes(key)) {
+            continue
+          }
+
+          const encrypted = isEncrypted(key, value)
+          if (encrypted) {
+            row.keys.push(key) // track key(s)
 
-              const decryptedValue = decryptValue(value, privateKey)
-              // once newSrc is built write it out
-              src = replace(src, key, decryptedValue)
+            const decryptedValue = decryptValue(value, privateKey)
+            // once newSrc is built write it out
+            src = replace(src, key, decryptedValue)
 
-              row.changed = true // track change
-            }
+            row.changed = true // track change
           }
         }
 
@@ -106,6 +117,14 @@ class Decrypt {
 
     return this.key
   }
+
+  _excludeKeys () {
+    if (!Array.isArray(this.excludeKey)) {
+      return [this.excludeKey]
+    }
+
+    return this.excludeKey
+  }
 }
 
 module.exports = Decrypt

package/src/lib/services/encrypt.js

@@ -15,10 +15,12 @@ class Encrypt {
   /**
    * @param {string|string[]} [envFile]
    * @param {string|string[]} [key]
+   * @param {string|string[]} [excludeKey]
    **/
-  constructor (envFile = '.env', key = []) {
+  constructor (envFile = '.env', key = [], excludeKey = []) {
     this.envFile = envFile
     this.key = key
+    this.excludeKey = excludeKey
     this.processedEnvFiles = []
     this.changedFilepaths = new Set()
     this.unchangedFilepaths = new Set()
@@ -27,6 +29,7 @@ class Encrypt {
   run () {
     const envFilepaths = this._envFilepaths()
     const keys = this._keys()
+    const excludeKeys = this._excludeKeys()
     for (const envFilepath of envFilepaths) {
       const filepath = path.resolve(envFilepath)
 
@@ -63,19 +66,25 @@ class Encrypt {
         // iterate over all non-encrypted values and encrypt them
         const parsed = dotenv.parse(src)
         for (const [key, value] of Object.entries(parsed)) {
-          if (keys.length < 1 || keys.includes(key)) {
-            // optionally control which key to encrypt
-            const encrypted =
-              isEncrypted(key, value) || isPublicKey(key, value)
-            if (!encrypted) {
-              row.keys.push(key) // track key(s)
-
-              const encryptedValue = encryptValue(value, publicKey)
-              // once newSrc is built write it out
-              src = replace(src, key, encryptedValue)
-
-              row.changed = true // track change
-            }
+          // key excluded - don't encrypt it
+          if (excludeKeys.includes(key)) {
+            continue
+          }
+
+          // key effectively excluded (by not being in the list of includes) - don't encrypt it
+          if (keys.length > 0 && !keys.includes(key)) {
+            continue
+          }
+
+          const encrypted = isEncrypted(key, value) || isPublicKey(key, value)
+          if (!encrypted) {
+            row.keys.push(key) // track key(s)
+
+            const encryptedValue = encryptValue(value, publicKey)
+            // once newSrc is built write it out
+            src = replace(src, key, encryptedValue)
+
+            row.changed = true // track change
           }
         }
 
@@ -122,6 +131,14 @@ class Encrypt {
 
     return this.key
   }
+
+  _excludeKeys () {
+    if (!Array.isArray(this.excludeKey)) {
+      return [this.excludeKey]
+    }
+
+    return this.excludeKey
+  }
 }
 
 module.exports = Encrypt

package/src/lib/services/genexample.js

@@ -5,11 +5,15 @@ const dotenv = require('dotenv')
 const ENCODING = 'utf8'
 
 const findEnvFiles = require('../helpers/findEnvFiles')
+const replace = require('../helpers/replace')
 
 class Genexample {
   constructor (directory = '.', envFile) {
     this.directory = directory
     this.envFile = envFile || findEnvFiles(directory)
+
+    this.exampleFilename = '.env.example'
+    this.exampleFilepath = path.resolve(this.directory, this.exampleFilename)
   }
 
   run () {
@@ -27,6 +31,12 @@ class Genexample {
     const keys = new Set()
     const addedKeys = new Set()
     const envFilepaths = this._envFilepaths()
+    /** @type {Record<string, string>} */
+    const injected = {}
+    /** @type {Record<string, string>} */
+    const preExisted = {}
+
+    let exampleSrc = `# ${this.exampleFilename} - generated with dotenvx\n`
 
     for (const envFilepath of envFilepaths) {
       const filepath = path.resolve(this.directory, envFilepath)
@@ -41,43 +51,51 @@ class Genexample {
         throw error
       }
 
-      const parsed = dotenv.configDotenv({ path: filepath }).parsed
-      for (const key of Object.keys(parsed)) {
+      // get the original src
+      let src = fs.readFileSync(filepath, { encoding: ENCODING })
+      const parsed = dotenv.parse(src)
+      for (const key in parsed) {
+        // used later
         keys.add(key)
+
+        // once newSrc is built write it out
+        src = replace(src, key, '') // empty value
       }
-    }
 
-    let envExampleFile = ''
-    const exampleFilename = '.env.example'
-    const exampleFilepath = path.resolve(this.directory, exampleFilename)
-    if (!fs.existsSync(exampleFilepath)) {
-      envExampleFile += `# ${exampleFilename} - generated with dotenvx\n`
-    } else {
-      envExampleFile = fs.readFileSync(exampleFilepath, ENCODING)
+      exampleSrc += `\n${src}`
     }
 
-    const currentEnvExample = dotenv.configDotenv({ path: exampleFilepath }).parsed
-    /** @type {Record<string, string>} */
-    const injected = {}
-    /** @type {Record<string, string>} */
-    const preExisted = {}
-
-    for (const key of [...keys]) {
-      if (key in currentEnvExample) {
-        preExisted[key] = currentEnvExample[key]
-      } else {
-        envExampleFile += `${key}=""\n`
-
+    if (!fs.existsSync(this.exampleFilepath)) {
+      // it doesn't exist so just write this first generated one
+      // exampleSrc - already written to from the prior loop
+      for (const key of [...keys]) {
+        // every key is added since it's the first time generating .env.example
         addedKeys.add(key)
 
         injected[key] = ''
       }
+    } else {
+      // it already exists (which means the user might have it modified a way in which they prefer, so replace exampleSrc with their existing .env.example)
+      exampleSrc = fs.readFileSync(this.exampleFilepath, ENCODING)
+
+      const parsed = dotenv.parse(exampleSrc)
+      for (const key of [...keys]) {
+        if (key in parsed) {
+          preExisted[key] = parsed[key]
+        } else {
+          exampleSrc += `${key}=""\n`
+
+          addedKeys.add(key)
+
+          injected[key] = ''
+        }
+      }
     }
 
     return {
-      envExampleFile,
+      envExampleFile: exampleSrc,
       envFile: this.envFile,
-      exampleFilepath,
+      exampleFilepath: this.exampleFilepath,
       addedKeys: [...addedKeys],
       injected,
       preExisted

package/src/shared/logger.js

@@ -1,10 +1,3 @@
-const winston = require('winston')
-
-const printf = winston.format.printf
-const combine = winston.format.combine
-const createLogger = winston.createLogger
-const transports = winston.transports
-
 const packageJson = require('../lib/helpers/packageJson')
 const { getColor, bold } = require('./colors')
 
@@ -26,7 +19,6 @@ const levels = {
   help: 2,
   help2: 2,
   blank: 2,
-  http: 3,
   verbose: 4,
   debug: 5,
   silly: 6
@@ -38,14 +30,27 @@ const success = getColor('green')
 const successv = getColor('olive') // yellow-ish tint that 'looks' like dotenv
 const help = getColor('blue')
 const help2 = getColor('gray')
-const http = getColor('green')
 const verbose = getColor('plum')
 const debug = getColor('plum')
 
-const dotenvxFormat = printf(({ level, message, label, timestamp }) => {
+let currentLevel = levels.info // default log level
+
+function log (level, message) {
+  if (levels[level] === undefined) {
+    throw new Error(`MISSING_LOG_LEVEL: '${level}'. implement in logger.`)
+  }
+
+  if (levels[level] <= currentLevel) {
+    const formattedMessage = formatMessage(level, message)
+    console.log(formattedMessage)
+  }
+}
+
+function formatMessage (level, message) {
   const formattedMessage = typeof message === 'object' ? JSON.stringify(message) : message
 
   switch (level.toLowerCase()) {
+    // errors
     case 'error':
       return error(formattedMessage)
     case 'errorv':
@@ -56,6 +61,7 @@ const dotenvxFormat = printf(({ level, message, label, timestamp }) => {
       return error(`[dotenvx@${packageJson.version}][prebuild] ${formattedMessage}`)
     case 'errornocolor':
       return formattedMessage
+    // warns
     case 'warn':
       return warn(formattedMessage)
     case 'warnv':
@@ -64,6 +70,7 @@ const dotenvxFormat = printf(({ level, message, label, timestamp }) => {
       return warn(`[dotenvx@${packageJson.version}][precommit] ${formattedMessage}`)
     case 'warnvpb':
       return warn(`[dotenvx@${packageJson.version}][prebuild] ${formattedMessage}`)
+    // successes
     case 'success':
       return success(formattedMessage)
     case 'successv': // success with 'version'
@@ -72,35 +79,66 @@ const dotenvxFormat = printf(({ level, message, label, timestamp }) => {
       return success(`[dotenvx@${packageJson.version}][precommit] ${formattedMessage}`)
     case 'successvpb': // success with 'version' and precommit
       return success(`[dotenvx@${packageJson.version}][prebuild] ${formattedMessage}`)
+    // info
     case 'info':
       return formattedMessage
+    // help
     case 'help':
       return help(formattedMessage)
     case 'help2':
       return help2(formattedMessage)
-    case 'http':
-      return http(formattedMessage)
+    // verbose
     case 'verbose':
       return verbose(formattedMessage)
+    // debug
     case 'debug':
       return debug(formattedMessage)
+    // blank
     case 'blank': // custom
       return formattedMessage
   }
-})
+}
 
-const logger = createLogger({
+const logger = {
+  // track level
   level: 'info',
-  levels,
-  format: combine(
-    dotenvxFormat
-  ),
-  transports: [
-    new transports.Console()
-  ]
-})
 
-const setLogLevel = options => {
+  // errors
+  error: (msg) => log('error', msg),
+  errorv: (msg) => log('errorv', msg),
+  errorvp: (msg) => log('errorvp', msg),
+  errorvpb: (msg) => log('errorvpb', msg),
+  errornocolor: (msg) => log('errornocolor', msg),
+  // warns
+  warn: (msg) => log('warn', msg),
+  warnv: (msg) => log('warnv', msg),
+  warnvp: (msg) => log('warnvp', msg),
+  warnvpb: (msg) => log('warnvpb', msg),
+  // success
+  success: (msg) => log('success', msg),
+  successv: (msg) => log('successv', msg),
+  successvp: (msg) => log('successvp', msg),
+  successvpb: (msg) => log('successvpb', msg),
+  // info
+  info: (msg) => log('info', msg),
+  // help
+  help: (msg) => log('help', msg),
+  help2: (msg) => log('help2', msg),
+  // verbose
+  verbose: (msg) => log('verbose', msg),
+  // debug
+  debug: (msg) => log('debug', msg),
+  // blank
+  blank: (msg) => log('blank', msg),
+  setLevel: (level) => {
+    if (levels[level] !== undefined) {
+      currentLevel = levels[level]
+      logger.level = level
+    }
+  }
+}
+
+function setLogLevel (options) {
   const logLevel = options.debug
     ? 'debug'
     : options.verbose
@@ -110,7 +148,7 @@ const setLogLevel = options => {
         : options.logLevel
 
   if (!logLevel) return
-  logger.level = logLevel
+  logger.setLevel(logLevel)
   // Only log which level it's setting if it's not set to quiet mode
   if (!options.quiet || (options.quiet && logLevel !== 'error')) {
     logger.debug(`Setting log level to ${logLevel}`)
@@ -120,5 +158,6 @@ const setLogLevel = options => {
 module.exports = {
   logger,
   getColor,
-  setLogLevel
+  setLogLevel,
+  levels
 }