@dotenvx/dotenvx 1.75.0 → 2.0.0

package/src/lib/resolvers/envs.js

@@ -0,0 +1,302 @@
+const fsx = require('./../helpers/fsx')
+const path = require('path')
+const { encrypted, parse, parseSync } = require('@dotenvx/primitives')
+
+const TYPE_ENV = 'env'
+const TYPE_ENV_FILE = 'envFile'
+
+const Errors = require('./../helpers/errors')
+const detectEncoding = require('./../helpers/detectEncoding')
+const detectEncodingSync = require('./../helpers/detectEncodingSync')
+const keynames = require('./../conventions/keynames')
+const providers = require('./../providers')
+
+function unresolvedEncryptedErrors (parsed) {
+  const keys = []
+  for (const [key, value] of Object.entries(parsed)) {
+    if (encrypted(value)) {
+      keys.push(key)
+    }
+  }
+
+  if (keys.length < 1) {
+    return []
+  }
+
+  return [new Errors({ message: `could not decrypt ${keys.join(', ')}` }).decryptionFailed()]
+}
+
+function decryptErrors (parsed, errors) {
+  const mappedErrors = (errors || []).map(error => {
+    return new Errors({
+      code: error.code,
+      message: error.message,
+      help: error.help
+    }).custom()
+  })
+
+  if (mappedErrors.length > 0) {
+    return mappedErrors
+  }
+
+  return unresolvedEncryptedErrors(parsed)
+}
+
+function inject (processEnv, parsed) {
+  for (const key of Object.keys(parsed)) {
+    processEnv[key] = parsed[key]
+  }
+}
+
+function buildParseOptions ({ processEnv, overload, envKeysFilepath, provider }) {
+  const options = {
+    processEnv,
+    overload,
+    fk: envKeysFilepath
+  }
+
+  if (provider) {
+    options.provider = provider
+  } else {
+    options.provider = null
+  }
+
+  return options
+}
+
+async function injectEnv ({ env, overload, processEnv, envKeysFilepath, provider }) {
+  const row = {}
+  row.type = TYPE_ENV
+  row.string = env.value
+
+  try {
+    const parseProcessEnv = { ...processEnv }
+    if (env.privateKeyName && Object.prototype.hasOwnProperty.call(processEnv, env.privateKeyName)) {
+      parseProcessEnv[env.privateKeyName] = processEnv[env.privateKeyName]
+    }
+
+    const parseOptions = buildParseOptions({
+      processEnv: parseProcessEnv,
+      overload,
+      envKeysFilepath,
+      provider
+    })
+
+    const {
+      parsed,
+      errors,
+      injected,
+      existed
+    } = await parse(env.value, parseOptions)
+
+    row.parsed = parsed
+    row.errors = decryptErrors(parsed, errors)
+    row.injected = injected || {}
+    row.existed = existed || {}
+
+    inject(processEnv, row.parsed)
+  } catch (e) {
+    row.errors = [e]
+  }
+
+  return row
+}
+
+function injectEnvSync ({ env, overload, processEnv, envKeysFilepath, provider }) {
+  const row = {}
+  row.type = TYPE_ENV
+  row.string = env.value
+
+  try {
+    const parseProcessEnv = { ...processEnv }
+    if (env.privateKeyName && Object.prototype.hasOwnProperty.call(processEnv, env.privateKeyName)) {
+      parseProcessEnv[env.privateKeyName] = processEnv[env.privateKeyName]
+    }
+
+    const parseOptions = buildParseOptions({
+      processEnv: parseProcessEnv,
+      overload,
+      envKeysFilepath,
+      provider
+    })
+
+    const {
+      parsed,
+      errors,
+      injected,
+      existed
+    } = parseSync(env.value, parseOptions)
+
+    row.parsed = parsed
+    row.errors = decryptErrors(parsed, errors)
+    row.injected = injected || {}
+    row.existed = existed || {}
+
+    inject(processEnv, row.parsed)
+  } catch (e) {
+    row.errors = [e]
+  }
+
+  return row
+}
+
+async function injectEnvFile ({ env, overload, processEnv, envKeysFilepath, provider, readableFilepaths }) {
+  const row = {}
+  row.type = TYPE_ENV_FILE
+  row.filepath = env.value
+
+  const filepath = path.resolve(env.value)
+  try {
+    const encoding = await detectEncoding(filepath)
+    const src = await fsx.readFileX(filepath, { encoding })
+    readableFilepaths.add(env.value)
+
+    const { privateKeyName } = keynames(filepath)
+    const fk = envKeysFilepath || (processEnv[privateKeyName] ? null : path.resolve(path.dirname(filepath), '.env.keys'))
+    const parseOptions = buildParseOptions({
+      processEnv,
+      overload,
+      envKeysFilepath: fk,
+      provider
+    })
+
+    const {
+      parsed,
+      errors,
+      injected,
+      existed
+    } = await parse(src, parseOptions)
+
+    row.src = src
+    row.parsed = parsed
+    row.injected = injected || {}
+    row.errors = decryptErrors(parsed, errors)
+    row.existed = existed || {}
+
+    inject(processEnv, parsed)
+  } catch (e) {
+    if (e.code === 'ENOENT' || e.code === 'EISDIR') {
+      row.errors = [new Errors({ envFilepath: env.value, filepath }).missingEnvFile()]
+    } else {
+      row.errors = [e]
+    }
+  }
+
+  return row
+}
+
+function injectEnvFileSync ({ env, overload, processEnv, envKeysFilepath, provider, readableFilepaths }) {
+  const row = {}
+  row.type = TYPE_ENV_FILE
+  row.filepath = env.value
+
+  const filepath = path.resolve(env.value)
+  try {
+    const encoding = detectEncodingSync(filepath)
+    const src = fsx.readFileXSync(filepath, { encoding })
+    readableFilepaths.add(env.value)
+
+    const { privateKeyName } = keynames(filepath)
+    const fk = envKeysFilepath || (processEnv[privateKeyName] ? null : path.resolve(path.dirname(filepath), '.env.keys'))
+    const parseOptions = buildParseOptions({
+      processEnv,
+      overload,
+      envKeysFilepath: fk,
+      provider
+    })
+
+    const {
+      parsed,
+      errors,
+      injected,
+      existed
+    } = parseSync(src, parseOptions)
+
+    row.src = src
+    row.parsed = parsed
+    row.injected = injected || {}
+    row.errors = decryptErrors(parsed, errors)
+    row.existed = existed || {}
+
+    inject(processEnv, parsed)
+  } catch (e) {
+    if (e.code === 'ENOENT' || e.code === 'EISDIR') {
+      row.errors = [new Errors({ envFilepath: env.value, filepath }).missingEnvFile()]
+    } else {
+      row.errors = [e]
+    }
+  }
+
+  return row
+}
+
+async function envs (options = {}) {
+  const processedEnvs = []
+  const readableFilepaths = new Set()
+  const processEnv = options.processEnv || process.env
+  const envKeysFilepath = options.envKeysFilepath || options.envKeysFile || null
+  const provider = options.noArmor ? null : await providers(options)
+
+  for (const env of options.envs || []) {
+    if (env.type === TYPE_ENV_FILE) {
+      processedEnvs.push(await injectEnvFile({
+        env,
+        overload: options.overload,
+        processEnv,
+        envKeysFilepath,
+        provider,
+        readableFilepaths
+      }))
+    } else if (env.type === TYPE_ENV) {
+      processedEnvs.push(await injectEnv({
+        env,
+        overload: options.overload,
+        processEnv,
+        envKeysFilepath,
+        provider
+      }))
+    }
+  }
+
+  return {
+    processedEnvs,
+    readableFilepaths: [...readableFilepaths]
+  }
+}
+
+function envsSync (options = {}) {
+  const processedEnvs = []
+  const readableFilepaths = new Set()
+  const processEnv = options.processEnv || process.env
+  const envKeysFilepath = options.envKeysFilepath || options.envKeysFile || null
+  const provider = options.noArmor ? null : providers.sync(options)
+
+  for (const env of options.envs || []) {
+    if (env.type === TYPE_ENV_FILE) {
+      processedEnvs.push(injectEnvFileSync({
+        env,
+        overload: options.overload,
+        processEnv,
+        envKeysFilepath,
+        provider,
+        readableFilepaths
+      }))
+    } else if (env.type === TYPE_ENV) {
+      processedEnvs.push(injectEnvSync({
+        env,
+        overload: options.overload,
+        processEnv,
+        envKeysFilepath,
+        provider
+      }))
+    }
+  }
+
+  return {
+    processedEnvs,
+    readableFilepaths: [...readableFilepaths]
+  }
+}
+
+module.exports = envs
+module.exports.sync = envsSync

