configorama 0.5.3 → 0.5.5

package/cli.js

@@ -3,17 +3,17 @@
 const fs = require('fs')
 const minimist = require('minimist')
 const Configorama = require('./src/main')
+const deepLog = require('./src/utils/deep-log')
 
 // Parse command line arguments
 const argv = minimist(process.argv.slice(2), {
   string: ['output', 'o', 'format', 'f'],
-  boolean: ['help', 'h', 'version', 'v', 'debug', 'd', 'allow-unknown', 'allow-undefined'],
+  boolean: ['help', 'h', 'version', 'v', 'debug', 'allow-unknown', 'allow-undefined'],
   alias: {
     h: 'help',
     v: 'version',
     o: 'output',
     f: 'format',
-    d: 'debug'
   },
   default: {
     format: 'json'
@@ -74,6 +74,34 @@ const options = {
   dynamicArgs: argv
 }
 
+if (options.dynamicArgs.verbose) {
+  console.log('───────────── Input Options ──────────────────────')
+  const dynamicArgs = options.dynamicArgs || {}
+  const { 
+    _, 
+    verbose, 
+    v, 
+    debug, 
+    d, 
+    help, 
+    h, 
+    version,
+    f,
+    format,
+    'allow-unknown': allowUnknown, 
+    'allow-undefined': allowUndefined, 
+    ...rest 
+  } = dynamicArgs
+
+  console.log()
+  if (Object.keys(rest).length) {
+    deepLog(rest)
+  } else {
+    console.log('No flag options provided. Set flags like --flag value')
+  }
+  console.log()
+}
+
 // Create Configorama instance
 const configorama = new Configorama(inputFile, options)
 // console.log('configorama', configorama)
@@ -104,7 +132,9 @@ configorama.init(argv)
       fs.writeFileSync(argv.output, output)
       console.log(`Configuration written to ${argv.output}`)
     } else {
-      console.log(output)
+      if (!argv.verbose) {
+        console.log(output)
+      }
     }
   })
   .catch((error) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "configorama",
-  "version": "0.5.3",
+  "version": "0.5.5",
   "description": "Variable support for configuration files",
   "main": "lib/index.js",
   "files": [
@@ -16,9 +16,10 @@
   },
   "scripts": {
     "docs": "node ./scripts/docs.js",
-    "test": "npm run testlib && uvu tests \".*\\.test.js$\" ",
+    "test": "npm run test:lib && uvu tests \".*\\.test.js$\" ",
+    "test:tests": "uvu tests \".*\\.test.js$\" ",
     "test:api": "uvu tests/api api.test.js",
-    "testlib": "uvu src \".*\\.test.js$\"",
+    "test:lib": "uvu src \".*\\.test.js$\"",
     "watch": "watchlist tests -- npm test",
     "publish": "git push origin && git push origin --tags",
     "release:patch": "npm version patch && npm publish",

package/src/main.js

@@ -66,7 +66,7 @@ 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 fileRefSyntax = RegExp(/^file\((~?[\{\}\:\$a-zA-Z0-9._\-\/,'" ]+?)\)/g)
 // TODO update file regex ^file\((~?[a-zA-Z0-9._\-\/, ]+?)\)
 // To match file(asyncValue.js, lol) input params
 const envRefSyntax = RegExp(/^env:/g)
@@ -79,10 +79,21 @@ const base64WrapperRegex = /\[_\[([A-Za-z0-9+/=\s]*)\]_\]/g
 const logLines = '─────────────────────────────────────────────────'
 
 let DEBUG = process.argv.includes('--debug') ? true : false
+let VERBOSE = process.argv.includes('--verbose') ? true : false
 // DEBUG = true
 
 const ENABLE_FUNCTIONS = true
 
+function combineRegexes(regexes) {
+  // Extract the pattern from each RegExp and join with OR operator
+  const patterns = regexes.map(regex => {
+    // Get source pattern string without flags
+    return regex.source
+  }).filter(Boolean)
+  // Join patterns with the OR operator and create new RegExp
+  return new RegExp(`(${patterns.join('|')})`)
+}
+
 class Configorama {
   constructor(fileOrObject, opts) {
     /* attach sig events on async calls */
@@ -100,18 +111,21 @@ class Configorama {
 
     this.filterCache = {}
 
+    this.foundVariables = []
+
     const defaultSyntax = '\\${((?!AWS|stageVariables)[ ~:a-zA-Z0-9=+!@#%*<>?._\'",|\\-\\/\\(\\)\\\\]+?)}'
   
-    const variableSyntax = options.syntax || defaultSyntax
+    const varSyntax = options.syntax || defaultSyntax
     let varRegex
-    if (typeof variableSyntax === 'string') {
-      varRegex = new RegExp(variableSyntax, 'g')
+    if (typeof varSyntax === 'string') {
+      varRegex = new RegExp(varSyntax, 'g')
       // this.variableSyntax = /\${((?!AWS)([ ~:a-zA-Z0-9=+!@#%*<>?._'",|\-\/\(\)\\]+?|(\w+)\s*\(((?:[^()]+)*)?\s*\)\s*))}/
-    } else if (variableSyntax instanceof RegExp) {
-      varRegex = variableSyntax
+    } else if (varSyntax instanceof RegExp) {
+      varRegex = varSyntax
     }
     // console.log('varRegex', varRegex)
-    this.variableSyntax = varRegex
+    const variableSyntax = varRegex
+    this.variableSyntax = variableSyntax
 
     // Set initial config object to populate
     if (typeof fileOrObject === 'object') {
@@ -266,7 +280,13 @@ class Configorama {
     /* attach self matcher last */
     this.variableTypes = this.variableTypes.concat(fallThroughSelfMatcher)
 
-    this.variablesKnownTypes = new RegExp(`^(${this.variableTypes.map((v) => v.prefix || v.type).join('|')}):`)
+    // const variablesKnownTypes = new RegExp(`^(${this.variableTypes.map((v) => v.prefix || v.type).join('|')}):`)
+    const variablesKnownTypes = combineRegexes(this.variableTypes.filter((v) => v.type !== 'string').map((v) => v.match))
+    // console.log('variablesKnownTypes', variablesKnownTypes)
+    this.variablesKnownTypes = variablesKnownTypes
+
+    // this.allPatterns = combineRegexes(...this.variableTypes.map((v) => v.match))
+    // console.log('this.allPatterns', this.allPatterns)
     // console.log('this.variablesKnownTypes', this.variablesKnownTypes)
     // process.exit(1)
     // Additional filters on values. ${thing | filterFunction}
@@ -383,6 +403,63 @@ class Configorama {
       this.functions = Object.assign({}, this.functions, options.functions)
     }
 
+    if (VERBOSE) {
+      console.log('───────────── Input Config ──────────────────────')
+      console.log()
+      deepLog(this.originalConfig)
+      console.log()
+
+      const foundVariables = []
+      let loggedHeader = false
+      traverse(this.originalConfig).forEach(function (rawValue) {
+        if (typeof rawValue === 'string' && rawValue.match(variableSyntax)) {
+          if (!loggedHeader) {
+            console.log('───────────── Variables Detected ──────────────────────')
+            console.log()
+            loggedHeader = true
+          }
+          const configValuePath = this.path.join('.')
+          const nested = findNestedVariables(rawValue, variableSyntax, variablesKnownTypes, configValuePath)
+          /*
+          console.log(nested)
+          /** */
+          
+          console.log(`▷ Path: ${configValuePath}`)
+          console.log('\n  Key/value:')
+          console.log(`  ${configValuePath}: ${rawValue}`)
+          if (nested.length > 0) {
+            const nestedCount = nested.length - 1
+            console.log('\n  Variable:')
+            console.log(`  ${nested[nested.length - 1].fullMatch}`)
+            
+            if (nestedCount) {
+              console.log(`\n  Contains ${nestedCount} nested values.`)
+            }
+  
+            // non mutate remove last
+            const removeLast = (nested.length > 1) ? nested.slice(0, -1) : nested
+            console.log()
+            removeLast.forEach((v) => {
+              if (v.hasFallback) {
+                console.log('  Resolve order:')
+                console.log(`    1. ${v.valueBeforeFallback}`)
+                v.fallbackValues.forEach((f, i) => {
+                  console.log(`    ${i + 2}. ${f.fullMatch}${f.isFallback ? ' (Fallback string value)' : ''}`)
+                })
+              }
+            })
+          }
+          console.log()
+          foundVariables.push(rawValue)
+        }
+      })
+
+      console.log(`───────────── Found ${foundVariables.length} Variables ──────────────────────`)
+      console.log()
+      deepLog(foundVariables)
+      console.log()
+    }
+
     this.deep = []
     this.callCount = 0
   }
@@ -478,6 +555,12 @@ class Configorama {
           if (this.mergeKeys && this.config) {
             this.config = mergeByKeys(this.config, '', this.mergeKeys)
           }
+          if (VERBOSE) {
+            console.log('───────────── Resolved Config ───────────────────')
+            console.log()
+            deepLog(this.config)
+            console.log()
+          }
           return this.config
         })
     })
@@ -625,7 +708,7 @@ class Configorama {
       // Initial check if value has variable string in it
       return isString(property.value) && property.value.match(this.variableSyntax)
     })
-    // console.log('variables', variables)
+
     return map(variables, (valueObject) => {
       // console.log('valueObject', valueObject)
       return this.populateValue(valueObject, false, '_populateVariables').then((populated) => {

package/src/resolvers/valueFromString.js

@@ -7,6 +7,7 @@ function getValueFromString(variableString) {
 }
 
 module.exports = {
+  type: 'string',
   match: stringRefSyntax,
   resolver: getValueFromString
 }

package/src/utils/find-nested-variables.js

@@ -1,63 +1,7 @@
-/**
- * Processes nested variable interpolations in a string and collects all matches
- * @param {string} input - The input string containing variable interpolations
- * @param {boolean} debug - Whether to print debug information
- * @returns {Array} Array of match objects containing full match and captured group
- */
-function findNestedVariablesx(input, regex, debug = false) {
-  let str = input
-  let matches = []
-  let match
-  let iteration = 0
-
-  console.log('input', input)
-  
-  if (debug) console.log(`Initial string: ${str}`)
-
-  // Process string until no more matches are found
-  while (true) {
-    iteration++
-    if (debug) console.log(`\nIteration ${iteration}:`)
-    
-    // Reset regex index
-    regex.lastIndex = 0
-    
-    // Find the next match
-    match = regex.exec(str)
-    if (!match) break
-    
-    // Log match details if in debug mode
-    if (debug) {
-      console.log(`Match: ${match[0]}`)
-      console.log(`Captured group: ${match[1]}`)
-    }
-    
-    // Store the match
-    matches.push({
-      fullMatch: match[0],
-      variable: match[1],
-      order: iteration
-    })
-    
-    // Replace the match with placeholder
-    str = str.replace(regex, `__REPLACED_${iteration - 1}__`)
-    if (debug) console.log(`After replacement: ${str}`)
-  }
-
-  // Replace the `__REPLACED_${iteration - 1}__` with the original match
-  matches = matches.map((match, index) => {
-    const indexOfReplaced = match.fullMatch.match(/__REPLACED_(\d+)__/)
-    if (indexOfReplaced) {
-      const replacedIndex = parseInt(indexOfReplaced[1])
-      match.fullMatch = match.fullMatch.replace(`__REPLACED_${replacedIndex}__`, matches[replacedIndex].variable)
-      match.variable = match.variable.replace(`__REPLACED_${replacedIndex}__`, matches[replacedIndex].variable)
-    }
-    return match
-  })
-
-  if (debug) console.log(`\nTotal matches found: ${matches.length}`)
-  return matches
-}
+const { splitByComma } = require('./splitByComma')
+const trimQuotes = require('./trimSurroundingQuotes')
+const FALLBACK_REGEX = /,\s*/
+const VAR_MATCH_REGEX = /__VAR_\d+__/
 
 /**
  * Finds all nested variable interpolations in a string while preserving original syntax
@@ -77,10 +21,10 @@ function findNestedVariablesx(input, regex, debug = false) {
  * @param {boolean} debug - Whether to print debug information
  * @returns {Array} Array of match objects with fullMatch, variable, varString and other properties
  */
-function findNestedVariables(input, regex, debug = false) {
+function findNestedVariables(input, regex, variablesKnownTypes, location, debug = false) {
   // Create a copy of the input for replacement tracking
-  let workingString = input
-  // console.log('workingString', workingString)
+  let current = input
+  // console.log('current', current)
   // Store matches with their positions in the original string
   let matches = []
   // Track original positions and replacements
@@ -99,7 +43,7 @@ function findNestedVariables(input, regex, debug = false) {
     regex.lastIndex = 0
     
     // Find the next match in the working string
-    match = regex.exec(workingString)
+    match = regex.exec(current)
     if (!match) break
     
     // Generate a unique placeholder
@@ -107,12 +51,15 @@ function findNestedVariables(input, regex, debug = false) {
     
     // Store match details
     const matchInfo = {
+      location,
+      value: input,
       fullMatch: match[0],
-      variable: match[1],
-      order: iteration,
+      variable: match[1].trim(),
+      varString: match[1],
+      resolveOrder: iteration,
       start: match.index,
       end: match.index + match[0].length,
-      placeholder
+      placeholder,
     }
     
     if (debug) {
@@ -132,29 +79,49 @@ function findNestedVariables(input, regex, debug = false) {
     })
     
     // Replace in working string (to find next match)
-    workingString = workingString.substring(0, match.index) + 
-                   placeholder + 
-                   workingString.substring(match.index + match[0].length)
+    current = current.substring(0, match.index) + placeholder + current.substring(match.index + match[0].length)
     
-    if (debug) console.log(`After replacement: ${workingString}`)
+    if (debug) console.log(`After replacement: ${current}`)
   }
   
   if (debug) console.log(`\nTotal matches found: ${matches.length}`)
   
   // We need to store varString - the variable string with placeholders
   for (let i = 0; i < matches.length; i++) {
-    // First match, the variable is the same as varString
-    if (i === 0) {
-      matches[i].varString = matches[i].variable
-    } else {
-      // For other matches, we need to copy the original variable with placeholders
-      matches[i].varString = matches[i].variable
+    matches[i].varString = matches[i].variable
+    /* Save additional meta data about the variable */
+    // console.log('matches[i].varString', matches[i].varString)
+    if (variablesKnownTypes && variablesKnownTypes.test(matches[i].varString)) {
+      matches[i].varType = matches[i].varString.match(variablesKnownTypes)[1]
+      if (FALLBACK_REGEX.test(matches[i].varString)) {
+        const split = splitByComma(matches[i].varString, regex)
+        matches[i].hasFallback = true
+
+        matches[i].valueBeforeFallback = split[0]
+        // remove first element from split
+        matches[i].fallbackValues = split.slice(1).map((item) => {
+          // console.log('item', item)
+          const isVariable = variablesKnownTypes.test(item) || VAR_MATCH_REGEX.test(item)
+          const fallbackData = {
+            isVariable,
+            fullMatch: item,
+            variable: item
+          }
+
+          if (!isVariable && typeof item === 'string') {
+            fallbackData.stringValue = trimQuotes(item)
+            fallbackData.isFallback = true
+          }
+          
+          return fallbackData
+        })
+      }
     }
   }
   
   // Second pass: Reconstruct each variable with original nested syntax
   // We need to do this recursively to ensure all placeholders are replaced properly
-  function replaceAllPlaceholders(text, matchesArray) {
+  function replaceAllPlaceholders(text = '', matchesArray, key = 'fullMatch') {
     let result = text
     let needsAnotherPass = false
     
@@ -162,17 +129,14 @@ function findNestedVariables(input, regex, debug = false) {
     for (let i = 0; i < matchesArray.length; i++) {
       const m = matchesArray[i]
       if (result.includes(m.placeholder)) {
-        result = result.replace(
-          new RegExp(m.placeholder, 'g'), 
-          m.fullMatch
-        )
+        result = result.replace(new RegExp(m.placeholder, 'g'), m[key])
         needsAnotherPass = true
       }
     }
     
     // If we made replacements, we might need another pass to handle nested placeholders
     if (needsAnotherPass) {
-      return replaceAllPlaceholders(result, matchesArray)
+      return replaceAllPlaceholders(result, matchesArray, key)
     }
     
     return result
@@ -186,10 +150,19 @@ function findNestedVariables(input, regex, debug = false) {
     if (!currentMatch.fullMatch.includes('__VAR_') && !currentMatch.variable.includes('__VAR_')) {
       continue
     }
+
+    if (currentMatch.hasFallback) {
+      currentMatch.fallbackValues.forEach((item) => {
+        item.fullMatch = replaceAllPlaceholders(item.fullMatch, matches, 'fullMatch')
+        item.variable = replaceAllPlaceholders(item.variable, matches, 'variable')
+      })
+    }
     
     // Reconstruct with all nested variables
     currentMatch.fullMatch = replaceAllPlaceholders(currentMatch.fullMatch, matches)
     currentMatch.variable = replaceAllPlaceholders(currentMatch.variable, matches)
+
+  
   }
   
   if (debug) {
@@ -207,6 +180,67 @@ function findNestedVariables(input, regex, debug = false) {
 }
 
 
+/**
+ * Processes nested variable interpolations in a string and collects all matches
+ * @param {string} input - The input string containing variable interpolations
+ * @param {boolean} debug - Whether to print debug information
+ * @returns {Array} Array of match objects containing full match and captured group
+ */
+function findNestedVariablesx(input, regex, variablesKnownTypes, debug = false) {
+  let str = input
+  let matches = []
+  let match
+  let iteration = 0
+
+  console.log('input', input)
+  
+  if (debug) console.log(`Initial string: ${str}`)
+
+  // Process string until no more matches are found
+  while (true) {
+    iteration++
+    if (debug) console.log(`\nIteration ${iteration}:`)
+    
+    // Reset regex index
+    regex.lastIndex = 0
+    
+    // Find the next match
+    match = regex.exec(str)
+    if (!match) break
+    
+    // Log match details if in debug mode
+    if (debug) {
+      console.log(`Match: ${match[0]}`)
+      console.log(`Captured group: ${match[1]}`)
+    }
+    
+    // Store the match
+    matches.push({
+      fullMatch: match[0],
+      variable: match[1],
+      order: iteration
+    })
+    
+    // Replace the match with placeholder
+    str = str.replace(regex, `__REPLACED_${iteration - 1}__`)
+    if (debug) console.log(`After replacement: ${str}`)
+  }
+
+  // Replace the `__REPLACED_${iteration - 1}__` with the original match
+  matches = matches.map((match, index) => {
+    const indexOfReplaced = match.fullMatch.match(/__REPLACED_(\d+)__/)
+    if (indexOfReplaced) {
+      const replacedIndex = parseInt(indexOfReplaced[1])
+      match.fullMatch = match.fullMatch.replace(`__REPLACED_${replacedIndex}__`, matches[replacedIndex].variable)
+      match.variable = match.variable.replace(`__REPLACED_${replacedIndex}__`, matches[replacedIndex].variable)
+    }
+    return match
+  })
+
+  if (debug) console.log(`\nTotal matches found: ${matches.length}`)
+  return matches
+}
+
 // // Test with the example
 // const regex = /\${((?!AWS|stageVariables)[ ~:a-zA-Z0-9=+!@#%*<>?._'",|\-\/\(\)\\]+?)}/g
 // const input = '${file(./config.${opt:stage, ${defaultStage}}.json):CREDS}'

package/src/utils/find-nested-variables.test.js

@@ -1,23 +1,26 @@
 const { test } = require('uvu');
 const assert = require('uvu/assert');
 const { findNestedVariables } = require('./find-nested-variables');
+const deepLog = require('./deep-log')
 
 // Define the regex pattern as used in the main function
 const regex = /\${((?!AWS|stageVariables)[ ~:a-zA-Z0-9=+!@#%*<>?._'",|\-\/\(\)\\]+?)}/g;
+const variablesKnownTypes = /(^env:|^opt:|^self:|^file\((~?[\{\}\:\$a-zA-Z0-9._\-\/,'" ]+?)\)|^git:|(\${)?deep:\d+(\.[^}]+)*()}?)/
 
 test('findNestedVariables - simple variables', () => {
   const input = '${simple}';
-  const result = findNestedVariables(input, regex);
+  const result = findNestedVariables(input, regex, variablesKnownTypes, 'key');
+  deepLog('result', result)
   
   assert.equal(result.length, 1);
   assert.equal(result[0].fullMatch, '${simple}');
   assert.equal(result[0].variable, 'simple');
-  assert.equal(result[0].order, 1); 
+  assert.equal(result[0].resolveOrder, 1, 'order should be 1'); 
 });
 
 test('findNestedVariables - complex variable with colon syntax', () => {
   const input = '${opt:stage, dev}';
-  const result = findNestedVariables(input, regex);
+  const result = findNestedVariables(input, regex, variablesKnownTypes);
   
   assert.equal(result.length, 1);
   assert.equal(result[0].fullMatch, '${opt:stage, dev}');
@@ -26,7 +29,7 @@ test('findNestedVariables - complex variable with colon syntax', () => {
 
 test('findNestedVariables - one level nesting', () => {
   const input = '${file(./config.${stage}.json)}';
-  const result = findNestedVariables(input, regex);
+  const result = findNestedVariables(input, regex, variablesKnownTypes);
   
   assert.equal(result.length, 2);
   // The innermost variable should be found first
@@ -39,7 +42,7 @@ test('findNestedVariables - one level nesting', () => {
 
 test('findNestedVariables - two levels of nesting', () => {
   const input = '${file(./config.${opt:stage, ${defaultStage}}.json):CREDS}';
-  const result = findNestedVariables(input, regex);
+  const result = findNestedVariables(input, regex, variablesKnownTypes);
   
   assert.equal(result.length, 3);
   // Innermost first
@@ -55,7 +58,7 @@ test('findNestedVariables - two levels of nesting', () => {
 
 test('findNestedVariables - multiple separate variables', () => {
   const input = 'Hello ${name}, welcome to ${service}!';
-  const result = findNestedVariables(input, regex);
+  const result = findNestedVariables(input, regex, variablesKnownTypes);
   
   assert.equal(result.length, 2);
   assert.equal(result[0].fullMatch, '${name}');
@@ -64,7 +67,7 @@ test('findNestedVariables - multiple separate variables', () => {
 
 test('findNestedVariables - complex mixed case', () => {
   const input = '${db.${envOne}.host}:${db.${envTwo}.port} using ${credentials.${user.role}}';
-  const result = findNestedVariables(input, regex, true);
+  const result = findNestedVariables(input, regex, variablesKnownTypes);
   console.log('result', result)
   assert.equal(result.length, 6);
   // Check the correct nesting order
@@ -77,23 +80,40 @@ test('findNestedVariables - complex mixed case', () => {
 
 test('findNestedVariables - empty string', () => {
   const input = '';
-  const result = findNestedVariables(input, regex);
+  const result = findNestedVariables(input, regex, variablesKnownTypes);
   assert.equal(result.length, 0);
 });
 
 test('findNestedVariables - string with no variables', () => {
   const input = 'This is a string with no variables';
-  const result = findNestedVariables(input, regex);
+  const result = findNestedVariables(input, regex, variablesKnownTypes);
   assert.equal(result.length, 0);
 });
 
 test('findNestedVariables - varString property for nested variables', () => {
   const input = '${file(./config.${opt:stage, ${defaultStage}}.json)}';
-  const result = findNestedVariables(input, regex);
-  console.log('result', result)
+  const result = findNestedVariables(input, regex, variablesKnownTypes);
+  deepLog('result', result)
   // Check varString property for the outermost variable
   assert.equal(result[2].variable, 'file(./config.${opt:stage, ${defaultStage}}.json)');
 });
 
+test('findNestedVariables - mutliple fallback items', () => {
+  const input = '${file(./config.${opt:stage, ${opt:stageOne}, ${opt:stageTwo}, "three"}.json)}';
+  const result = findNestedVariables(input, regex, variablesKnownTypes);
+  deepLog('result', result)
+  // Check varString property for the outermost variable
+  assert.equal(result[result.length - 1].variable, 'file(./config.${opt:stage, ${opt:stageOne}, ${opt:stageTwo}, "three"}.json)');
+});
+
+test.skip('findNestedVariables - deep', () => {
+  const input = '${file(./config.${opt:stage, ${opt:stageOne, ${env:foo}}, ${opt:stageTwo}, "three" }.json)}';
+  const result = findNestedVariables(input, regex, variablesKnownTypes, 'xyz');
+  deepLog('result', result)
+  // Check varString property for the outermost variable
+  assert.equal(result[result.length - 1].variable, 'file(./config.${opt:stage, ${opt:stageOne}, ${opt:stageTwo}, "three"}.json)');
+});
+
+
 // Run all tests
 test.run(); 

package/src/utils/x.js

@@ -0,0 +1,173 @@
+process.env.foo = 'foo'
+process.env.opt_stage = 'stage'
+process.env.opt_stageOne = 'stageOne'
+process.env.opt_stageTwo = 'stageTwo'
+
+function getResolvers() {
+  return {
+    'file': async function fileResolver(arg) {
+      return 'filevalue'
+    },
+    'env:': async function envResolver(key) {
+      return process.env[key]
+    },
+    'opt:': async function optResolver(key) {
+      return process.env[`opt_${key}`] || null
+    }
+  }
+}
+
+async function resolveVariables(variableArray) {
+  // Sort by resolveOrder to ensure inner variables are resolved first
+  const sortedArray = [...variableArray].sort((a, b) => a.resolveOrder - b.resolveOrder)
+  const resolvedValues = {}
+  const resolvers = getResolvers()
+  
+  for (const item of sortedArray) {
+    let resolvedValue = null
+    
+    if (item.hasFallback) {
+      // Try to resolve the primary value
+      const resolver = resolvers[item.varType]
+      const primaryKey = item.valueBeforeFallback.replace(`${item.varType}`, '')
+      resolvedValue = await resolver(primaryKey)
+      
+      // If primary value is null, try fallbacks in order
+      if (resolvedValue === null) {
+        for (const fallback of item.fallbackValues) {
+          if (fallback.isVariable) {
+            // This is a reference to another variable that should be already resolved
+            const placeholderMatch = fallback.variable.match(/__VAR_(\d+)__/)
+            if (placeholderMatch) {
+              resolvedValue = resolvedValues[`__VAR_${placeholderMatch[1]}__`]
+              if (resolvedValue !== null) break
+            } else {
+              // It's a direct variable reference
+              const varType = fallback.variable.split(':')[0] + ':'
+              const varKey = fallback.variable.replace(`${varType}`, '')
+              resolvedValue = await resolvers[varType](varKey)
+              if (resolvedValue !== null) break
+            }
+          } else {
+            // It's a literal value
+            resolvedValue = fallback.variable.replace(/"/g, '')
+            break
+          }
+        }
+      }
+    } else if (item.varType.startsWith('file')) {
+      // Handle file type specially as it requires the resolved path
+      let filePath = item.varString
+      for (const [placeholder, value] of Object.entries(resolvedValues)) {
+        filePath = filePath.replace(placeholder, value)
+      }
+      resolvedValue = await resolvers['file'](filePath)
+    } else {
+      // Simple variable resolution
+      const resolver = resolvers[item.varType]
+      const key = item.variable.replace(`${item.varType}`, '')
+      resolvedValue = await resolver(key)
+    }
+    
+    resolvedValues[item.placeholder] = resolvedValue
+  }
+  
+  return resolvedValues
+}
+
+
+const array = [
+  {
+    location: 'xyz',
+    value: '${file(./config.${opt:stage, ${opt:stageOne, ${env:foo}}, ${opt:stageTwo}, "three" }.json)}',
+    fullMatch: '${env:foo}',
+    variable: 'env:foo',
+    varString: 'env:foo',
+    resolveOrder: 1,
+    start: 45,
+    end: 55,
+    placeholder: '__VAR_0__',
+    varType: 'env:'
+  },
+  {
+    location: 'xyz',
+    value: '${file(./config.${opt:stage, ${opt:stageOne, ${env:foo}}, ${opt:stageTwo}, "three" }.json)}',
+    fullMatch: '${opt:stageOne, ${env:foo}}',
+    variable: 'opt:stageOne, ${env:foo}',
+    varString: 'opt:stageOne, __VAR_0__',
+    resolveOrder: 2,
+    start: 29,
+    end: 55,
+    placeholder: '__VAR_1__',
+    varType: 'opt:',
+    hasFallback: true,
+    valueBeforeFallback: 'opt:stageOne',
+    fallbackValues: [
+      {
+        isVariable: true,
+        variable: 'env:foo',
+        fullMatch: '${env:foo}'
+      }
+    ]
+  },
+  {
+    location: 'xyz',
+    value: '${file(./config.${opt:stage, ${opt:stageOne, ${env:foo}}, ${opt:stageTwo}, "three" }.json)}',
+    fullMatch: '${opt:stageTwo}',
+    variable: 'opt:stageTwo',
+    varString: 'opt:stageTwo',
+    resolveOrder: 3,
+    start: 40,
+    end: 55,
+    placeholder: '__VAR_2__',
+    varType: 'opt:'
+  },
+  {
+    location: 'xyz',
+    value: '${file(./config.${opt:stage, ${opt:stageOne, ${env:foo}}, ${opt:stageTwo}, "three" }.json)}',
+    fullMatch: '${opt:stage, ${opt:stageOne, ${env:foo}}, ${opt:stageTwo}, "three" }',
+    variable: 'opt:stage, ${opt:stageOne, ${env:foo}}, ${opt:stageTwo}, "three"',
+    varString: 'opt:stage, __VAR_1__, __VAR_2__, "three"',
+    resolveOrder: 4,
+    start: 16,
+    end: 60,
+    placeholder: '__VAR_3__',
+    varType: 'opt:',
+    hasFallback: true,
+    valueBeforeFallback: 'opt:stage',
+    fallbackValues: [
+      {
+        isVariable: true,
+        variable: 'opt:stageOne, ${env:foo}',
+        fullMatch: '${opt:stageOne, ${env:foo}}'
+      },
+      {
+        isVariable: true,
+        variable: 'opt:stageTwo',
+        fullMatch: '${opt:stageTwo}'
+      },
+      { isVariable: false, variable: '"three"', fullMatch: '"three"' }
+    ]
+  },
+  {
+    location: 'xyz',
+    value: '${file(./config.${opt:stage, ${opt:stageOne, ${env:foo}}, ${opt:stageTwo}, "three" }.json)}',
+    fullMatch: '${file(./config.${opt:stage, ${opt:stageOne, ${env:foo}}, ${opt:stageTwo}, "three" }.json)}',
+    variable: 'file(./config.${opt:stage, ${opt:stageOne, ${env:foo}}, ${opt:stageTwo}, "three" }.json)',
+    varString: 'file(./config.__VAR_3__.json)',
+    resolveOrder: 5,
+    start: 0,
+    end: 32,
+    placeholder: '__VAR_4__',
+    varType: 'file(./config.__VAR_3__.json)'
+  }
+]
+
+
+resolveVariables(array)
+.then((res) => {
+  console.log('res', res)
+})
+.catch((err) => {
+  console.log('err', err)
+})