@dotenvx/next-env 0.1.0 → 1.74.3

package/node_modules/@dotenvx/dotenvx/src/lib/helpers/parse.js

@@ -0,0 +1,214 @@
+const decryptKeyValue = require('./cryptography/decryptKeyValue')
+const isEncrypted = require('./cryptography/isEncrypted')
+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 = isEncrypted(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/node_modules/@dotenvx/dotenvx/src/lib/helpers/pluralize.js

@@ -0,0 +1,10 @@
+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/node_modules/@dotenvx/dotenvx/src/lib/helpers/prependPublicKey.js

@@ -0,0 +1,17 @@
+function prependPublicKey (publicKeyName, publicKey, filename, relativeFilepath = '.env.keys') {
+  const comment = relativeFilepath === '.env.keys'
+    ? ''
+    : ` # -fk ${relativeFilepath}`
+
+  return [
+    '#/-------------------[DOTENV_PUBLIC_KEY]--------------------/',
+    '#/            public-key encryption for .env files          /',
+    '#/       [how it works](https://dotenvx.com/encryption)     /',
+    '#/----------------------------------------------------------/',
+    `${publicKeyName}="${publicKey}"${comment}`,
+    '',
+    `# ${filename}`
+  ].join('\n')
+}
+
+module.exports = prependPublicKey

package/node_modules/@dotenvx/dotenvx/src/lib/helpers/preserveShebang.js

@@ -0,0 +1,16 @@
+function preserveShebang (envSrc) {
+  const [firstLine, ...remainingLines] = envSrc.split('\n')
+  let firstLinePreserved = ''
+
+  if (firstLine.startsWith('#!')) {
+    firstLinePreserved = firstLine + '\n'
+    envSrc = remainingLines.join('\n')
+  }
+
+  return {
+    firstLinePreserved,
+    envSrc
+  }
+}
+
+module.exports = preserveShebang

package/node_modules/@dotenvx/dotenvx/src/lib/helpers/prompts.js

@@ -0,0 +1,43 @@
+const Enquirer = require('enquirer')
+
+const enquirer = new Enquirer()
+
+function choicesForSelect (choices) {
+  return choices.map(choice => {
+    if (typeof choice === 'string') return choice
+
+    return {
+      name: choice.value,
+      message: choice.name || choice.value
+    }
+  })
+}
+
+function enquirerOptions (context = {}) {
+  const options = {
+    // Enquirer names the render stream stdout; use stderr so stdout stays machine-readable.
+    stdout: context.output || process.stderr
+  }
+
+  if (context.input) {
+    options.stdin = context.input
+  }
+
+  return options
+}
+
+async function select ({ message, choices }, context) {
+  const answer = await enquirer.prompt({
+    type: 'select',
+    name: 'value',
+    message,
+    choices: choicesForSelect(choices),
+    ...enquirerOptions(context)
+  })
+
+  return answer.value
+}
+
+module.exports = {
+  select
+}

package/node_modules/@dotenvx/dotenvx/src/lib/helpers/quotes.js

@@ -0,0 +1,36 @@
+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/node_modules/@dotenvx/dotenvx/src/lib/helpers/readEnvKey.js

@@ -0,0 +1,31 @@
+const fs = require('fs')
+const dotenvParse = require('./dotenvParse')
+const Errors = require('./errors')
+
+function ignored (error, options) {
+  return (options.ignore || []).includes(error.code)
+}
+
+function readEnvKey (key, filepath, options = {}) {
+  let src
+  try {
+    src = fs.readFileSync(filepath)
+  } catch (_error) {
+    const error = new Errors({ envFilepath: filepath }).missingEnvFile()
+    if (ignored(error, options)) return undefined
+    if (options.strict) throw error
+    return undefined
+  }
+
+  const parsed = dotenvParse(src)
+  const value = parsed[key]
+  if (value === undefined) {
+    const error = new Errors({ key }).missingKey()
+    if (ignored(error, options)) return undefined
+    if (options.strict) throw error
+  }
+
+  return value
+}
+
+module.exports = readEnvKey

package/node_modules/@dotenvx/dotenvx/src/lib/helpers/removeDynamicHelpSection.js

@@ -0,0 +1,21 @@
+// Remove Arguments section from help text. example:
+// Arguments:
+// command     dynamic command
+// args        dynamic command arguments
+
+function removeDynamicHelpSection (lines) {
+  let argumentsHelpIndex
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i] === 'Arguments:') {
+      argumentsHelpIndex = i
+      break
+    }
+  }
+  if (argumentsHelpIndex) {
+    lines.splice(argumentsHelpIndex, 4) // remove Arguments and the following 3 lines
+  }
+
+  return lines
+}
+
+module.exports = removeDynamicHelpSection

package/node_modules/@dotenvx/dotenvx/src/lib/helpers/removeEnvKey.js

@@ -0,0 +1,50 @@
+const fs = require('fs')
+const path = require('path')
+
+function escapeForRegex (value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+}
+
+function removeEnvKey (key, keysFilepath = '.env.keys') {
+  const resolvedKeysFilepath = path.resolve(keysFilepath)
+
+  if (!fs.existsSync(resolvedKeysFilepath)) {
+    return {
+      changed: false,
+      key,
+      filepath: keysFilepath
+    }
+  }
+
+  const src = fs.readFileSync(resolvedKeysFilepath, 'utf8')
+  const eol = src.includes('\r\n') ? '\r\n' : '\n'
+  const keyPattern = new RegExp(`^\\s*(?:export\\s+)?${escapeForRegex(key)}\\s*=`)
+  const envKeyPattern = /^\s*(?:export\s+)?[A-Za-z_][A-Za-z0-9_]*\s*=/
+  const lines = src.length > 0 ? src.split(/\r?\n/) : []
+
+  while (lines.length > 0 && lines[lines.length - 1] === '') {
+    lines.pop()
+  }
+
+  const nextLines = lines.filter((line) => !keyPattern.test(line))
+  const changed = nextLines.length !== lines.length
+
+  if (changed) {
+    const hasRemainingKeys = nextLines.some((line) => envKeyPattern.test(line))
+
+    if (hasRemainingKeys) {
+      const nextSrc = `${nextLines.join(eol)}${eol}`
+      fs.writeFileSync(resolvedKeysFilepath, nextSrc, 'utf8')
+    } else {
+      fs.rmSync(resolvedKeysFilepath, { force: true })
+    }
+  }
+
+  return {
+    changed,
+    key,
+    filepath: keysFilepath
+  }
+}
+
+module.exports = removeEnvKey