package/src/lib/resolvers/get.js

@@ -0,0 +1,69 @@
+const envsResolver = require('./envs')
+const Errors = require('./../helpers/errors')
+const { determine } = require('./../helpers/envResolution')
+
+function collectErrors (processedEnvs) {
+  const errors = []
+  for (const processedEnv of processedEnvs) {
+    for (const error of processedEnv.errors || []) {
+      errors.push(error)
+    }
+  }
+  return errors
+}
+
+function result ({ key, all, processedEnvs, processEnv }) {
+  const errors = collectErrors(processedEnvs)
+
+  if (key) {
+    const parsed = {}
+    const value = processEnv[key]
+    parsed[key] = value
+
+    if (value === undefined) {
+      errors.push(new Errors({ key }).missingKey())
+    }
+
+    return { parsed, errors }
+  }
+
+  if (all) {
+    return { parsed: processEnv, errors }
+  }
+
+  const parsed = {}
+  for (const processedEnv of processedEnvs) {
+    if (processedEnv.parsed) {
+      for (const key of Object.keys(processedEnv.parsed)) {
+        parsed[key] = processEnv[key]
+      }
+    }
+  }
+
+  return { parsed, errors }
+}
+
+function buildOptions (options, processEnv) {
+  return {
+    envs: determine(options.envs || [], processEnv),
+    overload: options.overload,
+    processEnv,
+    envKeysFilepath: options.envKeysFilepath || options.envKeysFile || null,
+    noArmor: options.noArmor,
+    onStatus: options.onStatus
+  }
+}
+
+async function get (options = {}) {
+  const processEnv = { ...(options.processEnv || process.env) }
+  const { processedEnvs } = await envsResolver(buildOptions(options, processEnv))
+
+  return result({
+    key: options.key,
+    all: options.all,
+    processedEnvs,
+    processEnv
+  })
+}
+
+module.exports = get

