@dotenvx/dotenvx 1.75.1 → 2.1.0

package/src/lib/helpers/keyResolution/keyValuesFromEnvSrc.js

@@ -1,85 +0,0 @@
-const path = require('path')
-const { scan } = require('@dotenvx/primitives')
-
-const readFileKeySync = require('./readFileKeySync')
-const armorKeypairSync = require('../cryptography/armorKeypairSync')
-
-const PUBLIC_KEY_SCHEMA = 'DOTENV_PUBLIC_KEY'
-const PRIVATE_KEY_SCHEMA = 'DOTENV_PRIVATE_KEY'
-
-function readProcessKey (processEnv, keyName) {
-  if (processEnv[keyName] && processEnv[keyName].length > 0) {
-    return processEnv[keyName]
-  }
-}
-
-function publicKeyNameFromEnvSrc (envParsed) {
-  for (const keyName of Object.keys(envParsed)) {
-    if (keyName === PUBLIC_KEY_SCHEMA || keyName.startsWith(PUBLIC_KEY_SCHEMA)) {
-      return keyName
-    }
-  }
-
-  return null
-}
-
-function finalValue (parsed, keyName) {
-  const values = parsed[keyName]
-  return values ? values[values.length - 1] : undefined
-}
-
-function keyValuesFromEnvSrc (src, privateKeyName = null, opts = {}) {
-  let keysFilepath = opts.keysFilepath || null
-  const noArmor = opts.noArmor === true
-  const processEnv = opts.processEnv || process.env
-  const { parsed: envParsed } = scan(src)
-
-  const publicKeyName = publicKeyNameFromEnvSrc(envParsed)
-  const publicKeyValue = publicKeyName ? readProcessKey(processEnv, publicKeyName) || finalValue(envParsed, publicKeyName) || null : null
-
-  if (!privateKeyName && publicKeyName) {
-    privateKeyName = publicKeyName.replace(PUBLIC_KEY_SCHEMA, PRIVATE_KEY_SCHEMA)
-  }
-
-  let privateKeyValue = null
-  let privateKeySource = null
-  if (privateKeyName) {
-    privateKeyValue = readProcessKey(processEnv, privateKeyName)
-
-    if (!privateKeyValue) {
-      if (keysFilepath) {
-        keysFilepath = path.resolve(keysFilepath)
-      } else {
-        keysFilepath = path.resolve('.env.keys')
-      }
-
-      privateKeyValue = readFileKeySync(privateKeyName, keysFilepath)
-    }
-  }
-
-  if (!noArmor && !privateKeyValue && publicKeyValue && publicKeyValue.length > 0) {
-    const armorOptions = {}
-    if (opts.token) {
-      armorOptions.token = opts.token
-    }
-    if (opts.command) {
-      armorOptions.command = opts.command
-    }
-    const kp = armorKeypairSync(publicKeyValue, armorOptions)
-    privateKeyValue = kp.privateKey
-    privateKeySource = 'armor'
-  }
-
-  const result = {
-    publicKeyValue: publicKeyValue || null,
-    privateKeyValue: privateKeyValue || null,
-    privateKeyName: privateKeyName || null
-  }
-  if (privateKeySource) {
-    result.privateKeySource = privateKeySource
-  }
-
-  return result
-}
-
-module.exports = keyValuesFromEnvSrc

package/src/lib/helpers/keyResolution/keyValuesSync.js

