@dotenvx/dotenvx 1.59.1 → 1.60.0

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