package/node_modules/@dotenvx/dotenvx/src/lib/helpers/removeOptionsHelpParts.js

@@ -0,0 +1,42 @@
+// Remove [options] from help text. example:
+
+function removeOptionsHelpParts (lines) {
+  for (let i = 0; i < lines.length; i++) {
+    lines[i] = lines[i].replace(' [options]', '')
+  }
+
+  let commandsStart = -1
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i] === 'Commands:') {
+      commandsStart = i + 1
+      break
+    }
+  }
+
+  if (commandsStart !== -1) {
+    const commands = []
+
+    for (let i = commandsStart; i < lines.length; i++) {
+      const line = lines[i]
+      if (line === '' || line.endsWith(':')) {
+        break
+      }
+
+      const match = line.match(/^(\s{2})(\S(?:.*\S)?)\s{2,}(\S.*)$/)
+      if (match) {
+        commands.push({ index: i, indent: match[1], command: match[2], description: match[3] })
+      }
+    }
+
+    if (commands.length > 0) {
+      const maxCommandLength = commands.reduce((max, item) => Math.max(max, item.command.length), 0)
+      for (const item of commands) {
+        lines[item.index] = `${item.indent}${item.command.padEnd(maxCommandLength + 2)}${item.description}`
+      }
+    }
+  }
+
+  return lines
+}
+
+module.exports = removeOptionsHelpParts

package/node_modules/@dotenvx/dotenvx/src/lib/helpers/replace.js

@@ -0,0 +1,82 @@
+const dotenvParse = require('./dotenvParse')
+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 = dotenvParse(src, true, true, true) // skip expanding \n and skip converting \r\n
+  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/node_modules/@dotenvx/dotenvx/src/lib/helpers/resolveEscapeSequences.js

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

package/node_modules/@dotenvx/dotenvx/src/lib/helpers/resolveHome.js

@@ -0,0 +1,12 @@
+const os = require('os')
+const path = require('path')
+
+function resolveHome (filepath) {
+  if (filepath[0] === '~') {
+    return path.join(os.homedir(), filepath.slice(1))
+  }
+
+  return filepath
+}
+
+module.exports = resolveHome

package/node_modules/@dotenvx/dotenvx/src/lib/helpers/sanitizeCommandForMetadata.js

@@ -0,0 +1,64 @@
+function commandParts (command) {
+  if (Array.isArray(command)) {
+    return command.map(arg => `${arg}`)
+  }
+
+  const parts = []
+  const src = `${command}`
+  const regex = /"([^"\\]*(?:\\.[^"\\]*)*)"|'([^'\\]*(?:\\.[^'\\]*)*)'|(\S+)/g
+  let match
+
+  while ((match = regex.exec(src)) !== null) {
+    parts.push(match[1] || match[2] || match[3])
+  }
+
+  return parts
+}
+
+function flagName (part) {
+  if (!part.startsWith('--')) return null
+  return part.slice(2).split('=')[0].toLowerCase()
+}
+
+function isSecretFlag (part) {
+  const name = flagName(part)
+  if (!name) return false
+  if (name === 'pass' || name === 'password' || name === 'passphrase' || name === 'pwd') return true
+
+  return name.includes('token') ||
+    name.includes('password') ||
+    name.includes('secret') ||
+    name.includes('api-key') ||
+    name.includes('apikey') ||
+    name.includes('private-key')
+}
+
+function sanitizeCommandForMetadata (command) {
+  const parts = commandParts(command)
+  const sanitized = []
+
+  for (let i = 0; i < parts.length; i++) {
+    const part = parts[i]
+
+    if (isSecretFlag(part) && part.includes('=')) {
+      const name = part.split('=')[0]
+      sanitized.push(`${name}=[REDACTED]`)
+      continue
+    }
+
+    if (isSecretFlag(part)) {
+      sanitized.push(part)
+      if (i + 1 < parts.length) {
+        sanitized.push('[REDACTED]')
+        i++
+      }
+      continue
+    }
+
+    sanitized.push(part)
+  }
+
+  return sanitized.join(' ')
+}
+
+module.exports = sanitizeCommandForMetadata

package/node_modules/@dotenvx/dotenvx/src/lib/helpers/teamChoicesFromMeta.js

@@ -0,0 +1,8 @@
+function teamChoicesFromMeta (meta) {
+  return meta.organizations.map(org => ({
+    name: org.provider_slug,
+    value: org.provider_slug
+  }))
+}
+
+module.exports = teamChoicesFromMeta

package/node_modules/@dotenvx/dotenvx/src/lib/helpers/truncate.js

@@ -0,0 +1,10 @@
+function truncate (str, showChar = 7) {
+  if (str && str.length > 0) {
+    const visiblePart = str.slice(0, showChar)
+    return visiblePart + '…'
+  } else {
+    return ''
+  }
+}
+
+module.exports = truncate