@dotenvx/dotenvx 1.75.1 → 2.0.0

package/src/lib/helpers/cryptography/mutateKeysSrc.js

@@ -6,32 +6,16 @@ const FIRST_TIME_KEYS_SRC = [
   '#/----------------------------------------------------------/'
 ].join('\n')
 
-const path = require('path')
-const fsx = require('./../fsx')
+function mutateKeysSrc ({ keysSrc, privateKeyName, privateKeyValue, comment }) {
+  const appendPrivateKey = [`# ${comment}`, `${privateKeyName}=${privateKeyValue}`, ''].join('\n')
 
-async function mutateKeysSrc ({ envFilepath, keysFilepath, privateKeyName, privateKeyValue }) {
-  const filename = path.basename(envFilepath)
-  const filepath = path.resolve(envFilepath)
-  let resolvedKeysFilepath = path.join(path.dirname(filepath), '.env.keys')
-  if (keysFilepath) {
-    resolvedKeysFilepath = path.resolve(keysFilepath)
+  if (!keysSrc || keysSrc.length < 1) {
+    keysSrc = `${FIRST_TIME_KEYS_SRC}\n`
   }
-  const appendPrivateKey = [`# ${filename}`, `${privateKeyName}=${privateKeyValue}`, ''].join('\n')
-
-  let keysSrc = ''
-  if (await fsx.exists(resolvedKeysFilepath)) {
-    keysSrc = await fsx.readFileX(resolvedKeysFilepath)
-  }
-  keysSrc = keysSrc.length > 1 ? keysSrc : `${FIRST_TIME_KEYS_SRC}\n`
   keysSrc = `${keysSrc}\n${appendPrivateKey}`
 
-  await fsx.writeFileX(resolvedKeysFilepath, keysSrc) // TODO: don't write if armor
-
-  const envKeysFilepath = keysFilepath || path.join(path.dirname(envFilepath), path.basename(resolvedKeysFilepath))
-
   return {
-    keysSrc,
-    envKeysFilepath
+    keysSrc
   }
 }
 

package/src/lib/helpers/envResolution/index.js

@@ -3,6 +3,6 @@ module.exports = {
   determine: require('./determine'),
   findEnvFiles: require('./../findEnvFiles'),
   dotenvOptionPaths: require('./../dotenvOptionPaths'),
-  environment: require('./environment'),
+  environment: require('./../../conventions/environment'),
   conventions: require('./../conventions')
 }

package/src/lib/helpers/errors.js

@@ -18,6 +18,7 @@ const ISSUE_BY_CODE = {
   MISSING_KEY: 'https://github.com/dotenvx/dotenvx/issues/759',
   MISSING_LOG_LEVEL: 'must be valid log level',
   MISSING_PRIVATE_KEY: 'https://github.com/dotenvx/dotenvx/issues/464',
+  MISSING_PUBLIC_KEY: 'https://github.com/dotenvx/dotenvx/issues/new',
   PRECOMMIT_HOOK_MODIFY_FAILED: 'try again or report error',
   WRONG_PRIVATE_KEY: 'https://github.com/dotenvx/dotenvx/issues/466'
 }
@@ -265,6 +266,18 @@ class Errors {
     return e
   }
 
+  missingPublicKey () {
+    const code = 'MISSING_PUBLIC_KEY'
+    const message = `[${code}] missing public key`
+    const help = `fix: [${ISSUE_BY_CODE[code]}]`
+
+    const e = new Error(message)
+    e.code = code
+    e.help = help
+    e.messageWithHelp = `${message}. ${help}`
+    return e
+  }
+
   precommitHookModifyFailed () {
     const code = 'PRECOMMIT_HOOK_MODIFY_FAILED'
     const message = `[${code}] failed to modify pre-commit hook: ${this.error.message}`

package/src/lib/helpers/keypairMetadata.js

@@ -3,7 +3,7 @@ const fs = require('fs')
 const execa = require('execa')
 const { scan } = require('@dotenvx/primitives')
 const canonicalEnvFilename = require('./canonicalEnvFilename')
-const environment = require('./envResolution/environment')
+const environment = require('../conventions/environment')
 const sanitizeCommandForMetadata = require('./sanitizeCommandForMetadata')
 
 function compact (object) {

package/src/lib/main.d.ts

@@ -306,7 +306,7 @@ export function set(
   key: string,
   value: string,
   options?: SetOptions
-): SetOutput;
+): Promise<SetOutput>;
 
 export interface GetOptions {
   /**
@@ -367,7 +367,7 @@ export interface GetOptions {
 export function get(
   key: string,
   options?: GetOptions
-): string;
+): Promise<string>;
 
 /**
  * List all env files in the current working directory
@@ -381,40 +381,3 @@ export function ls(
   envFile: string | string[],
   excludeEnvFile: string | string[]
 ): string[];
-
-export type DoctorFinding = {
-  lang: string;
-  filepath: string;
-  line: number;
-  code: string;
-  msg: string;
-};
-
-/**
- * Scan code for dotenv loaders that can conflict with dotenvx.
- *
- * @param directory - directory to scan
- */
-export function doctor(
-  directory: string
-): DoctorFinding[];
-
-export type GenExampleOutput = {
-  envExampleFile: string;
-  envFile: string | string[];
-  exampleFilepath: string;
-  addedKeys: string[];
-  injected: Record<string, string>;
-  preExisted: Record<string, string>;
-};
-
-/**
- * Generate an example .env file
- *
- * @param directory - current working directory
- * @param envFile - path to the .env file(s)
- */
-export function genexample(
-  directory: string,
-  envFile: string
-): GenExampleOutput;

package/src/lib/main.js

@@ -1,25 +1,37 @@
 // @ts-check
 const path = require('path')
+const { encrypted, parseSync } = require('@dotenvx/primitives')
 
 // shared
 const { setLogLevel, setLogName, setLogVersion, logger } = require('./../shared/logger')
 const { getColor, bold } = require('./../shared/colors')
 
-// services
-const Ls = require('./services/ls')
-const Doctor = require('./services/doctor')
-const Run = require('./services/run')
-const Sets = require('./services/sets')
-const Get = require('./services/get')
-const Keypair = require('./services/keypair')
-const Genexample = require('./services/genexample')
+// resolvers
+const envsResolver = require('./resolvers/envs')
+const getResolver = require('./resolvers/get')
+const lsResolver = require('./resolvers/ls')
+
 const Session = require('./../db/session')
 
+// transforms
+const setTransform = require('./transforms/set')
+
 // helpers
 const buildEnvs = require('./helpers/buildEnvs')
 const { determine } = require('./helpers/envResolution')
-const Parse = require('./helpers/parse')
 const fsx = require('./helpers/fsx')
+const decryptKeyValue = require('./helpers/cryptography/decryptKeyValue')
+const Errors = require('./helpers/errors')
+
+function uniqueInjectedKeys (processedEnvs) {
+  const result = new Set()
+  for (const processedEnv of processedEnvs) {
+    for (const key of Object.keys(processedEnv.injected || {})) {
+      result.add(key)
+    }
+  }
+  return result
+}
 
 /** @type {import('./main').config} */
 const config = function (options = {}) {
@@ -57,12 +69,16 @@ const config = function (options = {}) {
     }
     const {
       processedEnvs,
-      readableFilepaths,
-      uniqueInjectedKeys
-    } = new Run(envs, overload, processEnv, envKeysFile, noArmor, {
+      readableFilepaths
+    } = envsResolver.sync({
+      envs,
+      overload,
+      processEnv,
+      envKeysFile,
+      noArmor,
       noSpinner: options.noSpinner,
       token: options.token
-    }).runSync()
+    })
 
     let lastError
     /** @type {Record<string, string>} */
@@ -92,7 +108,7 @@ const config = function (options = {}) {
       }
 
       Object.assign(parsedAll, processedEnv.injected || {})
-      Object.assign(parsedAll, processedEnv.preExisted || {}) // preExisted 'wins'
+      Object.assign(parsedAll, processedEnv.existed || {}) // existed 'wins'
 
       // debug parsed
       logger.debug(processedEnv.parsed)
@@ -103,14 +119,14 @@ const config = function (options = {}) {
         logger.debug(`${key} set to ${value}`)
       }
 
-      // verbose/debug preExisted key/value
-      for (const [key, value] of Object.entries(processedEnv.preExisted || {})) {
+      // verbose/debug existed key/value
+      for (const [key, value] of Object.entries(processedEnv.existed || {})) {
         logger.verbose(`${key} pre-exists (protip: use --overload to override)`)
         logger.debug(`${key} pre-exists as ${value} (protip: use --overload to override)`)
       }
     }
 
-    let msg = `injected env (${uniqueInjectedKeys.length})`
+    let msg = `injected env (${uniqueInjectedKeys(processedEnvs).size})`
     if (readableFilepaths.length > 0) {
       msg += ` from ${readableFilepaths.join(', ')}`
     }
@@ -147,7 +163,29 @@ const parse = function (src, options = {}) {
   // ignore
   const ignore = options.ignore || []
 
-  const { parsed, errors } = new Parse(src, privateKey, processEnv, overload).run()
+  if (privateKey) {
+    processEnv = Object.assign({}, processEnv, { DOTENV_PRIVATE_KEY: privateKey })
+  }
+
+  const { parsed } = parseSync(src, { processEnv, overload })
+  const errors = []
+
+  for (const key of Object.keys(parsed)) {
+    if (!encrypted(parsed[key])) {
+      continue
+    }
+
+    if (!privateKey) {
+      errors.push(new Errors({ key, privateKeyName: 'DOTENV_PRIVATE_KEY', privateKey }).missingPrivateKey())
+      continue
+    }
+
+    try {
+      parsed[key] = decryptKeyValue(key, parsed[key], 'DOTENV_PRIVATE_KEY', privateKey)
+    } catch (error) {
+      errors.push(error)
+    }
+  }
 
   // display any errors
   for (const error of errors) {
@@ -163,7 +201,7 @@ const parse = function (src, options = {}) {
 }
 
 /* @type {import('./main').set} */
-const set = function (key, value, options = {}) {
+const set = async function (key, value, options = {}) {
   // encrypt
   let encrypt = true
   if (options.plain) {
@@ -180,13 +218,27 @@ const set = function (key, value, options = {}) {
 
   const envs = buildEnvs(options)
   const envKeysFilepath = options.envKeysFile
+  const noCreate = options.create === false
   const noArmor = resolveNoArmor(options)
 
   const {
+    keysSrc,
     processedEnvs,
     changedFilepaths,
     unchangedFilepaths
-  } = new Sets(key, value, envs, encrypt, envKeysFilepath, noArmor).runSync()
+  } = await setTransform({
+    envs,
+    key,
+    value,
+    fk: envKeysFilepath,
+    noArmor,
+    noCreate,
+    encrypt
+  })
+
+  if (keysSrc) {
+    fsx.writeFileXSync(envKeysFilepath || '.env.keys', keysSrc)
+  }
 
   let withEncryption = ''
 
@@ -242,14 +294,21 @@ const set = function (key, value, options = {}) {
 }
 
 /* @type {import('./main').get} */
-const get = function (key, options = {}) {
+const get = async function (key, options = {}) {
   const envs = buildEnvs(options)
   const noArmor = resolveNoArmor(options)
 
   // ignore
   const ignore = options.ignore || []
 
-  const { parsed, errors } = new Get(key, envs, options.overload, options.all, options.envKeysFile, noArmor).runSync()
+  const { parsed, errors } = await getResolver({
+    key,
+    envs,
+    overload: options.overload,
+    all: options.all,
+    envKeysFile: options.envKeysFile,
+    noArmor
+  })
 
   for (const error of errors || []) {
     if (ignore.includes(error.code)) {
@@ -301,26 +360,7 @@ const get = function (key, options = {}) {
 
 /** @type {import('./main').ls} */
 const ls = function (directory, envFile, excludeEnvFile) {
-  return new Ls(directory, envFile, excludeEnvFile).run()
-}
-
-const doctor = function (directory) {
-  return new Doctor(directory).run()
-}
-
-/** @type {import('./main').genexample} */
-const genexample = function (directory, envFile) {
-  return new Genexample(directory, envFile).run()
-}
-
-/** @type {import('./main').keypair} */
-const keypair = function (envFile, key, envKeysFile = null, noArmor = false) {
-  const keypairs = new Keypair(envFile, envKeysFile, noArmor).runSync()
-  if (key) {
-    return keypairs[key]
-  } else {
-    return keypairs
-  }
+  return lsResolver({ directory, envFile, excludeEnvFile })
 }
 
 function resolveNoArmor (options = {}) {
@@ -336,9 +376,6 @@ module.exports = {
   set,
   get,
   ls,
-  doctor,
-  keypair,
-  genexample,
   // expose for libs depending on @dotenvx/dotenvx - like dotenvx-ops
   setLogLevel,
   logger,

package/src/lib/providers/armor/index.js

@@ -0,0 +1,29 @@
+const Session = require('../../../db/session')
+const ArmorKeyring = require('../../services/armorKeyring')
+const armoredKeyDisplay = require('../../helpers/armoredKeyDisplay')
+
+async function index (publicKeyHex, options = {}) {
+  const sesh = new Session()
+
+  const hostname = sesh.hostname()
+  const token = sesh.token()
+  const devicePublicKey = sesh.devicePublicKey()
+
+  const keyring = new ArmorKeyring(
+    hostname,
+    token,
+    devicePublicKey,
+    publicKeyHex
+  )
+  if (options.onStatus) {
+    keyring.onApprovalRequired = ({ approvalUri, code }) => {
+      const keyDisplay = armoredKeyDisplay(publicKeyHex)
+      const keySuffix = keyDisplay ? ` (${keyDisplay})` : ''
+      options.onStatus(`[${code}] visit [${approvalUri}] and approve${keySuffix}`)
+    }
+  }
+
+  return await keyring.run() // { "publicKey": "privateKey" }
+}
+
+module.exports = index

package/src/lib/providers/index.js

@@ -0,0 +1,46 @@
+const Session = require('./../../db/session')
+
+const armorProvider = require('./armor/index')
+function syncArmorProvider (publicKeyHex) {
+  const { createSyncFn } = require('synckit')
+  const runProviderSync = createSyncFn(require.resolve('./worker.js'))
+  return runProviderSync(require.resolve('./armor/index'), publicKeyHex)
+}
+
+async function providers (options = {}) {
+  if (Object.prototype.hasOwnProperty.call(options, 'provider')) {
+    return options.provider
+  }
+
+  if (options.noArmor || options.armor === false) {
+    return null
+  }
+
+  const sesh = new Session()
+  const noArmor = !options.token && await sesh.noArmor()
+  if (noArmor) return null
+
+  return (publicKeyHex) => armorProvider(publicKeyHex, {
+    onStatus: options.onStatus,
+    token: options.token,
+    command: options.command
+  })
+}
+
+providers.sync = function providersSync (options = {}) {
+  if (Object.prototype.hasOwnProperty.call(options, 'provider')) {
+    return options.provider
+  }
+
+  if (options.noArmor || options.armor === false) {
+    return null
+  }
+
+  const sesh = new Session()
+  const noArmor = !options.token && sesh.noArmorSync()
+  if (noArmor) return null
+
+  return syncArmorProvider
+}
+
+module.exports = providers

package/src/lib/providers/worker.js

@@ -0,0 +1,6 @@
+const { runAsWorker } = require('synckit')
+
+runAsWorker(async (providerPath, publicKeyHex) => {
+  const provider = require(providerPath)
+  return provider(publicKeyHex)
+})