@dotenvx/dotenvx 1.75.1 → 2.1.0

package/src/lib/services/rotate.js

@@ -1,197 +0,0 @@
-const fsx = require('./../helpers/fsx')
-const path = require('path')
-const picomatch = require('picomatch')
-const { encrypted, scan } = require('@dotenvx/primitives')
-
-const TYPE_ENV_FILE = 'envFile'
-
-const Errors = require('./../helpers/errors')
-
-const {
-  determine
-} = require('./../helpers/envResolution')
-
-const {
-  keyNamesForEnvFile,
-  keyValues
-} = require('./../helpers/keyResolution')
-
-const {
-  armorKeypair,
-  localKeypair,
-  encryptValue,
-  decryptKeyValue
-} = require('./../helpers/cryptography')
-
-const append = require('./../helpers/append')
-const replace = require('./../helpers/replace')
-const detectEncoding = require('./../helpers/detectEncoding')
-
-class Rotate {
-  constructor (envs = [], key = [], excludeKey = [], envKeysFilepath = null, noArmor = false, options = {}) {
-    this.envs = determine(envs, process.env)
-    this.key = key
-    this.excludeKey = excludeKey
-    this.envKeysFilepath = envKeysFilepath
-    this.noArmor = noArmor
-    this.command = options.command
-
-    this.processedEnvs = []
-    this.changedFilepaths = new Set()
-    this.unchangedFilepaths = new Set()
-
-    this.envKeysSources = {}
-  }
-
-  async run () {
-    // example
-    // envs [
-    //   { type: 'envFile', value: '.env' }
-    // ]
-
-    this.keys = this._keys()
-    const excludeKeys = this._excludeKeys()
-
-    this.exclude = picomatch(excludeKeys)
-    this.include = picomatch(this.keys, { ignore: excludeKeys })
-
-    for (const env of this.envs) {
-      if (env.type === TYPE_ENV_FILE) {
-        await this._rotateEnvFile(env.value)
-      }
-    }
-
-    return {
-      processedEnvs: this.processedEnvs,
-      changedFilepaths: [...this.changedFilepaths],
-      unchangedFilepaths: [...this.unchangedFilepaths]
-    }
-  }
-
-  async _rotateEnvFile (envFilepath) {
-    const row = {}
-    row.keys = []
-    row.type = TYPE_ENV_FILE
-
-    const filepath = path.resolve(envFilepath)
-    row.filepath = filepath
-    row.envFilepath = envFilepath
-
-    try {
-      const encoding = await detectEncoding(filepath)
-      let envSrc = await fsx.readFileX(filepath, { encoding })
-      const envParsed = scan(envSrc).parsed
-
-      const { publicKeyName, privateKeyName } = keyNamesForEnvFile(envFilepath)
-      const { privateKeyValue } = await keyValues(envFilepath, {
-        keysFilepath: this.envKeysFilepath,
-        noArmor: this.noArmor,
-        command: this.command
-      })
-
-      let newPublicKey
-      let newPrivateKey
-      let envKeysFilepath
-      let envKeysSrc
-
-      if (!this.noArmor) {
-        const kp = await armorKeypair(undefined, {
-          command: this.command
-        })
-        newPublicKey = kp.publicKey
-        newPrivateKey = kp.privateKey
-
-        row.localPrivateKeyAdded = false
-        row.remotePrivateKeyAdded = true
-      } else {
-        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()
-        newPublicKey = kp.publicKey
-        newPrivateKey = kp.privateKey
-
-        row.localPrivateKeyAdded = true
-        row.remotePrivateKeyAdded = false
-      }
-
-      // .env
-      envSrc = replace(envSrc, publicKeyName, newPublicKey) // replace publicKey
-      row.changed = true // track change
-
-      for (const [key, values] of Object.entries(envParsed)) { // re-encrypt each individual key
-        // key excluded - don't re-encrypt it
-        if (this.exclude(key)) {
-          continue
-        }
-
-        // key effectively excluded (by not being in the list of includes) - don't re-encrypt it
-        if (this.keys.length > 0 && !this.include(key)) {
-          continue
-        }
-
-        const value = [...values].reverse().find(value => encrypted(value))
-        if (value) { // only re-encrypt those already encrypted
-          row.keys.push(key) // track key(s)
-
-          const decryptedValue = decryptKeyValue(key, value, privateKeyName, privateKeyValue) // get decrypted value
-          let encryptedValue
-          try {
-            encryptedValue = encryptValue(decryptedValue, newPublicKey) // encrypt with the new publicKey
-          } catch {
-            throw new Errors({ publicKeyName, publicKey: newPublicKey }).invalidPublicKey()
-          }
-
-          envSrc = replace(envSrc, key, encryptedValue)
-        }
-      }
-      row.envSrc = envSrc
-      row.privateKeyName = privateKeyName
-      row.privateKey = newPrivateKey
-
-      if (this.noArmor) {
-        // keys src only for local key storage
-        envKeysSrc = append(envKeysSrc, privateKeyName, newPrivateKey) // append privateKey
-        this.envKeysSources[envKeysFilepath] = envKeysSrc
-        row.envKeysSrc = envKeysSrc
-      }
-
-      this.changedFilepaths.add(envFilepath)
-    } catch (e) {
-      if (e.code === 'ENOENT') {
-        const missingPath = e.path ? path.resolve(e.path) : null
-        const expectedEnvKeysPath = row.envKeysFilepath ? path.resolve(row.envKeysFilepath) : null
-        if (this.noArmor && expectedEnvKeysPath && missingPath === expectedEnvKeysPath) {
-          row.error = new Errors({ envKeysFilepath: row.envKeysFilepath }).missingEnvKeysFile()
-        } else {
-          row.error = new Errors({ envFilepath, filepath }).missingEnvFile()
-        }
-      } else {
-        row.error = e
-      }
-    }
-
-    this.processedEnvs.push(row)
-  }
-
-  _keys () {
-    if (!Array.isArray(this.key)) {
-      return [this.key]
-    }
-
-    return this.key
-  }
-
-  _excludeKeys () {
-    if (!Array.isArray(this.excludeKey)) {
-      return [this.excludeKey]
-    }
-
-    return this.excludeKey
-  }
-}
-
-module.exports = Rotate