package/src/lib/resolvers/keypair.js

@@ -0,0 +1,81 @@
+const fsx = require('./../helpers/fsx')
+const path = require('path')
+const keynames = require('./../conventions/keynames')
+const filepaths = require('./../conventions/filepaths')
+
+const { keyring, keyringSync, publickeys } = require('@dotenvx/primitives')
+const providers = require('./../providers')
+
+function buildOptions ({ publicKey, processEnv, fk }) {
+  const ring = {}
+  if (publicKey) {
+    ring[publicKey] = ''
+  }
+
+  const options = {
+    processEnv,
+    fk,
+    ring
+  }
+
+  return options
+}
+
+function outputKeypair ({ out, filepath, publicKey, ring }) {
+  const { publicKeyName, privateKeyName } = keynames(filepath)
+
+  out[publicKeyName] = publicKey || null
+  out[privateKeyName] = publicKey ? ring[publicKey] || null : null
+}
+
+async function keypair (options = {}) {
+  const out = {}
+  const processEnv = options.processEnv || process.env
+
+  for (const filepath of filepaths(options.envFile)) {
+    const src = await fsx.readFileX(filepath)
+    const publicKey = publickeys(src)[0]
+
+    const keyringOptions = buildOptions({
+      publicKey,
+      processEnv,
+      fk: options.envKeysFilepath || options.envKeysFile || path.resolve(path.dirname(filepath), '.env.keys')
+    })
+
+    const provider = await providers(options)
+    keyringOptions.provider = provider
+
+    const ring = await keyring(keyringOptions)
+
+    outputKeypair({ out, filepath, publicKey, ring })
+  }
+
+  return out
+}
+
+function keypairSync (options = {}) {
+  const out = {}
+  const processEnv = options.processEnv || process.env
+
+  for (const filepath of filepaths(options.envFile)) {
+    const src = fsx.readFileXSync(filepath)
+    const publicKey = publickeys(src)[0]
+
+    const keyringOptions = buildOptions({
+      publicKey,
+      processEnv,
+      fk: options.envKeysFilepath || options.envKeysFile || path.resolve(path.dirname(filepath), '.env.keys')
+    })
+    const provider = providers.sync(options)
+    keyringOptions.provider = provider
+
+    const ring = keyringSync(keyringOptions)
+
+    outputKeypair({ out, filepath, publicKey, ring })
+  }
+
+  return out
+}
+
+module.exports = keypair
+module.exports.sync = keypairSync

package/src/lib/resolvers/ls.js

