@dotenvx/dotenvx 1.75.0 → 2.0.0

package/src/lib/services/decrypt.js

@@ -1,157 +0,0 @@
-const fsx = require('./../helpers/fsx')
-const path = require('path')
-const picomatch = require('picomatch')
-const { encrypted } = 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 {
-  decryptKeyValue
-} = require('./../helpers/cryptography')
-
-const replace = require('./../helpers/replace')
-const dotenvParse = require('./../helpers/dotenvParse')
-const detectEncoding = require('./../helpers/detectEncoding')
-
-class Decrypt {
-  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()
-  }
-
-  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._decryptEnvFile(env.value)
-      }
-    }
-
-    return {
-      processedEnvs: this.processedEnvs,
-      changedFilepaths: [...this.changedFilepaths],
-      unchangedFilepaths: [...this.unchangedFilepaths]
-    }
-  }
-
-  async _decryptEnvFile (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 = dotenvParse(envSrc, false, false, true)
-
-      const { privateKeyName } = keyNamesForEnvFile(envFilepath)
-      const { privateKeyValue, privateKeySource } = await keyValues(envFilepath, {
-        keysFilepath: this.envKeysFilepath,
-        noArmor: this.noArmor,
-        command: this.command
-      })
-
-      row.privateKey = privateKeyValue
-      row.privateKeySource = privateKeySource
-      row.armoredPrivateKeyUsed = privateKeySource === 'armor'
-      row.privateKeyName = privateKeyName
-      row.changed = false // track possible changes
-
-      for (const [key, values] of Object.entries(envParsed)) {
-        // key excluded - don't decrypt it
-        if (this.exclude(key)) {
-          continue
-        }
-
-        // key effectively excluded (by not being in the list of includes) - don't decrypt it
-        if (this.keys.length > 0 && !this.include(key)) {
-          continue
-        }
-
-        const hasEncrypted = values.some(value => encrypted(value))
-        if (hasEncrypted) {
-          row.keys.push(key) // track key(s)
-
-          const decryptedValues = values.map(value => {
-            if (!encrypted(value)) {
-              return value
-            }
-
-            return decryptKeyValue(key, value, privateKeyName, privateKeyValue)
-          })
-
-          // once newSrc is built write it out
-          envSrc = replace(envSrc, key, decryptedValues)
-
-          row.changed = true // track change
-        }
-      }
-
-      row.envSrc = envSrc
-      if (row.changed) {
-        this.changedFilepaths.add(envFilepath)
-      } else {
-        this.unchangedFilepaths.add(envFilepath)
-      }
-    } catch (e) {
-      if (e.code === 'ENOENT') {
-        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 = Decrypt

package/src/lib/services/encrypt.js

@@ -1,214 +0,0 @@
-const fsx = require('./../helpers/fsx')
-const path = require('path')
-const picomatch = require('picomatch')
-const { encrypted } = 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 {
-  encryptValue,
-  isPublicKey,
-  provision,
-  provisionWithPrivateKey
-} = require('./../helpers/cryptography')
-
-const replace = require('./../helpers/replace')
-const dotenvParse = require('./../helpers/dotenvParse')
-const detectEncoding = require('./../helpers/detectEncoding')
-const SAMPLE_ENV_KIT = require('./../helpers/kits/sample')
-
-class Encrypt {
-  constructor (envs = [], key = [], excludeKey = [], envKeysFilepath = null, noArmor = false, noCreate = false, token = undefined, options = {}) {
-    this.envs = determine(envs, process.env)
-    this.key = key
-    this.excludeKey = excludeKey
-    this.envKeysFilepath = envKeysFilepath
-    this.noArmor = noArmor
-    this.noCreate = noCreate
-    this.token = token
-    this.selectKeyStorage = options.selectKeyStorage
-    this.command = options.command
-
-    this.processedEnvs = []
-    this.changedFilepaths = new Set()
-    this.unchangedFilepaths = new Set()
-  }
-
-  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._encryptEnvFile(env.value)
-      }
-    }
-
-    return {
-      processedEnvs: this.processedEnvs,
-      changedFilepaths: [...this.changedFilepaths],
-      unchangedFilepaths: [...this.unchangedFilepaths]
-    }
-  }
-
-  async _encryptEnvFile (envFilepath) {
-    const row = {}
-    row.keys = []
-    row.type = TYPE_ENV_FILE
-    let fileCreated = false
-
-    const filepath = path.resolve(envFilepath)
-    row.filepath = filepath
-    row.envFilepath = envFilepath
-
-    try {
-      const fileExists = await fsx.exists(filepath)
-      let envSrc
-      if (!fileExists && !this.noCreate) {
-        envSrc = SAMPLE_ENV_KIT
-        fileCreated = true
-        row.kitCreated = 'sample'
-        row.changed = true
-      } else {
-        const encoding = await detectEncoding(filepath)
-        envSrc = await fsx.readFileX(filepath, { encoding })
-      }
-      if (envSrc.trim().length === 0) {
-        envSrc = SAMPLE_ENV_KIT
-        row.kitCreated = 'sample'
-        row.changed = true
-      }
-      const envParsed = dotenvParse(envSrc, false, false, true)
-
-      let publicKey
-      let privateKey
-
-      const { publicKeyName, privateKeyName } = keyNamesForEnvFile(envFilepath)
-      const { publicKeyValue, privateKeyValue } = await keyValues(envFilepath, {
-        keysFilepath: this.envKeysFilepath,
-        noArmor: this.noArmor,
-        command: this.command
-      })
-
-      // first pass - provision
-      if (!privateKeyValue && !publicKeyValue) {
-        const prov = await provision({
-          envSrc,
-          envFilepath,
-          keysFilepath: this.envKeysFilepath,
-          noArmor: this.noArmor,
-          token: this.token,
-          selectKeyStorage: this.selectKeyStorage,
-          command: this.command
-        })
-        envSrc = prov.envSrc
-        publicKey = prov.publicKey
-        privateKey = prov.privateKey
-        row.localPrivateKeyAdded = prov.localPrivateKeyAdded
-        row.remotePrivateKeyAdded = prov.remotePrivateKeyAdded
-        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
-      } else if (publicKeyValue) {
-        publicKey = publicKeyValue
-      }
-
-      row.publicKey = publicKey
-      row.privateKey = privateKey
-      row.privateKeyName = privateKeyName
-
-      // iterate over all non-encrypted values and encrypt them
-      for (const [key, values] of Object.entries(envParsed)) {
-        // key excluded - don't encrypt it
-        if (this.exclude(key)) {
-          continue
-        }
-
-        // key effectively excluded (by not being in the list of includes) - don't encrypt it
-        if (this.keys.length > 0 && !this.include(key)) {
-          continue
-        }
-
-        const fullyEncrypted = values.every(value => encrypted(value) || isPublicKey(key))
-        if (!fullyEncrypted) {
-          row.keys.push(key) // track key(s)
-
-          const encryptedValues = values.map(value => {
-            if (encrypted(value) || isPublicKey(key)) {
-              return value
-            }
-
-            try {
-              return encryptValue(value, publicKey)
-            } catch {
-              throw new Errors({ publicKeyName, publicKey }).invalidPublicKey()
-            }
-          })
-
-          // once newSrc is built write it out
-          envSrc = replace(envSrc, key, encryptedValues)
-
-          row.changed = true // track change
-        }
-      }
-
-      row.envSrc = envSrc
-      if (fileCreated) {
-        row.changed = true
-      }
-      if (row.changed) {
-        this.changedFilepaths.add(envFilepath)
-      } else {
-        this.unchangedFilepaths.add(envFilepath)
-      }
-    } catch (e) {
-      if (e.code === 'ENOENT') {
-        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 = Encrypt

package/src/lib/services/get.js

@@ -1,76 +0,0 @@
-const Run = require('./run')
-const Errors = require('./../helpers/errors')
-const { determine } = require('./../helpers/envResolution')
-
-class Get {
-  constructor (key, envs = [], overload = false, all = false, envKeysFilepath = null, noArmor = false, options = {}) {
-    this.key = key
-    this.envs = envs
-    this.overload = overload
-    this.all = all
-    this.envKeysFilepath = envKeysFilepath
-    this.noArmor = noArmor
-    this.command = options.command
-  }
-
-  runSync () {
-    const processEnv = { ...process.env }
-    const envs = determine(this.envs, processEnv)
-    const { processedEnvs } = new Run(envs, this.overload, processEnv, this.envKeysFilepath, this.noArmor, {
-      command: this.command
-    }).runSync()
-    return this._result(processedEnvs, processEnv)
-  }
-
-  async run () {
-    const processEnv = { ...process.env }
-    const envs = determine(this.envs, processEnv)
-    const { processedEnvs } = await new Run(envs, this.overload, processEnv, this.envKeysFilepath, this.noArmor, {
-      command: this.command
-    }).run()
-    return this._result(processedEnvs, processEnv)
-  }
-
-  _result (processedEnvs, processEnv) {
-    const errors = []
-    for (const processedEnv of processedEnvs) {
-      for (const error of processedEnv.errors) {
-        errors.push(error)
-      }
-    }
-
-    if (this.key) {
-      const parsed = {}
-      const value = processEnv[this.key]
-      parsed[this.key] = value
-
-      if (value === undefined) {
-        errors.push(new Errors({ key: this.key }).missingKey())
-      }
-
-      return { parsed, errors }
-    }
-
-    // if user wants to return ALL envs (even prior set on machine)
-    if (this.all) {
-      return { parsed: processEnv, errors }
-    }
-
-    // typical scenario - return only envs that were identified in the .env file
-    // iterate over all processedEnvs.parsed and grab from processEnv
-    /** @type {Record<string, string>} */
-    const parsed = {}
-    for (const processedEnv of processedEnvs) {
-      // parsed means we saw the key in a file or --env flag. this effectively filters out any preset machine envs - while still respecting complex evaluating, expansion, and overload. in other words, the value might be the machine value because the key was displayed in a .env file
-      if (processedEnv.parsed) {
-        for (const key of Object.keys(processedEnv.parsed)) {
-          parsed[key] = processEnv[key]
-        }
-      }
-    }
-
-    return { parsed, errors }
-  }
-}
-
-module.exports = Get

package/src/lib/services/keypair.js

@@ -1,60 +0,0 @@
-const keyNamesForEnvFile = require('./../helpers/keyResolution/keyNamesForEnvFile')
-const keyValues = require('./../helpers/keyResolution/keyValues')
-const keyValuesSync = require('./../helpers/keyResolution/keyValuesSync')
-
-class Keypair {
-  constructor (envFile = '.env', envKeysFilepath = null, noArmor = false, options = {}) {
-    this.envFile = envFile
-    this.envKeysFilepath = envKeysFilepath
-    this.noArmor = noArmor
-    this.command = options.command
-  }
-
-  runSync () {
-    const out = {}
-
-    const filepaths = this._filepaths()
-    for (const filepath of filepaths) {
-      const { publicKeyName, privateKeyName } = keyNamesForEnvFile(filepath)
-      const { publicKeyValue, privateKeyValue } = keyValuesSync(filepath, {
-        keysFilepath: this.envKeysFilepath,
-        noArmor: this.noArmor,
-        command: this.command
-      })
-
-      out[publicKeyName] = publicKeyValue
-      out[privateKeyName] = privateKeyValue
-    }
-
-    return out
-  }
-
-  async run () {
-    const out = {}
-
-    const filepaths = this._filepaths()
-    for (const filepath of filepaths) {
-      const { publicKeyName, privateKeyName } = keyNamesForEnvFile(filepath)
-      const { publicKeyValue, privateKeyValue } = await keyValues(filepath, {
-        keysFilepath: this.envKeysFilepath,
-        noArmor: this.noArmor,
-        command: this.command
-      })
-
-      out[publicKeyName] = publicKeyValue
-      out[privateKeyName] = privateKeyValue
-    }
-
-    return out
-  }
-
-  _filepaths () {
-    if (!Array.isArray(this.envFile)) {
-      return [this.envFile]
-    }
-
-    return this.envFile
-  }
-}
-
-module.exports = Keypair

package/src/lib/services/loginPoll.js

@@ -1,36 +0,0 @@
-const Session = require('../../db/session')
-const PostOauthToken = require('../api/postOauthToken')
-
-class LoginPoll {
-  constructor (hostname, deviceCode, interval) {
-    this.hostname = hostname
-    this.deviceCode = deviceCode
-    this.interval = interval
-  }
-
-  async run () {
-    const sesh = new Session()
-
-    while (true) {
-      try {
-        const data = await new PostOauthToken(this.hostname, this.deviceCode).run()
-
-        if (data.access_token) {
-          sesh.login(this.hostname, data.id, data.username, data.access_token)
-          await sesh.notifyUpdate()
-          return data
-        }
-
-        await new Promise(resolve => setTimeout(resolve, this.interval * 1000))
-      } catch (error) {
-        if (error.code === 'authorization_pending') {
-          await new Promise(resolve => setTimeout(resolve, (this.interval + 1) * 1000))
-        } else {
-          throw error
-        }
-      }
-    }
-  }
-}
-
-module.exports = LoginPoll

package/src/lib/services/ls.js

@@ -1,57 +0,0 @@
-const { fdir: Fdir } = require('fdir')
-const path = require('path')
-const picomatch = require('picomatch')
-
-class Ls {
-  constructor (directory = './', envFile = ['.env*'], excludeEnvFile = []) {
-    this.ignore = ['node_modules/**', '.git/**']
-
-    this.cwd = path.resolve(directory)
-    this.envFile = envFile
-    this.excludeEnvFile = excludeEnvFile
-  }
-
-  run () {
-    return this._filepaths()
-  }
-
-  _filepaths () {
-    const exclude = picomatch(this._exclude())
-    const include = picomatch(this._patterns(), {
-      ignore: this._exclude()
-    })
-
-    return new Fdir()
-      .withRelativePaths()
-      .exclude((dir, path) => exclude(path))
-      .filter((path) => include(path))
-      .crawl(this.cwd)
-      .sync()
-  }
-
-  _patterns () {
-    if (!Array.isArray(this.envFile)) {
-      return [`**/${this.envFile}`]
-    }
-
-    return this.envFile.map(part => `**/${part}`)
-  }
-
-  _excludePatterns () {
-    if (!Array.isArray(this.excludeEnvFile)) {
-      return [`**/${this.excludeEnvFile}`]
-    }
-
-    return this.excludeEnvFile.map(part => `**/${part}`)
-  }
-
-  _exclude () {
-    if (this._excludePatterns().length > 0) {
-      return this.ignore.concat(this._excludePatterns())
-    } else {
-      return this.ignore
-    }
-  }
-}
-
-module.exports = Ls