@@ -1,103 +0,0 @@
-const path = require('path')
-const { scan } = require('@dotenvx/primitives')
-
-const fsx = require('./../fsx')
-const keyNamesForEnvFile = require('./keyNamesForEnvFile')
-const readProcessKey = require('./readProcessKey')
-const readFileKeySync = require('./readFileKeySync')
-const armorKeypairSync = require('../cryptography/armorKeypairSync')
-
-function invertForPrivateKeyName (filepath) {
-  const PUBLIC_KEY_SCHEMA = 'DOTENV_PUBLIC_KEY'
-  const PRIVATE_KEY_SCHEMA = 'DOTENV_PRIVATE_KEY'
-
-  if (!fsx.existsSync(filepath)) {
-    return null
-  }
-
-  const envSrc = fsx.readFileXSync(filepath)
-  const { parsed: envParsed } = scan(envSrc)
-
-  let publicKeyName
-  for (const keyName of Object.keys(envParsed)) {
-    if (keyName === PUBLIC_KEY_SCHEMA || keyName.startsWith(PUBLIC_KEY_SCHEMA)) {
-      publicKeyName = keyName // find DOTENV_PUBLIC_KEY* in filename
-    }
-  }
-
-  if (publicKeyName) {
-    return publicKeyName.replace(PUBLIC_KEY_SCHEMA, PRIVATE_KEY_SCHEMA) // return inverted (DOTENV_PUBLIC_KEY* -> DOTENV_PRIVATE_KEY*) if found
-  }
-
-  return null
-}
-
-function keyValuesSync (filepath, opts = {}) {
-  let keysFilepath = opts.keysFilepath || null
-  const noArmor = opts.noArmor === true
-  const names = keyNamesForEnvFile(filepath)
-  const publicKeyName = names.publicKeyName // DOTENV_PUBLIC_KEY_${ENVIRONMENT}
-  let privateKeyName = names.privateKeyName // DOTENV_PRIVATE_KEY_${ENVIRONMENT}
-
-  let publicKey = null
-  let privateKey = null
-  let privateKeySource = null
-
-  // public key: process.env first, then .env*
-  publicKey = readProcessKey(publicKeyName)
-  if (!publicKey) {
-    publicKey = readFileKeySync(publicKeyName, filepath) || null
-  }
-
-  // private key: process.env first, then .env.keys, then invert public key
-  privateKey = readProcessKey(privateKeyName)
-  if (!privateKey) {
-    if (keysFilepath) { // user specified -fk flag
-      keysFilepath = path.resolve(keysFilepath)
-    } else {
-      keysFilepath = path.resolve(path.dirname(filepath), '.env.keys') // typical scenario
-    }
-
-    privateKey = readFileKeySync(privateKeyName, keysFilepath)
-  }
-  // invert
-  if (!privateKey) {
-    privateKeyName = invertForPrivateKeyName(filepath)
-    if (privateKeyName) {
-      privateKey = readProcessKey(privateKeyName)
-      if (!privateKey) {
-        privateKey = readFileKeySync(privateKeyName, keysFilepath)
-      }
-    }
-  }
-
-  // armor
-  if (!noArmor && !privateKey && publicKey && publicKey.length > 0) {
-    const armorOptions = { envFilepath: filepath }
-    if (opts.token) {
-      armorOptions.token = opts.token
-    }
-    if (opts.command) {
-      armorOptions.command = opts.command
-    }
-    if (opts.noSpinner) {
-      armorOptions.noSpinner = true
-    }
-
-    const kp = armorKeypairSync(publicKey, armorOptions)
-    privateKey = kp.privateKey
-    privateKeySource = 'armor'
-  }
-
-  const result = {
-    publicKeyValue: publicKey || null, // important to make sure name is rendered
-    privateKeyValue: privateKey || null // important to make sure name is rendered
-  }
-  if (privateKeySource) {
-    result.privateKeySource = privateKeySource
-  }
-
-  return result
-}
-
-module.exports = keyValuesSync

package/src/lib/helpers/keyResolution/readFileKey.js

@@ -1,19 +0,0 @@
-const fsx = require('./../fsx')
-const { scan } = require('@dotenvx/primitives')
-
-async function readFileKey (keyName, filepath) {
-  if (!(await fsx.exists(filepath))) {
-    return undefined
-  }
-
-  const src = await fsx.readFileX(filepath)
-  const { parsed } = scan(src)
-  const values = parsed[keyName]
-
-  if (values && values.length > 0) {
-    const value = values[values.length - 1]
-    return value || undefined
-  }
-}
-
-module.exports = readFileKey

package/src/lib/helpers/keyResolution/readFileKeySync.js

