@dotenvx/dotenvx 1.59.0 → 1.60.0

package/src/lib/services/keypair.js

@@ -1,22 +1,38 @@
 const {
   keyNames,
-  keyValues
+  keyValues,
+  keyValuesSync
 } = require('./../helpers/keyResolution')
 
 class Keypair {
-  constructor (envFile = '.env', envKeysFilepath = null, opsOn = false) {
+  constructor (envFile = '.env', envKeysFilepath = null, noOps = false) {
     this.envFile = envFile
     this.envKeysFilepath = envKeysFilepath
-    this.opsOn = opsOn
+    this.noOps = noOps
   }
 
-  run () {
+  runSync () {
     const out = {}
 
     const filepaths = this._filepaths()
     for (const filepath of filepaths) {
       const { publicKeyName, privateKeyName } = keyNames(filepath)
-      const { publicKeyValue, privateKeyValue } = keyValues(filepath, { keysFilepath: this.envKeysFilepath, opsOn: this.opsOn })
+      const { publicKeyValue, privateKeyValue } = keyValuesSync(filepath, { keysFilepath: this.envKeysFilepath, noOps: this.noOps })
+
+      out[publicKeyName] = publicKeyValue
+      out[privateKeyName] = privateKeyValue
+    }
+
+    return out
+  }
+
+  async run () {
+    const out = {}
+
+    const filepaths = this._filepaths()
+    for (const filepath of filepaths) {
+      const { publicKeyName, privateKeyName } = keyNames(filepath)
+      const { publicKeyValue, privateKeyValue } = await keyValues(filepath, { keysFilepath: this.envKeysFilepath, noOps: this.noOps })
 
       out[publicKeyName] = publicKeyValue
       out[privateKeyName] = privateKeyValue

package/src/lib/services/prebuild.js

@@ -7,7 +7,6 @@ const Ls = require('../services/ls')
 const Errors = require('../helpers/errors')
 
 const isFullyEncrypted = require('./../helpers/isFullyEncrypted')
-const packageJson = require('./../helpers/packageJson')
 const MISSING_DOCKERIGNORE = '.env.keys' // by default only ignore .env.keys. all other .env* files COULD be included - as long as they are encrypted
 
 class Prebuild {
@@ -26,12 +25,12 @@ class Prebuild {
     // 1. check for .dockerignore file
     if (!fsx.existsSync('.dockerignore')) {
       const warning = new Errors({
-        message: `[dotenvx@${packageJson.version}][prebuild] .dockerignore missing`,
+        message: '.dockerignore missing',
         help: 'fix: [touch .dockerignore]'
       }).custom()
       warnings.push(warning)
     } else {
-      dockerignore = fsx.readFileX('.dockerignore')
+      dockerignore = fsx.readFileXSync('.dockerignore')
     }
 
     // 2. check .env* files against .dockerignore file
@@ -47,22 +46,22 @@ class Prebuild {
       if (ig.ignores(file)) {
         if (file === '.env.example' || file === '.env.x') {
           const warning = new Errors({
-            message: `[dotenvx@${packageJson.version}][prebuild] ${file} (currently ignored but should not be)`,
+            message: `${file} ignored (should not be)`,
             help: `fix: [dotenvx ext gitignore --pattern !${file}]`
           }).custom()
           warnings.push(warning)
         }
       } else {
         if (file !== '.env.example' && file !== '.env.x') {
-          const src = fsx.readFileX(file)
+          const src = fsx.readFileXSync(file)
           const encrypted = isFullyEncrypted(src)
 
           // if contents are encrypted don't raise an error
           if (!encrypted) {
-            let errorMsg = `[dotenvx@${packageJson.version}][prebuild] ${file} not protected (encrypted or dockerignored)`
+            let errorMsg = `${file} not encrypted/dockerignored`
             let errorHelp = `fix: [dotenvx encrypt -f ${file}] or [dotenvx ext gitignore --pattern ${file}]`
             if (file.includes('.env.keys')) {
-              errorMsg = `[dotenvx@${packageJson.version}][prebuild] ${file} not protected (dockerignored)`
+              errorMsg = `${file} not dockerignored`
               errorHelp = `fix: [dotenvx ext gitignore --pattern ${file}]`
             }
 
@@ -72,11 +71,7 @@ class Prebuild {
       }
     })
 
-    let successMessage = `[dotenvx@${packageJson.version}][prebuild] .env files (${count}) protected (encrypted or dockerignored)`
-
-    if (count === 0) {
-      successMessage = `[dotenvx@${packageJson.version}][prebuild] zero .env files`
-    }
+    let successMessage = count === 0 ? '▣ no .env files' : `▣ encrypted/dockerignored (${count})`
     if (warnings.length > 0) {
       successMessage += ` with warnings (${warnings.length})`
     }

package/src/lib/services/precommit.js

@@ -6,7 +6,6 @@ const ignore = require('ignore')
 const Ls = require('../services/ls')
 
 const isFullyEncrypted = require('./../helpers/isFullyEncrypted')
-const packageJson = require('./../helpers/packageJson')
 const InstallPrecommitHook = require('./../helpers/installPrecommitHook')
 const Errors = require('./../helpers/errors')
 const childProcess = require('child_process')
@@ -39,12 +38,12 @@ class Precommit {
       // 1. check for .gitignore file
       if (!fsx.existsSync('.gitignore')) {
         const warning = new Errors({
-          message: `[dotenvx@${packageJson.version}][precommit] .gitignore missing`,
+          message: '.gitignore missing',
           help: 'fix: [touch .gitignore]'
         }).custom()
         warnings.push(warning)
       } else {
-        gitignore = fsx.readFileX('.gitignore')
+        gitignore = fsx.readFileXSync('.gitignore')
       }
 
       // 2. check .env* files against .gitignore file
@@ -63,22 +62,22 @@ class Precommit {
           if (ig.ignores(file)) {
             if (file === '.env.example' || file === '.env.x') {
               const warning = new Errors({
-                message: `[dotenvx@${packageJson.version}][precommit] ${file} (currently ignored but should not be)`,
+                message: `${file} ignored (should not be)`,
                 help: `fix: [dotenvx ext gitignore --pattern !${file}]`
               }).custom()
               warnings.push(warning)
             }
           } else {
             if (file !== '.env.example' && file !== '.env.x') {
-              const src = fsx.readFileX(file)
+              const src = fsx.readFileXSync(file)
               const encrypted = isFullyEncrypted(src)
 
               // if contents are encrypted don't raise an error
               if (!encrypted) {
-                let errorMsg = `[dotenvx@${packageJson.version}][precommit] ${file} not protected (encrypted or gitignored)`
+                let errorMsg = `${file} not encrypted/gitignored`
                 let errorHelp = `fix: [dotenvx encrypt -f ${file}] or [dotenvx ext gitignore --pattern ${file}]`
                 if (file.includes('.env.keys')) {
-                  errorMsg = `[dotenvx@${packageJson.version}][precommit] ${file} not protected (gitignored)`
+                  errorMsg = `${file} not gitignored`
                   errorHelp = `fix: [dotenvx ext gitignore --pattern ${file}]`
                 }
 
@@ -89,10 +88,7 @@ class Precommit {
         }
       })
 
-      let successMessage = `[dotenvx@${packageJson.version}][precommit] .env files (${count}) protected (encrypted or gitignored)`
-      if (count === 0) {
-        successMessage = `[dotenvx@${packageJson.version}][precommit] zero .env files`
-      }
+      let successMessage = count === 0 ? '▣ no .env files' : `▣ encrypted/gitignored (${count})`
       if (warnings.length > 0) {
         successMessage += ` with warnings (${warnings.length})`
       }

package/src/lib/services/rotate.js

@@ -29,12 +29,12 @@ const dotenvParse = require('./../helpers/dotenvParse')
 const detectEncoding = require('./../helpers/detectEncoding')
 
 class Rotate {
-  constructor (envs = [], key = [], excludeKey = [], envKeysFilepath = null, opsOn = false) {
+  constructor (envs = [], key = [], excludeKey = [], envKeysFilepath = null, noOps = false) {
     this.envs = determine(envs, process.env)
     this.key = key
     this.excludeKey = excludeKey
     this.envKeysFilepath = envKeysFilepath
-    this.opsOn = opsOn
+    this.noOps = noOps
 
     this.processedEnvs = []
     this.changedFilepaths = new Set()
@@ -43,7 +43,7 @@ class Rotate {
     this.envKeysSources = {}
   }
 
-  run () {
+  async run () {
     // example
     // envs [
     //   { type: 'envFile', value: '.env' }
@@ -57,7 +57,7 @@ class Rotate {
 
     for (const env of this.envs) {
       if (env.type === TYPE_ENV_FILE) {
-        this._rotateEnvFile(env.value)
+        await this._rotateEnvFile(env.value)
       }
     }
 
@@ -68,7 +68,7 @@ class Rotate {
     }
   }
 
-  _rotateEnvFile (envFilepath) {
+  async _rotateEnvFile (envFilepath) {
     const row = {}
     row.keys = []
     row.type = TYPE_ENV_FILE
@@ -78,31 +78,29 @@ class Rotate {
     row.envFilepath = envFilepath
 
     try {
-      const encoding = detectEncoding(filepath)
-      let envSrc = fsx.readFileX(filepath, { encoding })
+      const encoding = await detectEncoding(filepath)
+      let envSrc = await fsx.readFileX(filepath, { encoding })
       const envParsed = dotenvParse(envSrc)
 
       const { publicKeyName, privateKeyName } = keyNames(envFilepath)
-      const { privateKeyValue } = keyValues(envFilepath, { keysFilepath: this.envKeysFilepath, opsOn: this.opsOn })
+      const { privateKeyValue } = await keyValues(envFilepath, { keysFilepath: this.envKeysFilepath, noOps: this.noOps })
 
       let newPublicKey
       let newPrivateKey
       let envKeysFilepath
       let envKeysSrc
 
-      if (this.opsOn) {
-        const kp = opsKeypair()
+      if (!this.noOps) {
+        const kp = await opsKeypair()
         newPublicKey = kp.publicKey
         newPrivateKey = kp.privateKey
 
         row.privateKeyAdded = false // TODO: change to localPrivateKeyAdded
       } else {
-        envKeysFilepath = path.join(path.dirname(filepath), '.env.keys')
-        if (this.envKeysFilepath) {
-          envKeysFilepath = path.resolve(this.envKeysFilepath)
-        }
-        row.envKeysFilepath = envKeysFilepath
-        this.envKeysSources[envKeysFilepath] ||= fsx.readFileX(envKeysFilepath, { encoding: detectEncoding(envKeysFilepath) })
+        row.envKeysFilepath = this.envKeysFilepath || path.join(path.dirname(envFilepath), '.env.keys')
+        envKeysFilepath = path.resolve(row.envKeysFilepath)
+        const encodingForKeys = await detectEncoding(envKeysFilepath)
+        this.envKeysSources[envKeysFilepath] ||= await fsx.readFileX(envKeysFilepath, { encoding: encodingForKeys })
         envKeysSrc = this.envKeysSources[envKeysFilepath]
 
         const kp = localKeypair()
@@ -145,7 +143,7 @@ class Rotate {
       row.privateKeyName = privateKeyName
       row.privateKey = newPrivateKey
 
-      if (!this.opsOn) {
+      if (this.noOps) {
         // keys src only for ops
         envKeysSrc = append(envKeysSrc, privateKeyName, newPrivateKey) // append privateKey
         this.envKeysSources[envKeysFilepath] = envKeysSrc
@@ -155,7 +153,13 @@ class Rotate {
       this.changedFilepaths.add(envFilepath)
     } catch (e) {
       if (e.code === 'ENOENT') {
-        row.error = new Errors({ envFilepath, filepath }).missingEnvFile()
+        const missingPath = e.path ? path.resolve(e.path) : null
+        const expectedEnvKeysPath = row.envKeysFilepath ? path.resolve(row.envKeysFilepath) : null
+        if (this.noOps && expectedEnvKeysPath && missingPath === expectedEnvKeysPath) {
+          row.error = new Errors({ envKeysFilepath: row.envKeysFilepath }).missingEnvKeysFile()
+        } else {
+          row.error = new Errors({ envFilepath, filepath }).missingEnvFile()
+        }
       } else {
         row.error = e
       }

package/src/lib/services/run.js

@@ -7,10 +7,12 @@ const TYPE_ENV_FILE = 'envFile'
 const Parse = require('./../helpers/parse')
 const Errors = require('./../helpers/errors')
 const detectEncoding = require('./../helpers/detectEncoding')
+const detectEncodingSync = require('./../helpers/detectEncodingSync')
 
 const {
   keyNames,
-  keyValues
+  keyValues,
+  keyValuesSync
 } = require('./../helpers/keyResolution')
 
 const {
@@ -18,12 +20,12 @@ const {
 } = require('./../helpers/envResolution')
 
 class Run {
-  constructor (envs = [], overload = false, processEnv = process.env, envKeysFilepath = null, opsOn = false) {
+  constructor (envs = [], overload = false, processEnv = process.env, envKeysFilepath = null, noOps = false) {
     this.envs = determine(envs, processEnv)
     this.overload = overload
     this.processEnv = processEnv
     this.envKeysFilepath = envKeysFilepath
-    this.opsOn = opsOn
+    this.noOps = noOps
 
     this.processedEnvs = []
     this.readableFilepaths = new Set()
@@ -32,7 +34,7 @@ class Run {
     this.beforeEnv = { ...this.processEnv }
   }
 
-  run () {
+  runSync () {
     // example
     // envs [
     //   { type: 'env', value: 'HELLO=one' },
@@ -42,7 +44,33 @@ class Run {
 
     for (const env of this.envs) {
       if (env.type === TYPE_ENV_FILE) {
-        this._injectEnvFile(env.value)
+        this._injectEnvFileSync(env.value)
+      } else if (env.type === TYPE_ENV) {
+        this._injectEnv(env.value)
+      }
+    }
+
+    return {
+      processedEnvs: this.processedEnvs,
+      readableStrings: [...this.readableStrings],
+      readableFilepaths: [...this.readableFilepaths],
+      uniqueInjectedKeys: [...this.uniqueInjectedKeys],
+      beforeEnv: this.beforeEnv,
+      afterEnv: { ...this.processEnv }
+    }
+  }
+
+  async run () {
+    // example
+    // envs [
+    //   { type: 'env', value: 'HELLO=one' },
+    //   { type: 'envFile', value: '.env' },
+    //   { type: 'env', value: 'HELLO=three' }
+    // ]
+
+    for (const env of this.envs) {
+      if (env.type === TYPE_ENV_FILE) {
+        await this._injectEnvFile(env.value)
       } else if (env.type === TYPE_ENV) {
         this._injectEnv(env.value)
       }
@@ -90,19 +118,64 @@ class Run {
     this.processedEnvs.push(row)
   }
 
-  _injectEnvFile (envFilepath) {
+  _injectEnvFileSync (envFilepath) {
+    const row = {}
+    row.type = TYPE_ENV_FILE
+    row.filepath = envFilepath
+
+    const filepath = path.resolve(envFilepath)
+    try {
+      const encoding = detectEncodingSync(filepath)
+      const src = fsx.readFileXSync(filepath, { encoding })
+      this.readableFilepaths.add(envFilepath)
+
+      const { privateKeyName } = keyNames(filepath)
+      const { privateKeyValue } = keyValuesSync(filepath, { keysFilepath: this.envKeysFilepath, noOps: this.noOps })
+
+      const {
+        parsed,
+        errors,
+        injected,
+        preExisted
+      } = new Parse(src, privateKeyValue, this.processEnv, this.overload, privateKeyName).run()
+
+      row.privateKeyName = privateKeyName
+      row.privateKey = privateKeyValue
+      row.src = src
+      row.parsed = parsed
+      row.errors = errors
+      row.injected = injected
+      row.preExisted = preExisted
+
+      this.inject(row.parsed) // inject
+
+      for (const key of Object.keys(injected)) {
+        this.uniqueInjectedKeys.add(key) // track uniqueInjectedKeys across multiple files
+      }
+    } catch (e) {
+      if (e.code === 'ENOENT' || e.code === 'EISDIR') {
+        row.errors = [new Errors({ envFilepath, filepath }).missingEnvFile()]
+      } else {
+        row.errors = [e]
+      }
+    }
+
+    this.processedEnvs.push(row)
+  }
+
+  async _injectEnvFile (envFilepath) {
     const row = {}
     row.type = TYPE_ENV_FILE
     row.filepath = envFilepath
 
     const filepath = path.resolve(envFilepath)
     try {
-      const encoding = detectEncoding(filepath)
-      const src = fsx.readFileX(filepath, { encoding })
+      const encoding = await detectEncoding(filepath)
+      const src = await fsx.readFileX(filepath, { encoding })
       this.readableFilepaths.add(envFilepath)
 
       const { privateKeyName } = keyNames(filepath)
-      const { privateKeyValue } = keyValues(filepath, { keysFilepath: this.envKeysFilepath, opsOn: this.opsOn })
+      const { privateKeyValue } = await keyValues(filepath, { keysFilepath: this.envKeysFilepath, noOps: this.noOps })
 
       const {
         parsed,

package/src/lib/services/sets.js

@@ -11,7 +11,8 @@ const {
 
 const {
   keyNames,
-  keyValues
+  keyValues,
+  keyValuesSync
 } = require('./../helpers/keyResolution')
 
 const {
@@ -19,21 +20,23 @@ const {
   decryptKeyValue,
   isEncrypted,
   provision,
+  provisionSync,
   provisionWithPrivateKey
 } = require('./../helpers/cryptography')
 
 const replace = require('./../helpers/replace')
 const dotenvParse = require('./../helpers/dotenvParse')
 const detectEncoding = require('./../helpers/detectEncoding')
+const detectEncodingSync = require('./../helpers/detectEncodingSync')
 
 class Sets {
-  constructor (key, value, envs = [], encrypt = true, envKeysFilepath = null, opsOn = false, noCreate = false) {
+  constructor (key, value, envs = [], encrypt = true, envKeysFilepath = null, noOps = false, noCreate = false) {
     this.envs = determine(envs, process.env)
     this.key = key
     this.value = value
     this.encrypt = encrypt
     this.envKeysFilepath = envKeysFilepath
-    this.opsOn = opsOn
+    this.noOps = noOps
     this.noCreate = noCreate
 
     this.processedEnvs = []
@@ -42,7 +45,7 @@ class Sets {
     this.readableFilepaths = new Set()
   }
 
-  run () {
+  runSync () {
     // example
     // envs [
     //   { type: 'envFile', value: '.env' }
@@ -50,7 +53,7 @@ class Sets {
 
     for (const env of this.envs) {
       if (env.type === TYPE_ENV_FILE) {
-        this._setEnvFile(env.value)
+        this._setEnvFileSync(env.value)
       }
     }
 
@@ -61,7 +64,26 @@ class Sets {
     }
   }
 
-  _setEnvFile (envFilepath) {
+  async run () {
+    // example
+    // envs [
+    //   { type: 'envFile', value: '.env' }
+    // ]
+
+    for (const env of this.envs) {
+      if (env.type === TYPE_ENV_FILE) {
+        await this._setEnvFile(env.value)
+      }
+    }
+
+    return {
+      processedEnvs: this.processedEnvs,
+      changedFilepaths: [...this.changedFilepaths],
+      unchangedFilepaths: [...this.unchangedFilepaths]
+    }
+  }
+
+  _setEnvFileSync (envFilepath) {
     const row = {}
     row.key = this.key || null
     row.value = this.value || null
@@ -77,14 +99,119 @@ class Sets {
 
       if (!fsx.existsSync(filepath)) {
         if (this.noCreate) {
-          detectEncoding(filepath) // throws ENOENT
+          detectEncodingSync(filepath) // throws ENOENT
+        } else {
+          fsx.writeFileXSync(filepath, '')
+        }
+      }
+
+      const encoding = detectEncodingSync(filepath)
+      let envSrc = fsx.readFileXSync(filepath, { encoding })
+
+      // blank files seeded by `set` should contain only the key being set
+      if (row.key && envSrc.trim().length === 0) {
+        envSrc = `${row.key}="${this.value}"\n`
+        seededWithInitialKey = true
+      }
+
+      const envParsed = dotenvParse(envSrc)
+      row.originalValue = envParsed[row.key] || null
+      if (seededWithInitialKey) {
+        row.originalValue = null
+      }
+      const wasPlainText = !isEncrypted(row.originalValue)
+      this.readableFilepaths.add(envFilepath)
+
+      if (this.encrypt) {
+        let publicKey
+        let privateKey
+
+        const { publicKeyName, privateKeyName } = keyNames(filepath)
+        const { publicKeyValue, privateKeyValue } = keyValuesSync(filepath, { keysFilepath: this.envKeysFilepath, noOps: this.noOps })
+
+        // first pass - provisionSync
+        if (!privateKeyValue && !publicKeyValue) {
+          const prov = provisionSync({ envSrc, envFilepath, keysFilepath: this.envKeysFilepath, noOps: this.noOps })
+          envSrc = prov.envSrc
+          publicKey = prov.publicKey
+          privateKey = prov.privateKey
+          row.privateKeyAdded = prov.privateKeyAdded
+          row.envKeysFilepath = prov.envKeysFilepath
+        } else if (privateKeyValue) {
+          const prov = provisionWithPrivateKey({ envSrc, envFilepath, keysFilepath: this.envKeysFilepath, privateKeyValue, publicKeyValue, publicKeyName })
+          publicKey = prov.publicKey
+          privateKey = prov.privateKey
+          envSrc = prov.envSrc
+
+          if (row.originalValue) {
+            row.originalValue = decryptKeyValue(row.key, row.originalValue, privateKeyName, privateKey)
+          }
+        } else if (publicKeyValue) {
+          publicKey = publicKeyValue
+        }
+
+        row.publicKey = publicKey
+        row.privateKey = privateKey
+        try {
+          row.encryptedValue = encryptValue(this.value, publicKey)
+        } catch {
+          throw new Errors({ publicKeyName, publicKey }).invalidPublicKey()
+        }
+        row.privateKeyName = privateKeyName
+      }
+
+      const goingFromPlainTextToEncrypted = wasPlainText && this.encrypt
+      const valueChanged = this.value !== row.originalValue
+      const shouldPersistSeededPlainValue = seededWithInitialKey && !this.encrypt
+
+      if (shouldPersistSeededPlainValue) {
+        row.envSrc = envSrc
+        this.changedFilepaths.add(envFilepath)
+        row.changed = true
+      } else if (goingFromPlainTextToEncrypted || valueChanged) {
+        row.envSrc = replace(envSrc, this.key, row.encryptedValue || this.value)
+        this.changedFilepaths.add(envFilepath)
+        row.changed = true
+      } else {
+        row.envSrc = envSrc
+        this.unchangedFilepaths.add(envFilepath)
+        row.changed = false
+      }
+    } catch (e) {
+      if (e.code === 'ENOENT') {
+        row.error = new Errors({ envFilepath, filepath }).missingEnvFile()
+      } else {
+        row.error = e
+      }
+    }
+
+    this.processedEnvs.push(row)
+  }
+
+  async _setEnvFile (envFilepath) {
+    const row = {}
+    row.key = this.key || null
+    row.value = this.value || null
+    row.type = TYPE_ENV_FILE
+
+    const filepath = path.resolve(envFilepath)
+    row.filepath = filepath
+    row.envFilepath = envFilepath
+    row.changed = false
+
+    try {
+      let seededWithInitialKey = false
+
+      if (!(await fsx.exists(filepath))) {
+        if (this.noCreate) {
+          await detectEncoding(filepath) // throws ENOENT
         } else {
-          fsx.writeFileX(filepath, '')
+          await fsx.writeFileX(filepath, '')
         }
       }
 
-      const encoding = detectEncoding(filepath)
-      let envSrc = fsx.readFileX(filepath, { encoding })
+      const encoding = await detectEncoding(filepath)
+      let envSrc = await fsx.readFileX(filepath, { encoding })
 
       // blank files seeded by `set` should contain only the key being set
       if (row.key && envSrc.trim().length === 0) {
@@ -105,11 +232,11 @@ class Sets {
         let privateKey
 
         const { publicKeyName, privateKeyName } = keyNames(filepath)
-        const { publicKeyValue, privateKeyValue } = keyValues(filepath, { keysFilepath: this.envKeysFilepath, opsOn: this.opsOn })
+        const { publicKeyValue, privateKeyValue } = await keyValues(filepath, { keysFilepath: this.envKeysFilepath, noOps: this.noOps })
 
         // first pass - provision
         if (!privateKeyValue && !publicKeyValue) {
-          const prov = provision({ envSrc, envFilepath, keysFilepath: this.envKeysFilepath, opsOn: this.opsOn })
+          const prov = await provision({ envSrc, envFilepath, keysFilepath: this.envKeysFilepath, noOps: this.noOps })
           envSrc = prov.envSrc
           publicKey = prov.publicKey
           privateKey = prov.privateKey

package/src/shared/logger.js

@@ -20,8 +20,8 @@ const success = getColor('amber')
 const successv = (m) => getColor('amber')(`⟐ ${m}`)
 const info = getColor('gray')
 const help = getColor('dodgerblue')
-const verbose = getColor('plum')
-const debug = getColor('plum')
+const verbose = (m) => getColor('plum')(`┆ ${m}`)
+const debug = (m) => getColor('plum')(`┆ ${m}`)
 
 let currentLevel = levels.info // default log level
 let currentName = 'dotenvx' // default logger name
@@ -121,7 +121,7 @@ function setLogLevel (options) {
   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}`)
+    logger.debug(`setting log level to: ${logLevel}`)
   }
 }
 

package/src/lib/helpers/sleep.js

@@ -1,5 +0,0 @@
-function sleep (ms) {
-  return new Promise(resolve => setTimeout(resolve, ms))
-}
-
-module.exports = sleep