package/src/lib/services/run.js

@@ -1,255 +0,0 @@
-const fsx = require('./../helpers/fsx')
-const path = require('path')
-
-const TYPE_ENV = 'env'
-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 {
-  keyNamesForEnvFile,
-  keyValues,
-  keyValuesSync,
-  keyValuesFromEnvSrc
-} = require('./../helpers/keyResolution')
-
-class Run {
-  constructor (envs = [], overload = false, processEnv = process.env, envKeysFilepath = null, noArmor = false, options = {}) {
-    this.envs = envs
-    this.overload = overload
-    this.processEnv = processEnv
-    this.envKeysFilepath = envKeysFilepath
-    this.noArmor = noArmor
-    this.noSpinner = options.noSpinner
-    this.token = options.token
-    this.command = options.command
-
-    this.processedEnvs = []
-    this.readableFilepaths = new Set()
-    this.readableStrings = new Set()
-    this.uniqueInjectedKeys = new Set()
-    this.beforeEnv = { ...this.processEnv }
-  }
-
-  runSync () {
-    // 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) {
-        this._injectEnvFileSync(env.value)
-      } else if (env.type === TYPE_ENV) {
-        this._injectEnv(env.value, env.privateKeyName)
-      }
-    }
-
-    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, env.privateKeyName)
-      }
-    }
-
-    return {
-      processedEnvs: this.processedEnvs,
-      readableStrings: [...this.readableStrings],
-      readableFilepaths: [...this.readableFilepaths],
-      uniqueInjectedKeys: [...this.uniqueInjectedKeys],
-      beforeEnv: this.beforeEnv,
-      afterEnv: { ...this.processEnv }
-    }
-  }
-
-  _injectEnv (env, privateKeyName = null) {
-    const row = {}
-    row.type = TYPE_ENV
-    row.string = env
-
-    try {
-      const {
-        privateKeyName: resolvedPrivateKeyName,
-        privateKeyValue,
-        privateKeySource
-      } = keyValuesFromEnvSrc(env, privateKeyName, {
-        keysFilepath: this.envKeysFilepath,
-        noArmor: this.noArmor,
-        processEnv: this.processEnv,
-        token: this.token,
-        command: this.command
-      })
-
-      const {
-        parsed,
-        errors,
-        injected,
-        preExisted
-      } = new Parse(env, privateKeyValue, this.processEnv, this.overload, resolvedPrivateKeyName).run()
-
-      row.privateKeyName = resolvedPrivateKeyName
-      row.privateKey = privateKeyValue
-      if (privateKeySource) {
-        row.privateKeySource = privateKeySource
-        row.armoredPrivateKeyUsed = privateKeySource === 'armor'
-      }
-      row.parsed = parsed
-      row.errors = errors
-      row.injected = injected
-      row.preExisted = preExisted
-
-      this.inject(row.parsed) // inject
-
-      this.readableStrings.add(env)
-
-      for (const key of Object.keys(injected)) {
-        this.uniqueInjectedKeys.add(key) // track uniqueInjectedKeys across multiple files
-      }
-    } catch (e) {
-      row.errors = [e]
-    }
-
-    this.processedEnvs.push(row)
-  }
-
-  _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 } = keyNamesForEnvFile(filepath)
-      const { privateKeyValue, privateKeySource } = keyValuesSync(filepath, {
-        keysFilepath: this.envKeysFilepath,
-        noArmor: this.noArmor,
-        noSpinner: this.noSpinner,
-        token: this.token,
-        command: this.command
-      })
-
-      const {
-        parsed,
-        errors,
-        injected,
-        preExisted
-      } = new Parse(src, privateKeyValue, this.processEnv, this.overload, privateKeyName).run()
-
-      row.privateKeyName = privateKeyName
-      row.privateKey = privateKeyValue
-      if (privateKeySource) {
-        row.privateKeySource = privateKeySource
-        row.armoredPrivateKeyUsed = privateKeySource === 'armor'
-      }
-      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 = await detectEncoding(filepath)
-      const src = await fsx.readFileX(filepath, { encoding })
-      this.readableFilepaths.add(envFilepath)
-
-      const { privateKeyName } = keyNamesForEnvFile(filepath)
-      const { privateKeyValue, privateKeySource } = await keyValues(filepath, {
-        keysFilepath: this.envKeysFilepath,
-        noArmor: this.noArmor,
-        token: this.token,
-        command: this.command
-      })
-
-      const {
-        parsed,
-        errors,
-        injected,
-        preExisted
-      } = new Parse(src, privateKeyValue, this.processEnv, this.overload, privateKeyName).run()
-
-      row.privateKeyName = privateKeyName
-      row.privateKey = privateKeyValue
-      if (privateKeySource) {
-        row.privateKeySource = privateKeySource
-        row.armoredPrivateKeyUsed = privateKeySource === 'armor'
-      }
-      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)
-  }
-
-  inject (parsed) {
-    for (const key of Object.keys(parsed)) {
-      this.processEnv[key] = parsed[key] // inject to process.env
-    }
-  }
-}
-
-module.exports = Run