@@ -1,17 +0,0 @@
-const fsx = require('./../fsx')
-const { scan } = require('@dotenvx/primitives')
-
-function readFileKeySync (keyName, filepath) {
-  if (fsx.existsSync(filepath)) {
-    const src = fsx.readFileXSync(filepath)
-    const { parsed } = scan(src)
-    const values = parsed[keyName]
-
-    if (values && values.length > 0) {
-      const value = values[values.length - 1]
-      return value || undefined
-    }
-  }
-}
-
-module.exports = readFileKeySync

package/src/lib/helpers/keyResolution/readProcessKey.js

@@ -1,7 +0,0 @@
-function readProcessKey (keyName) {
-  if (process.env[keyName] && process.env[keyName].length > 0) {
-    return process.env[keyName]
-  }
-}
-
-module.exports = readProcessKey

package/src/lib/helpers/localDisplayPath.js

@@ -1,11 +0,0 @@
-const path = require('path')
-
-function localDisplayPath (filepath) {
-  if (!filepath) return '.env.keys'
-  if (!path.isAbsolute(filepath)) return filepath
-
-  const relative = path.relative(process.cwd(), filepath)
-  return relative || path.basename(filepath)
-}
-
-module.exports = localDisplayPath

package/src/lib/helpers/parse.js

