configorama 0.9.12 → 0.9.14

package/cli.js

@@ -7,14 +7,16 @@ const deepLog = require('./src/utils/ui/deep-log')
 const { logHeader } = require('./src/utils/ui/logs')
 const configorama = require('./src')
 const { makeBox } = require('@davidwells/box-logger')
+const getValueAtPath = require('./src/utils/parsing/getValueAtPath')
 
 // Parse command line arguments
 const argv = minimist(process.argv.slice(2), {
   string: ['output', 'o', 'format', 'f', 'param'],
-  boolean: ['help', 'h', 'version', 'v', 'debug', 'allow-unknown', 'allow-undefined', 'list', 'info', 'verify'],
+  boolean: ['help', 'h', 'version', 'v', 'V', 'debug', 'allow-unknown', 'allow-undefined', 'list', 'info', 'verify'],
   alias: {
     h: 'help',
-    v: 'verify',
+    v: 'version',
+    V: 'verify',
     o: 'output',
     f: 'format',
     l: 'list',
@@ -31,7 +33,7 @@ if (argv.help) {
 Configorama - Variable resolution for configuration files
 
 Usage:
-  configorama [options] <file>
+  configorama [options] <file> [path]
 
 Options:
   -h, --help                Show this help message
@@ -40,13 +42,27 @@ Options:
   -f, --format <format>     Output format: json, yaml, or js (default: json)
   -d, --debug               Enable debug mode
   -i, --info                Show info about the config
-  -v, --verify              Verify the config
+  -V, --verify              Verify the config
   --param <key=value>       Pass parameter values (can be used multiple times)
   --allow-unknown           Allow unknown variables to pass through
   --allow-undefined         Allow undefined values in the final output
 
+Path Extraction:
+  Use jq-style paths to extract specific values from the resolved config.
+  Paths can appear before or after options.
+
+  Supported syntax:
+    .foo              Object key access
+    .foo.bar          Nested key access
+    .[0]              Array index (0-based)
+    .[-1]             Negative index (from end)
+    .foo[0].bar       Mixed access
+    .["key-name"]     Bracket notation for special keys
+
 Examples:
   configorama config.yml
+  configorama config.yml .database.host
+  configorama '.servers[0].port' config.yml
   configorama --info config.yml
   configorama --format yaml config.json
   configorama --output resolved.json config.yml
@@ -63,8 +79,22 @@ if (argv.version) {
   process.exit(0)
 }
 
-// Check for input file
-const inputFile = argv._[0]
+// Parse positional args: find file path and jq-style extraction path
+// File is first arg that exists as a file, jq path starts with '.' or '['
+let inputFile = null
+let extractPath = null
+
+for (const arg of argv._) {
+  if (arg === 'setup') continue
+
+  // jq-style paths start with '.' or '['
+  if (arg.startsWith('.') || arg.startsWith('[')) {
+    extractPath = arg
+  } else if (!inputFile) {
+    inputFile = arg
+  }
+}
+
 if (!inputFile) {
   console.error('Error: No input file specified')
   console.error('Run with --help for usage information')
@@ -135,6 +165,15 @@ options.options = rest
 // Process the configuration
 configorama(inputFile, options)
   .then((config) => {
+    // Apply path extraction if specified
+    if (extractPath) {
+      config = getValueAtPath(config, extractPath)
+      if (config === undefined) {
+        console.error(`Error: Path not found: ${extractPath}`)
+        process.exit(1)
+      }
+    }
+
     let output
 
     // Format the output
@@ -186,10 +225,9 @@ configorama(inputFile, options)
       content: error.message,
       type: 'error',
     })
-    console.log('error', error)
-    console.log(errorMsg)
+    console.error(errorMsg)
     if (argv.debug) {
-      console.error(error.stack)
+      console.error('error', error)
     }
     process.exit(1)
   })

package/index.d.ts

@@ -124,6 +124,7 @@ declare namespace configorama {
     toml: any
     ini: any
     hcl: any
+    markdown: any
   }
 
   /** The Configorama class for advanced usage */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "configorama",
-  "version": "0.9.12",
+  "version": "0.9.14",
   "description": "Variable support for configuration files",
   "main": "src/index.js",
   "types": "index.d.ts",
@@ -59,26 +59,10 @@
     "jiti": "^2.4.2",
     "js-yaml": "^3.14.1",
     "json5": "^2.2.3",
-    "lodash.assign": "^4.2.0",
     "lodash.camelcase": "^4.3.0",
-    "lodash.capitalize": "^4.2.1",
     "lodash.clonedeep": "^4.5.0",
-    "lodash.flatten": "^4.4.0",
-    "lodash.includes": "^4.3.0",
-    "lodash.isarray": "^4.0.0",
-    "lodash.isdate": "^4.0.1",
-    "lodash.isempty": "^4.4.0",
-    "lodash.isfunction": "^3.0.9",
-    "lodash.isnumber": "^3.0.3",
-    "lodash.isobject": "^3.0.2",
-    "lodash.isregexp": "^4.0.1",
-    "lodash.isstring": "^4.0.1",
     "lodash.kebabcase": "^4.1.1",
-    "lodash.map": "^4.6.0",
-    "lodash.mapvalues": "^4.6.0",
-    "lodash.split": "^4.4.2",
     "minimist": "^1.2.8",
-    "promise.prototype.finally": "^3.1.8",
     "safe-chalk": "^1.0.4",
     "subscript": "^9.1.0",
     "sync-rpc": "^1.3.6",

package/src/main.js

@@ -7,7 +7,6 @@ console.log = () => {}
 // process.exit(1)
 /** */
 /* External dependencies */
-const promiseFinallyShim = require('promise.prototype.finally').shim()
 const findUp = require('find-up')
 const traverse = require('traverse')
 const dotProp = require('dot-prop')
@@ -34,7 +33,7 @@ const { arrayToJsonPath } = require('./utils/parsing/arrayToJsonPath')
 const { normalizePath, extractFilePath, resolveInnerVariables } = require('./utils/paths/filePathUtils')
 const { findLineForKey } = require('./utils/paths/findLineForKey')
 /* Utils - regex */
-const { combineRegexes, funcRegex } = require('./utils/regex')
+const { combineRegexes, funcRegex, fileRefSyntax, textRefSyntax } = require('./utils/regex')
 /* Utils - strings */
 const formatFunctionArgs = require('./utils/strings/formatFunctionArgs')
 const { splitByComma } = require('./utils/strings/splitByComma')
@@ -92,20 +91,18 @@ const deepRefSyntax = RegExp(/(\${)?deep:\d+(\.[^}]+)*()}?/)
 const deepIndexReplacePattern = new RegExp(/^deep:|(\.[^}]+)*$/g)
 const deepIndexPattern = /deep\:(\d*)/
 const deepPrefixReplacePattern = /(?:^deep:)\d+\.?/g
-const fileRefSyntax = RegExp(/^file\((~?[@\{\}\:\$a-zA-Z0-9._\-\/,'" =+]+?)\)/g)
-const textRefSyntax = RegExp(/^text\((~?[@\{\}\:\$a-zA-Z0-9._\-\/,'" =+]+?)\)/g)
 // TODO update file regex ^file\((~?[a-zA-Z0-9._\-\/, ]+?)\)
 // To match file(asyncValue.js, lol) input params
 const selfRefSyntax = RegExp(/^self:/g)
-const base64WrapperRegex = /\[_\[([A-Za-z0-9+/=\s]*)\]_\]/g
 const logLines = '─────────────────────────────────────────────────'
+const evalIfPattern = /\b(eval|if)\s*\(/
+const functionPrefixPattern = /^> function /
 
 let DEBUG = process.argv.includes('--debug') ? true : false
 let VERBOSE = process.argv.includes('--verbose') ? true : false
 let SETUP_MODE = process.argv.includes('--setup') ? true : false
 // DEBUG = true
 let DEBUG_TYPE = false
-const ENABLE_FUNCTIONS = true
 
 class Configorama {
   constructor(fileOrObject, opts) {
@@ -565,7 +562,6 @@ class Configorama {
         }
         return assign({}, value, otherValue)
       },
-      math: () => {},
       upperKeys: (o) => {
         return Object.keys(o).reduce((c, k) => ((c[k.toUpperCase()] = o[k]), c), {}) // eslint-disable-line
       },
@@ -684,6 +680,17 @@ class Configorama {
       /** */
       //process.exit(1)
 
+      // Strip body content before variable resolution, re-attach after
+      if (configObject && configObject._body !== undefined) {
+        this._markdownContent = configObject._body
+        this._markdownContentKey = '_body'
+        delete configObject._body
+      } else if (configObject && configObject._content !== undefined) {
+        this._markdownContent = configObject._content
+        this._markdownContentKey = '_content'
+        delete configObject._content
+      }
+
       this.config = configObject
       this.originalConfig = cloneDeep(configObject)
     }
@@ -715,12 +722,8 @@ class Configorama {
       )
 
       if (showFoundVariables) {
-        //*
         deepLog('metadata', metadata)
-        fs.writeFileSync(`metadata-${path.basename(this.configFilePath)}.json`, JSON.stringify(metadata, null, 2))
         deepLog('enrich', enrich)
-        // process.exit(1)
-        /** */
       }
 
       const variableData = metadata.variables
@@ -1231,8 +1234,7 @@ class Configorama {
     
       /* Exit early if list or info flag is set */
       if (showFoundVariables) {
-        // TODO re-enable this
-        // process.exit(0)
+        return Promise.resolve(this.config)
       }
     }
 
@@ -1240,6 +1242,9 @@ class Configorama {
 
     /* If no variables found just return early */
     if (this.originalString && !this.originalString.match(this.variableSyntax)) {
+      if (this._markdownContent !== undefined) {
+        this.originalConfig[this._markdownContentKey] = this._markdownContent
+      }
       return Promise.resolve(this.originalConfig)
     }
 
@@ -1255,7 +1260,7 @@ class Configorama {
       }
       const stage = cliOpts.stage || providerStage || process.env.NODE_ENV || 'dev'
       /* Load env variables into process.env */
-      const values = require('env-stage-loader')({
+      require('env-stage-loader')({
         // silent: true,
         // debug: true,
         env: stage,
@@ -1304,7 +1309,7 @@ class Configorama {
               if (typeof rawValue === 'string') {
                 // console.log('rawValue', rawValue)
                 /* Process inline functions like merge() */
-                if (ENABLE_FUNCTIONS && rawValue.match(/> function /)) {
+                if (rawValue.match(functionPrefixPattern)) {
                   // console.log('RAW FUNCTION', rawFunction)
                   const funcString = rawValue.replace(/> function /g, '')
                   // console.log('funcString', funcString)
@@ -1399,6 +1404,10 @@ class Configorama {
             deepLog(this.config)
             console.log()
           }
+          // Re-attach markdown body content after variable resolution
+          if (this._markdownContent !== undefined) {
+            this.config[this._markdownContentKey] = this._markdownContent
+          }
           return this.config
         })
     })
@@ -2141,9 +2150,6 @@ class Configorama {
 
       historyEntry.match = matches[i].match
       historyEntry.variable = matches[i].variable
-      if (historyEntry.resultType === 'string' && historyEntry.result.match(/^>passthrough\[/)) {
-        historyEntry.variableType = 'encodedUnknown'
-      }
       if (resolverType) {
         historyEntry.variableType = resolverType
       }
@@ -2156,6 +2162,9 @@ class Configorama {
       }
 
       historyEntry.resultType = typeof finalResult
+      if (historyEntry.resultType === 'string' && typeof cleanResult === 'string' && cleanResult.match(/^>passthrough\[/)) {
+        historyEntry.variableType = 'encodedUnknown'
+      }
       historyEntry.valueBeforeResolution = valueBeforeResolution
       historyEntry.from = 'renderMatches'
       if (isDeepResult) {
@@ -2474,7 +2483,7 @@ class Configorama {
 
       // For eval/if expressions, string values need quotes unless already quoted
       // BUT don't quote strings that contain variable refs (they need further resolution)
-      if (/\b(eval|if)\s*\(/.test(property) && !valueToPopulate.match(this.variableSyntax)) {
+      if (evalIfPattern.test(property) && !valueToPopulate.match(this.variableSyntax)) {
         const matchIdx = property.indexOf(currentMatchedString)
         const charBefore = matchIdx > 0 ? property[matchIdx - 1] : ''
         // Always escape quotes in values for eval/if context
@@ -2502,7 +2511,7 @@ class Configorama {
       if (DEBUG_TYPE) console.log('DEBUG_TYPE isObject')
 
       // For eval/if expressions, encode objects to avoid {} breaking variable syntax
-      const isEvalOrIf = /\b(eval|if)\s*\(/.test(property)
+      const isEvalOrIf = evalIfPattern.test(property)
       if (isEvalOrIf) {
         const encoded = encodeValueForEval(valueToPopulate)
         property = replaceAll(matchedString, encoded, property)
@@ -2539,12 +2548,12 @@ class Configorama {
       // console.log('other new prop', property)
 
     // partial replacement, boolean inside eval/if expressions
-    } else if (typeof valueToPopulate === 'boolean' && /\b(eval|if)\s*\(/.test(property)) {
+    } else if (typeof valueToPopulate === 'boolean' && evalIfPattern.test(property)) {
       if (DEBUG_TYPE) console.log('DEBUG_TYPE isBoolean in eval/if')
       property = replaceAll(matchedString, String(valueToPopulate), property)
 
     // partial replacement, null inside eval/if expressions
-    } else if (valueToPopulate === null && /\b(eval|if)\s*\(/.test(property)) {
+    } else if (valueToPopulate === null && evalIfPattern.test(property)) {
       if (DEBUG_TYPE) console.log('DEBUG_TYPE isNull in eval/if')
       property = replaceAll(matchedString, '__NULL__', property)
 
@@ -2644,13 +2653,13 @@ Missing Value ${missingValue} - ${matchedString}
       }
       
       // console.log('prop', prop)
-      if (property.match(/^> function /g) && prop) {
+      if (property.match(functionPrefixPattern) && prop) {
         // console.log('func prop', property)
         // console.log('Prop', prop)
       }
       const func = funcRegex.exec(property)
       // console.log('func', func)
-      if (func && property.match(/^> function /g)) {
+      if (func && property.match(functionPrefixPattern)) {
         /* IMPORTANT fix `finalProp` for nested function reference
           nestedOne: 'hi'
           nestedTwo: ${merge('nice', 'wow')}
@@ -2693,12 +2702,15 @@ Missing Value ${missingValue} - ${matchedString}
         && !prop.match(getValueFromEval.match)
         && !prop.match(getValueFromIf.match)
         // AND is not multiline value
-        && (func && prop.split('\n').length < 3)) {
+        && (func && prop.split('\n').length < 3)
+        // Only tag as function if the function name is actually registered
+        // Prevents resolved values like git messages "fix(scope)" from being treated as functions
+        && (func[1] && (this.functions[func[1]] || this.functions[func[1].toLowerCase()]))) {
         // console.log('IS FUNCTION')
         /* if matches function signature like ${merge('foo', 'bar')}
           rewrite the variable to run the function after inputs resolved
         */
-        const rep = property.replace(/^> function /g, '')
+        const rep = property.replace(functionPrefixPattern, '')
         property = `> function ${rep}`
       }
       // if (prop.match(/\s\|/)) {
@@ -3610,7 +3622,7 @@ Missing Value ${missingValue} - ${matchedString}
       return variableString
     }
     // console.log('runFunction', variableString)
-    var hasFunc = funcRegex.exec(variableString)
+    const hasFunc = funcRegex.exec(variableString)
     // TODO finish Function handling. Need to move this down below resolver to resolve inner refs first
     // console.log('hasFunc', hasFunc)
     // Skip special expressions (cron, eval, if) - these aren't user functions

package/src/parsers/index.js

@@ -9,6 +9,7 @@ const toml = require('./toml')
 const yaml = require('./yaml')
 const ini = require('./ini')
 const hcl = require('./hcl')
+const markdown = require('./markdown')
 
 /**
  * Collection of format parsers for different config file types
@@ -19,5 +20,6 @@ module.exports = {
   toml: toml,
   yaml: yaml,
   ini: ini,
-  hcl: hcl
+  hcl: hcl,
+  markdown: markdown
 }

package/src/parsers/markdown.js

@@ -0,0 +1,69 @@
+// Extracts and detects frontmatter format from markdown/MDX files
+
+/**
+ * Detect frontmatter syntax format from raw content
+ * @param {string} rawFrontmatter - Raw frontmatter string (without delimiters)
+ * @returns {'yaml'|'toml'|'json'} Detected format
+ */
+function detectSyntax(rawFrontmatter) {
+  const trimmed = rawFrontmatter.trim()
+  if (trimmed.startsWith('{')) {
+    return 'json'
+  }
+  if (/^\[[\w.-]+\]/m.test(trimmed)) {
+    return 'toml'
+  }
+  return 'yaml'
+}
+
+/**
+ * Extract frontmatter and body content from a markdown file
+ * @param {string} fileContents - Full file contents
+ * @returns {{ frontmatterContent: string|null, content: string, format: 'yaml'|'toml'|'json'|null }}
+ */
+function extractFrontmatter(fileContents) {
+  const noMatch = { frontmatterContent: null, content: fileContents, format: null }
+
+  if (!fileContents) {
+    return noMatch
+  }
+
+  // Normalize CRLF to LF for consistent delimiter matching
+  fileContents = fileContents.replace(/\r\n/g, '\n')
+
+  // +++ delimiters → TOML
+  if (fileContents.startsWith('+++\n')) {
+    const endIdx = fileContents.indexOf('\n+++', 4)
+    if (endIdx === -1) return noMatch
+    const frontmatterContent = fileContents.slice(4, endIdx)
+    const content = fileContents.slice(endIdx + 4)
+    return { frontmatterContent, content, format: 'toml' }
+  }
+
+  // --- delimiters → detect format from content
+  if (fileContents.startsWith('---\n')) {
+    const endIdx = fileContents.indexOf('\n---', 4)
+    if (endIdx === -1) return noMatch
+    const frontmatterContent = fileContents.slice(4, endIdx)
+    const content = fileContents.slice(endIdx + 4)
+    const format = detectSyntax(frontmatterContent)
+    return { frontmatterContent, content, format }
+  }
+
+  // <!-- --> comment frontmatter (strict: position 0)
+  if (fileContents.startsWith('<!--\n')) {
+    const endIdx = fileContents.indexOf('\n-->', 5)
+    if (endIdx === -1) return noMatch
+    const frontmatterContent = fileContents.slice(5, endIdx)
+    const content = fileContents.slice(endIdx + 4)
+    const format = detectSyntax(frontmatterContent)
+    return { frontmatterContent, content, format }
+  }
+
+  return noMatch
+}
+
+module.exports = {
+  extractFrontmatter,
+  detectSyntax
+}

package/src/parsers/markdown.test.js

@@ -0,0 +1,132 @@
+/* eslint-disable no-template-curly-in-string */
+// Unit tests for markdown frontmatter extraction and format detection
+const { test } = require('uvu')
+const assert = require('uvu/assert')
+const { extractFrontmatter, detectSyntax } = require('./markdown')
+
+// --- detectSyntax tests ---
+
+test('detectSyntax: JSON detected by leading {', () => {
+  assert.is(detectSyntax('{ "title": "hello" }'), 'json')
+})
+
+test('detectSyntax: TOML detected by [section] header', () => {
+  assert.is(detectSyntax('title = "hello"\n[section]\nkey = "val"'), 'toml')
+})
+
+test('detectSyntax: TOML detected by [dotted.section] header', () => {
+  assert.is(detectSyntax('[my.config]\nkey = "val"'), 'toml')
+})
+
+test('detectSyntax: defaults to yaml', () => {
+  assert.is(detectSyntax('title: hello\ndescription: world'), 'yaml')
+})
+
+test('detectSyntax: yaml even with empty content', () => {
+  assert.is(detectSyntax(''), 'yaml')
+})
+
+// --- extractFrontmatter: YAML with --- delimiters ---
+
+test('extract YAML frontmatter with --- delimiters', () => {
+  const input = '---\ntitle: hello\nstage: ${opt:stage}\n---\n\n# My Doc\n\nBody content here.'
+  const result = extractFrontmatter(input)
+  assert.is(result.format, 'yaml')
+  assert.is(result.frontmatterContent, 'title: hello\nstage: ${opt:stage}')
+  assert.is(result.content, '\n\n# My Doc\n\nBody content here.')
+})
+
+// --- extractFrontmatter: TOML with +++ delimiters ---
+
+test('extract TOML frontmatter with +++ delimiters', () => {
+  const input = '+++\ntitle = "hello"\nstage = "${opt:stage}"\n+++\n\n# My Doc\n\nBody.'
+  const result = extractFrontmatter(input)
+  assert.is(result.format, 'toml')
+  assert.is(result.frontmatterContent, 'title = "hello"\nstage = "${opt:stage}"')
+  assert.is(result.content, '\n\n# My Doc\n\nBody.')
+})
+
+// --- extractFrontmatter: TOML detected inside --- delimiters ---
+
+test('extract TOML detected inside --- delimiters via [section]', () => {
+  const input = '---\n[metadata]\ntitle = "hello"\n---\n\nBody.'
+  const result = extractFrontmatter(input)
+  assert.is(result.format, 'toml')
+  assert.is(result.frontmatterContent, '[metadata]\ntitle = "hello"')
+  assert.is(result.content, '\n\nBody.')
+})
+
+// --- extractFrontmatter: JSON detected inside --- delimiters ---
+
+test('extract JSON detected inside --- delimiters via leading {', () => {
+  const input = '---\n{\n  "title": "hello"\n}\n---\n\nBody.'
+  const result = extractFrontmatter(input)
+  assert.is(result.format, 'json')
+  assert.is(result.frontmatterContent, '{\n  "title": "hello"\n}')
+  assert.is(result.content, '\n\nBody.')
+})
+
+// --- extractFrontmatter: HTML comment frontmatter ---
+
+test('extract hidden comment frontmatter <!-- -->', () => {
+  const input = '<!--\ntitle: hello\nstage: dev\n-->\n\n# Doc\n\nBody.'
+  const result = extractFrontmatter(input)
+  assert.is(result.format, 'yaml')
+  assert.is(result.frontmatterContent, 'title: hello\nstage: dev')
+  assert.is(result.content, '\n\n# Doc\n\nBody.')
+})
+
+test('comment frontmatter not detected when not at position 0', () => {
+  const input = '\n<!--\ntitle: hello\n-->\n\nBody.'
+  const result = extractFrontmatter(input)
+  assert.is(result.frontmatterContent, null)
+  assert.is(result.format, null)
+  assert.is(result.content, '\n<!--\ntitle: hello\n-->\n\nBody.')
+})
+
+// --- extractFrontmatter: no frontmatter ---
+
+test('no frontmatter returns null + full content', () => {
+  const input = '# Just a markdown file\n\nNo frontmatter here.'
+  const result = extractFrontmatter(input)
+  assert.is(result.frontmatterContent, null)
+  assert.is(result.format, null)
+  assert.is(result.content, '# Just a markdown file\n\nNo frontmatter here.')
+})
+
+// --- Multiple --- in body don't confuse extraction ---
+
+test('thematic breaks in body do not confuse extraction', () => {
+  const input = '---\ntitle: hello\n---\n\nSome text\n\n---\n\nMore text after thematic break.'
+  const result = extractFrontmatter(input)
+  assert.is(result.format, 'yaml')
+  assert.is(result.frontmatterContent, 'title: hello')
+  assert.is(result.content, '\n\nSome text\n\n---\n\nMore text after thematic break.')
+})
+
+// --- Edge cases ---
+
+test('empty file returns no frontmatter', () => {
+  const result = extractFrontmatter('')
+  assert.is(result.frontmatterContent, null)
+  assert.is(result.format, null)
+  assert.is(result.content, '')
+})
+
+test('--- only at start with no closing returns no frontmatter', () => {
+  const input = '---\ntitle: hello\nno closing delimiter'
+  const result = extractFrontmatter(input)
+  assert.is(result.frontmatterContent, null)
+  assert.is(result.format, null)
+  assert.is(result.content, '---\ntitle: hello\nno closing delimiter')
+})
+
+test('+++ only at start with no closing returns no frontmatter', () => {
+  const input = '+++\ntitle = "hello"\nno closing delimiter'
+  const result = extractFrontmatter(input)
+  assert.is(result.frontmatterContent, null)
+  assert.is(result.format, null)
+  assert.is(result.content, '+++\ntitle = "hello"\nno closing delimiter')
+})
+
+test.run()

package/src/resolvers/valueFromEnv.js

@@ -1,3 +1,5 @@
+// Resolves values from process.env environment variables
+// Matches ${env:VAR_NAME} syntax with optional fallback values
 
 const envRefSyntax = RegExp(/^env:/g)
 
@@ -13,12 +15,7 @@ Example: \${env:MY_ENV_VAR}
 `)
   }
 
-  let valueToPopulate
-  if (requestedEnvVar !== '' || '' in process.env) {
-    valueToPopulate = process.env[requestedEnvVar]
-  } else {
-    valueToPopulate = process.env
-  }
+  const valueToPopulate = process.env[requestedEnvVar]
   return Promise.resolve(valueToPopulate)
 }
 

package/src/resolvers/valueFromFile.js

@@ -121,9 +121,9 @@ async function getValueFromFile(ctx, variableString, options) {
 
   // Get function input params if any supplied https://regex101.com/r/qlNFVm/1
   // var funcParamsRegex = /(\w+)\s*\(((?:[^()]+)*)?\s*\)\s*/g
-  var funcParamsRegex = /(\w+)\s*\(((?:[^()]+)*)?\s*\)/g
+  const funcParamsRegex = /(\w+)\s*\(((?:[^()]+)*)?\s*\)/g
   // tighter (?<![.\w-])\b(\w+)\s*\(((?:[^()]+)*)?\s*\)\s*
-  var hasParams = funcParamsRegex.exec(matchedFileString)
+  const hasParams = funcParamsRegex.exec(matchedFileString)
 
   let argsToPass = []
   if (hasParams) {
@@ -257,8 +257,8 @@ ${JSON.stringify(options.context, null, 2)}`,
   const variableFileContents = fs.readFileSync(fullFilePath, 'utf-8')
 
   /* handle case for referencing raw JS files to inline them */
-  if (argsToPass.length
-    && (argsToPass && argsToPass[0] && typeof argsToPass[0] === 'string' && argsToPass[0].toLowerCase() === 'raw')
+  if ((argsToPass.length
+    && argsToPass[0] && typeof argsToPass[0] === 'string' && argsToPass[0].toLowerCase() === 'raw')
     || opts.asRawText
   ) {
     // Encode foo() to foo__PH_PAREN_OPEN__) to avoid function collisions