@@ -0,0 +1,41 @@
+const { fdir: Fdir } = require('fdir')
+const path = require('path')
+const picomatch = require('picomatch')
+
+function patternsFor (value) {
+  if (!Array.isArray(value)) {
+    return [`**/${value}`]
+  }
+
+  return value.map(part => `**/${part}`)
+}
+
+function excludePatternsFor (value) {
+  if (!Array.isArray(value)) {
+    return [`**/${value}`]
+  }
+
+  return value.map(part => `**/${part}`)
+}
+
+function ls (options = {}) {
+  const ignore = ['node_modules/**', '**/node_modules/**', '.git/**', '**/.git/**']
+  const cwd = path.resolve(options.directory || './')
+  const envFile = options.envFile || ['.env*']
+  const excludeEnvFile = options.excludeEnvFile || []
+  const excludePatterns = excludePatternsFor(excludeEnvFile)
+  const excludes = excludePatterns.length > 0 ? ignore.concat(excludePatterns) : ignore
+  const exclude = picomatch(excludes, { dot: true })
+  const include = picomatch(patternsFor(envFile), {
+    dot: true,
+    ignore: excludes
+  })
+
+  return new Fdir()
+    .withRelativePaths()
+    .filter((filepath) => !exclude(filepath) && include(filepath))
+    .crawl(cwd)
+    .sync()
+}
+
+module.exports = ls

package/src/lib/services/armorDown.js

@@ -1,6 +1,6 @@
 const prompts = require('../helpers/prompts')
 const PostArmorDown = require('../api/postArmorDown')
-const keyNamesForEnvFile = require('../helpers/keyResolution/keyNamesForEnvFile')
+const keynames = require('../conventions/keynames')
 const upsertEnvKey = require('../helpers/upsertEnvKey')
 const readEnvKey = require('../helpers/readEnvKey')
 const teamChoicesFromMeta = require('../helpers/teamChoicesFromMeta')
@@ -24,7 +24,7 @@ class ArmorDown {
     const {
       publicKeyName,
       privateKeyName
-    } = keyNamesForEnvFile(envFile)
+    } = keynames(envFile)
 
     const publicKey = readEnvKey(publicKeyName, envFile, { strict: true, ignore: ['MISSING_PRIVATE_KEY'] })
     let json

package/src/lib/services/{armorKeypair.js → armorKeyring.js}

@@ -1,7 +1,4 @@
-const prompts = require('../helpers/prompts')
-const PostKeypair = require('../api/postKeypair')
-const keypairMetadata = require('../helpers/keypairMetadata')
-const teamChoicesFromMeta = require('../helpers/teamChoicesFromMeta')
+const PostArmorKeyring = require('../api/postArmorKeyring')
 
 const ACCESS_APPROVAL_REQUIRED = 'ACCESS_APPROVAL_REQUIRED'
 const ACCESS_APPROVAL_PENDING = 'ACCESS_APPROVAL_PENDING'
@@ -40,44 +37,37 @@ function approvalTimeoutError () {
   return error
 }
 