@@ -1,214 +0,0 @@
-const decryptKeyValue = require('./cryptography/decryptKeyValue')
-const { encrypted } = require('@dotenvx/primitives')
-const evalKeyValue = require('./evalKeyValue')
-const resolveEscapeSequences = require('./resolveEscapeSequences')
-
-class Parse {
-  static LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/mg
-
-  constructor (src, privateKey = null, processEnv = process.env, overload = false, privateKeyName = null) {
-    this.src = src
-    this.privateKey = privateKey
-    this.privateKeyName = privateKeyName
-    this.processEnv = processEnv
-    this.overload = overload
-
-    this.parsed = {}
-    this.preExisted = {}
-    this.injected = {}
-    this.errors = []
-
-    // for use with progressive expansion
-    this.runningParsed = {}
-    // for use with stopping expansion for literals
-    this.literals = {}
-  }
-
-  run () {
-    const lines = this.getLines()
-
-    let match
-    while ((match = Parse.LINE.exec(lines)) !== null) {
-      const key = match[1]
-      const value = match[2]
-      const quote = this.quote(value) // must be raw match
-      this.parsed[key] = this.clean(value, quote) // file value
-
-      if (!this.overload && this.inProcessEnv(key)) {
-        this.parsed[key] = this.processEnv[key] // use process.env pre-existing value
-      }
-
-      // decrypt
-      try {
-        this.parsed[key] = this.decrypt(key, this.parsed[key])
-      } catch (e) {
-        this.errors.push(e)
-      }
-
-      const encryptedPrefixed = encrypted(this.parsed[key]) // do not eval encrypted prefix
-
-      // eval empty, double, or backticks
-      let evaled = false
-      if (!encryptedPrefixed && quote !== "'" && (!this.inProcessEnv(key) || this.processEnv[key] === this.parsed[key])) {
-        const priorEvaled = this.parsed[key]
-        // eval
-        try {
-          this.parsed[key] = this.eval(key, priorEvaled)
-        } catch (e) {
-          this.errors.push(e)
-        }
-        if (priorEvaled !== this.parsed[key]) {
-          evaled = true
-        }
-      }
-
-      // expand empty, double, or backticks
-      if (!encryptedPrefixed && !evaled && quote !== "'" && (!this.processEnv[key] || this.overload)) {
-        this.parsed[key] = resolveEscapeSequences(this.expand(this.parsed[key]))
-      }
-
-      if (quote === "'") {
-        this.literals[key] = this.parsed[key]
-      }
-
-      // for use with progressive expansion
-      this.runningParsed[key] = this.parsed[key]
-
-      if (Object.prototype.hasOwnProperty.call(this.processEnv, key) && !this.overload) {
-        this.preExisted[key] = this.processEnv[key] // track preExisted
-      } else {
-        this.injected[key] = this.parsed[key] // track injected
-      }
-    }
-
-    return {
-      parsed: this.parsed,
-      processEnv: this.processEnv,
-      injected: this.injected,
-      preExisted: this.preExisted,
-      errors: this.errors
-    }
-  }
-
-  trimmer (value) {
-    // Default undefined or null to empty string
-    return (value || '').trim()
-  }
-
-  quote (value) {
-    const v = this.trimmer(value)
-    const maybeQuote = v[0]
-    let q = ''
-    switch (maybeQuote) {
-      // single
-      case "'":
-        q = "'"
-        break
-      // double
-      case '"':
-        q = '"'
-        break
-      // backtick
-      case '`':
-        q = '`'
-        break
-      // empty
-      default:
-        q = ''
-    }
-
-    return q
-  }
-
-  clean (value, _quote) {
-    let v = this.trimmer(value)
-
-    // Remove surrounding quotes
-    v = v.replace(/^(['"`])([\s\S]*)\1$/mg, '$2')
-
-    // Expand newlines if double quoted
-    if (_quote === '"') {
-      v = v.replace(/\\n/g, '\n') // newline
-      v = v.replace(/\\r/g, '\r') // carriage return
-      v = v.replace(/\\t/g, '\t') // tabs
-    }
-
-    return v
-  }
-
-  decrypt (key, value) {
-    return decryptKeyValue(key, value, this.privateKeyName, this.privateKey)
-  }
-
-  eval (key, value) {
-    return evalKeyValue(key, value, this.processEnv, this.runningParsed)
-  }
-
-  expand (value) {
-    let env = { ...this.runningParsed, ...this.processEnv } // typically process.env wins
-    if (this.overload) {
-      env = { ...this.processEnv, ...this.runningParsed } // parsed wins
-    }
-
-    const regex = /(?<!\\)\${([^{}]+)}|(?<!\\)\$([A-Za-z_][A-Za-z0-9_]*)/g
-
-    let result = value
-    let match
-
-    while ((match = regex.exec(result)) !== null) {
-      const [template, bracedExpression, unbracedExpression] = match
-      const expression = bracedExpression || unbracedExpression
-
-      // match the operators `:+`, `+`, `:-`, and `-`
-      const opRegex = /(:\+|\+|:-|-)/
-      // find first match
-      const opMatch = expression.match(opRegex)
-      const splitter = opMatch ? opMatch[0] : null
-
-      const r = expression.split(splitter)
-
-      let defaultValue
-      let value
-      const key = r.shift()
-
-      if ([':+', '+'].includes(splitter)) {
-        defaultValue = env[key] ? r.join(splitter) : ''
-        value = null
-      } else {
-        defaultValue = r.join(splitter)
-        value = env[key]
-      }
-
-      if (value) {
-        result = result.replace(template, value)
-      } else {
-        result = result.replace(template, defaultValue)
-      }
-
-      // if the result equaled what was in env then stop expanding - handle self-referential check as well
-      if (result === env[key]) {
-        break
-      }
-
-      // if the result came from what was a literal value then stop expanding
-      // BUT only if the literal value contains expansion patterns (${...} or $VAR)
-      if (this.literals[key] && /\$\{[^}]+\}|\$[A-Za-z_][A-Za-z0-9_]*/.test(this.literals[key])) {
-        break
-      }
-
-      regex.lastIndex = 0 // reset regex search position to re-evaluate after each replacement
-    }
-
-    return result
-  }
-
-  inProcessEnv (key) {
-    return Object.prototype.hasOwnProperty.call(this.processEnv, key)
-  }
-
-  getLines () {
-    return (this.src || '').toString().replace(/\r\n?/mg, '\n') // Convert buffer to string and Convert line breaks to same format
-  }
-}
-
-module.exports = Parse

package/src/lib/helpers/pluralize.js

@@ -1,10 +0,0 @@
-function pluralize (word, count) {
-  // simple pluralization: add 's' at the end
-  if (count === 0 || count > 1) {
-    return word + 's'
-  } else {
-    return word
-  }
-}
-
-module.exports = pluralize

package/src/lib/helpers/quotes.js

@@ -1,36 +0,0 @@
-const LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/mg
-
-function quotes (src) {
-  const obj = {}
-  // Convert buffer to string
-  let lines = src.toString()
-
-  // Convert line breaks to same format
-  lines = lines.replace(/\r\n?/mg, '\n')
-
-  let match
-  while ((match = LINE.exec(lines)) != null) {
-    const key = match[1]
-
-    // Default undefined or null to empty string
-    let value = (match[2] || '')
-
-    // Remove whitespace
-    value = value.trim()
-
-    // Check if double quoted
-    const maybeQuote = value[0]
-
-    value = value.replace(/^(['"`])([\s\S]*)\1$/mg, '$2')
-
-    if (maybeQuote === value[0]) {
-      obj[key] = ''
-    } else {
-      obj[key] = maybeQuote
-    }
-  }
-
-  return obj
-}
-
-module.exports = quotes

package/src/lib/helpers/replace.js

@@ -1,82 +0,0 @@
-const { scan } = require('@dotenvx/primitives')
-const escapeForRegex = require('./escapeForRegex')
-
-function replaceExistingValue (src, key, originalValue, replaceValue) {
-  const escapedKey = escapeForRegex(key)
-  const escapedOriginalValue = escapeForRegex(originalValue)
-
-  // conditionally enforce end of line
-  let enforceEndOfLine = ''
-  if (escapedOriginalValue === '') {
-    enforceEndOfLine = '$' // EMPTY scenario
-  }
-
-  const currentPart = new RegExp(
-    '^' + // start of line
-    '(\\s*)?' + // spaces
-    '(export\\s+)?' + // export
-    escapedKey + // KEY
-    '\\s*=\\s*' + // spaces (KEY = value)
-    '(["\'`]?)' + // open quote
-    escapedOriginalValue + // escaped value
-    '\\3' + // close quote
-    enforceEndOfLine
-    ,
-    'gm' // (g)lobal (m)ultiline
-  )
-
-  return src.replace(currentPart, function (match, spaces = '', exportPart = '', quote = '') {
-    let newPart = `${key}=${quote}${replaceValue}${quote}`
-
-    // if empty quote and consecutive newlines
-    const newlineMatch = src.match(new RegExp(`${escapedKey}\\s*=\\s*\n\n`, 'm')) // match any consecutive newline scenario for a blank value
-    if (escapedOriginalValue === '' && quote === '' && newlineMatch) {
-      const newlineCount = (newlineMatch[0].match(/\n/g)).length - 1
-      for (let i = 0; i < newlineCount; i++) {
-        newPart += '\n' // re-append the extra newline to preserve user's format choice
-      }
-    }
-
-    return `${spaces}${exportPart}${newPart}`
-  })
-}
-
-function replace (src, key, replaceValue) {
-  let output
-  let newPart = ''
-
-  const { parsed } = scan(src, { expandDoubleQuotedNewlines: false, convertWindowsNewlines: false })
-  if (Object.prototype.hasOwnProperty.call(parsed, key)) {
-    const allValues = parsed[key]
-    let duplicateOutput = src
-    const replacements = Array.isArray(replaceValue) ? replaceValue : allValues.map(() => replaceValue)
-    const replacementByValue = new Map()
-
-    allValues.forEach((value, index) => {
-      if (!replacementByValue.has(value)) {
-        replacementByValue.set(value, replacements[index])
-      }
-    })
-
-    for (const [value, replacement] of replacementByValue) {
-      duplicateOutput = replaceExistingValue(duplicateOutput, key, value, replacement)
-    }
-
-    return duplicateOutput
-  } else {
-    newPart += `${key}="${replaceValue}"`
-
-    // append
-    if (src.endsWith('\n')) {
-      newPart = newPart + '\n'
-    } else {
-      newPart = '\n' + newPart
-    }
-
-    output = src + newPart
-  }
-
-  return output
-}
-
-module.exports = replace

package/src/lib/helpers/resolveEscapeSequences.js

@@ -1,5 +0,0 @@
-function resolveEscapeSequences (value) {
-  return value.replace(/\\\$/g, '$')
-}
-
-module.exports = resolveEscapeSequences