-class ArmorKeypair {
-  constructor (hostname, token, devicePublicKey, publicKey, options = {}) {
+class ArmorKeyring {
+  constructor (hostname, token, devicePublicKey, publicKey) {
     this.hostname = hostname
     this.token = token
     this.devicePublicKey = devicePublicKey
     this.publicKey = publicKey
-    this.team = options.team
-    this.envFile = options.envFile || '.env'
-    this.metadata = options.metadata
     this.onApprovalRequired = null
   }
 
-  async request (team, metadata, grantToken) {
+  async request (grantToken) {
     if (grantToken !== undefined) {
-      return await new PostKeypair(
+      return await new PostArmorKeyring(
         this.hostname,
         this.token,
         this.devicePublicKey,
         this.publicKey,
-        team,
-        metadata,
         grantToken
       ).run()
     }
 
-    return await new PostKeypair(
+    return await new PostArmorKeyring(
       this.hostname,
       this.token,
       this.devicePublicKey,
-      this.publicKey,
-      team,
-      metadata
+      this.publicKey
     ).run()
   }
 
-  async requestWithApprovalPolling (team, metadata) {
+  async requestWithApprovalPolling () {
     try {
-      return await this.request(team, metadata)
+      return await this.request()
     } catch (error) {
       if (!isAccessApprovalRequired(error)) {
         throw error
@@ -97,16 +87,16 @@ class ArmorKeypair {
         this.onApprovalRequired({ approvalUri, code: error.code })
       }
 
-      return await this.poll(team, metadata, grantToken)
+      return await this.poll(grantToken)
     }
   }
 
-  async poll (team, metadata, grantToken) {
+  async poll (grantToken) {
     const startedAt = Date.now()
 
     while (true) {
       try {
-        return await this.request(team, metadata, grantToken)
+        return await this.request(grantToken)
       } catch (error) {
         if (!isAccessPending(error)) {
           throw error
@@ -122,35 +112,8 @@ class ArmorKeypair {
   }
 
   async run () {
-    const metadata = keypairMetadata(this.envFile, this.metadata)
-
-    if (this.team) {
-      return await this.requestWithApprovalPolling(this.team, metadata)
-    }
-
-    try {
-      return await this.requestWithApprovalPolling(undefined, metadata)
-    } catch (error) {
-      if (error.code !== 'DOTENVX_TEAM_REQUIRED') {
-        throw error
-      }
-
-      const choices = teamChoicesFromMeta(error.meta)
-
-      let team = choices[0].value
-      if (choices.length > 1) {
-        team = await prompts.select({
-          message: 'Select team',
-          choices
-        }, {
-          input: process.stdin,
-          output: process.stderr
-        })
-      }
-
-      return await this.requestWithApprovalPolling(team, metadata)
-    }
+    return await this.requestWithApprovalPolling()
   }
 }
 
-module.exports = ArmorKeypair
+module.exports = ArmorKeyring

package/src/lib/services/armorMove.js

@@ -1,7 +1,7 @@
 const prompts = require('../helpers/prompts')
 const PostArmorMove = require('../api/postArmorMove')
 const GetAccount = require('../api/getAccount')
-const keyNamesForEnvFile = require('../helpers/keyResolution/keyNamesForEnvFile')
+const keynames = require('../conventions/keynames')
 const readEnvKey = require('../helpers/readEnvKey')
 
 class ArmorMove {
@@ -24,7 +24,7 @@ class ArmorMove {
     const {
       publicKeyName,
       privateKeyName
-    } = keyNamesForEnvFile(envFile)
+    } = keynames(envFile)
     const publicKey = readEnvKey(publicKeyName, envFile, { strict: true, ignore: ['MISSING_PRIVATE_KEY'] })
 
     const accountJson = await new GetAccount(hostname, token).run()

package/src/lib/services/armorPull.js

@@ -1,7 +1,7 @@
 const prompts = require('../helpers/prompts')
 const PostArmorPull = require('../api/postArmorPull')
 const upsertEnvKey = require('../helpers/upsertEnvKey')
-const keyNamesForEnvFile = require('../helpers/keyResolution/keyNamesForEnvFile')
+const keynames = require('../conventions/keynames')
 const readEnvKey = require('../helpers/readEnvKey')
 const teamChoicesFromMeta = require('../helpers/teamChoicesFromMeta')
 
@@ -24,7 +24,7 @@ class ArmorPull {
     const {
       publicKeyName,
       privateKeyName
-    } = keyNamesForEnvFile(envFile)
+    } = keynames(envFile)
 
     const publicKey = readEnvKey(publicKeyName, envFile, { strict: true, ignore: ['MISSING_PRIVATE_KEY'] })
     let json

package/src/lib/services/armorPush.js

@@ -1,7 +1,7 @@
 const { derive } = require('@dotenvx/primitives')
 const prompts = require('../helpers/prompts')
 const PostArmorPush = require('../api/postArmorPush')
-const keyNamesForEnvFile = require('../helpers/keyResolution/keyNamesForEnvFile')
+const keynames = require('../conventions/keynames')
 const readEnvKey = require('../helpers/readEnvKey')
 const teamChoicesFromMeta = require('../helpers/teamChoicesFromMeta')
 
@@ -29,7 +29,7 @@ class ArmorPush {
     const envFile = this.envFile
     const team = this.team
 
-    const { privateKeyName } = keyNamesForEnvFile(envFile)
+    const { privateKeyName } = keynames(envFile)
 
     const privateKey = readEnvKey(privateKeyName, '.env.keys', { strict: true })
     const publicKey = publicKeyFromPrivateKey(privateKey)

package/src/lib/services/armorUp.js

@@ -1,6 +1,6 @@
 const prompts = require('../helpers/prompts')
 const PostArmorUp = require('../api/postArmorUp')
-const keyNamesForEnvFile = require('../helpers/keyResolution/keyNamesForEnvFile')
+const keynames = require('../conventions/keynames')
 const removeEnvKey = require('../helpers/removeEnvKey')
 const readEnvKey = require('../helpers/readEnvKey')
 const teamChoicesFromMeta = require('../helpers/teamChoicesFromMeta')
@@ -24,7 +24,7 @@ class ArmorUp {
     const {
       publicKeyName,
       privateKeyName
-    } = keyNamesForEnvFile(envFile)
+    } = keynames(envFile)
 
     const publicKey = readEnvKey(publicKeyName, envFile, { strict: true, ignore: ['MISSING_PRIVATE_KEY'] })
     const privateKey = readEnvKey(privateKeyName, '.env.keys', { strict: true, ignore: ['MISSING_KEY'] })