configorama 0.6.9 → 0.6.11

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

@@ -1,27 +1,31 @@
 const { splitByComma } = require('./splitByComma')
 const trimQuotes = require('./trimSurroundingQuotes')
+const { getVariableType } = require('./getVariableType')
 const FALLBACK_REGEX = /,\s*/
 const VAR_MATCH_REGEX = /__VAR_\d+__/
 
 /**
  * Finds all nested variable interpolations in a string while preserving original syntax
- * 
+ *
  * This function handles complex nested variables like:
  * ${file(./config.${opt:stage, ${defaultStage}}.json):CREDS}
- * 
+ *
  * The returned matches will include:
  * 1. innermost variables first (e.g., ${defaultStage})
  * 2. middle variables next (e.g., ${opt:stage, ${defaultStage}})
  * 3. outermost variables last (e.g., the entire expression)
- * 
+ *
  * Each variable retains its original syntax even in nested form.
- * 
+ *
  * @param {string} input - The input string containing variable interpolations
  * @param {RegExp} regex - The regex pattern to match variables
+ * @param {RegExp} variablesKnownTypes - Combined regex of all known variable types
+ * @param {string} location - The location in config where this variable appears
+ * @param {Array} variableTypes - Array of variable type definitions from resolvers
  * @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, variablesKnownTypes, location, debug = false) {
+function findNestedVariables(input, regex, variablesKnownTypes, location, variableTypes, debug = false) {
   // console.log('variablesKnownTypes', variablesKnownTypes)
   // Create a copy of the input for replacement tracking
   let current = input
@@ -52,10 +56,10 @@ function findNestedVariables(input, regex, variablesKnownTypes, location, debug
     
     // Store match details
     const matchInfo = {
-      varType: undefined,
+      variableType: undefined,
       location,
-      value: input,
-      fullMatch: match[0],
+      originalStringValue: input,
+      varMatch: match[0],
       variable: match[1].trim(),
       varString: match[1],
       resolveOrder: iteration,
@@ -95,7 +99,7 @@ function findNestedVariables(input, regex, variablesKnownTypes, location, debug
     // console.log('matches[i].varString', matches[i].varString)
 
     // if (variablesKnownTypes && variablesKnownTypes.test(matches[i].varString)) {
-    //   matches[i].varType = matches[i].varString.match(variablesKnownTypes)[1] 
+    //   matches[i].variableType = matches[i].varString.match(variablesKnownTypes)[1] 
     //   if (FALLBACK_REGEX.test(matches[i].varString)) {
     //     const split = splitByComma(matches[i].varString, regex)
     //     matches[i].hasFallback = true
@@ -124,10 +128,10 @@ function findNestedVariables(input, regex, variablesKnownTypes, location, debug
   
   // 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, key = 'fullMatch') {
+  function replaceAllPlaceholders(text = '', matchesArray, key = 'varMatch') {
     let result = text
     let needsAnotherPass = false
-    
+
     // Replace all placeholders with their original matches
     for (let i = 0; i < matchesArray.length; i++) {
       const m = matchesArray[i]
@@ -136,33 +140,33 @@ function findNestedVariables(input, regex, variablesKnownTypes, location, debug
         needsAnotherPass = true
       }
     }
-    
+
     // If we made replacements, we might need another pass to handle nested placeholders
     if (needsAnotherPass) {
       return replaceAllPlaceholders(result, matchesArray, key)
     }
-    
+
     return result
   }
   
   // For each match, reconstruct the original nested syntax
   for (let i = 0; i < matches.length; i++) {
     const currentMatch = matches[i]
-    
+
     // Skip if this match doesn't contain any placeholders
-    if (!currentMatch.fullMatch.includes('__VAR_') && !currentMatch.variable.includes('__VAR_')) {
+    if (!currentMatch.varMatch.includes('__VAR_') && !currentMatch.variable.includes('__VAR_')) {
       continue
     }
 
     if (currentMatch.hasFallback) {
       currentMatch.fallbackValues.forEach((item) => {
-        item.fullMatch = replaceAllPlaceholders(item.fullMatch, matches, 'fullMatch')
+        item.varMatch = replaceAllPlaceholders(item.varMatch, matches, 'varMatch')
         item.variable = replaceAllPlaceholders(item.variable, matches, 'variable')
       })
     }
-    
+
     // Reconstruct with all nested variables
-    currentMatch.fullMatch = replaceAllPlaceholders(currentMatch.fullMatch, matches)
+    currentMatch.varMatch = replaceAllPlaceholders(currentMatch.varMatch, matches)
     currentMatch.variable = replaceAllPlaceholders(currentMatch.variable, matches)
   }
 
@@ -174,7 +178,7 @@ function findNestedVariables(input, regex, variablesKnownTypes, location, debug
     // console.log('matches[i].varString', matches[i].varString)
 
     if (variablesKnownTypes && variablesKnownTypes.test(matches[i].varString)) {
-      matches[i].varType = matches[i].varString.match(variablesKnownTypes)[1] 
+      matches[i].variableType = getVariableType(matches[i].varString, variableTypes)
       if (FALLBACK_REGEX.test(matches[i].varString)) {
         const split = splitByComma(matches[i].varString, regex)
         matches[i].hasFallback = true
@@ -188,7 +192,7 @@ function findNestedVariables(input, regex, variablesKnownTypes, location, debug
           const isVariable = variablesKnownTypes.test(innerContent) || VAR_MATCH_REGEX.test(item)
           const fallbackData = {
             isVariable,
-            fullMatch: item,
+            varMatch: item,
             variable: item,
           }
 
@@ -198,31 +202,30 @@ function findNestedVariables(input, regex, variablesKnownTypes, location, debug
           }
 
           if (isVariable) {
-            const varType = innerContent.match(variablesKnownTypes)[1]
-            fallbackData.varType = varType
-            // if (varType === 'self:') {
-            //   fallbackData.fullMatch = item.replace('self:', '')
+            fallbackData.variableType = getVariableType(innerContent, variableTypes)
+            // if (variableType === 'self:') {
+            //   fallbackData.varMatch = item.replace('self:', '')
             //   fallbackData.variable = item.replace('self:', '')
-            //   fallbackData.varType = 'dot.prop'
+            //   fallbackData.variableType = 'dot.prop'
             // }
           }
           return fallbackData
         })
       }
-    } else if (typeof matches[i].varType === 'undefined') {
-      matches[i].varType = 'dot.prop'
+    } else if (typeof matches[i].variableType === 'undefined') {
+      matches[i].variableType = 'dot.prop'
     }
   }
 
   const finalMatches = matches.map((m) => {
     delete m.placeholder
-    if (typeof m.varType === 'undefined') {
+    if (typeof m.variableType === 'undefined') {
       /*
       {
-        varType: 'dot.prop',
+        variableType: 'dot.prop',
         location: 'resolvedDomainName',
-        value: '${domainByStage.${opt:stage, ${defaultStage}}}',
-        fullMatch: '${domainByStage.${opt:stage, ${defaultStage}}}',
+        originalStringValue: '${domainByStage.${opt:stage, ${defaultStage}}}',
+        varMatch: '${domainByStage.${opt:stage, ${defaultStage}}}',
         variable: 'domainByStage.${opt:stage, ${defaultStage}}',
         varString: 'domainByStage.__VAR_1__',
         resolveOrder: 3,
@@ -230,10 +233,10 @@ function findNestedVariables(input, regex, variablesKnownTypes, location, debug
         end: 26
       }
       {
-        varType: 'dot.prop',
+        variableType: 'dot.prop',
         location: 'resolvedDomainName',
-        value: '${domainByStage.${opt:stage, ${defaultStage}}}',
-        fullMatch: '${defaultStage}',
+        originalStringValue: '${domainByStage.${opt:stage, ${defaultStage}}}',
+        varMatch: '${defaultStage}',
         variable: 'defaultStage',
         varString: 'defaultStage',
         resolveOrder: 1,
@@ -255,7 +258,7 @@ function findNestedVariables(input, regex, variablesKnownTypes, location, debug
       }, m.fallbackValues)
       m.fallbackValues = combinedFallbacks
     }
-    if (m.varType === 'dot.prop') {
+    if (m.variableType === 'dot.prop') {
       // const reversedMatches = matches.reverse()
       // const test = reversedMatches.reduce((acc, f) => {
       //   console.log('f', f)
@@ -276,7 +279,7 @@ function findNestedVariables(input, regex, variablesKnownTypes, location, debug
     console.log("\nReconstructed matches:")
     matches.forEach((m, i) => {
       console.log(`Match #${i+1} (order ${m.order}):`)
-      console.log(`Full: ${m.fullMatch}`)
+      console.log(`VarMatch: ${m.varMatch}`)
       console.log(`Variable: ${m.variable}`)
       console.log(`VarString: ${m.varString}`)
       console.log(`Placeholder: ${m.placeholder}`)
@@ -335,10 +338,10 @@ function findNestedVariablesOld(input, regex, variablesKnownTypes, debug = false
 
   // Replace the `__REPLACED_${iteration - 1}__` with the original match
   matches = matches.map((match, index) => {
-    const indexOfReplaced = match.fullMatch.match(/__REPLACED_(\d+)__/)
+    const indexOfReplaced = match.varMatch.match(/__REPLACED_(\d+)__/)
     if (indexOfReplaced) {
       const replacedIndex = parseInt(indexOfReplaced[1])
-      match.fullMatch = match.fullMatch.replace(`__REPLACED_${replacedIndex}__`, matches[replacedIndex].variable)
+      match.varMatch = match.varMatch.replace(`__REPLACED_${replacedIndex}__`, matches[replacedIndex].variable)
       match.variable = match.variable.replace(`__REPLACED_${replacedIndex}__`, matches[replacedIndex].variable)
     }
     return match

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

@@ -3,96 +3,133 @@ const assert = require('uvu/assert');
 const { findNestedVariables } = require('./find-nested-variables');
 const deepLog = require('./deep-log')
 
+// Import resolvers to build variableTypes array
+const getValueFromEnv = require('../resolvers/valueFromEnv')
+const getValueFromOptions = require('../resolvers/valueFromOptions')
+const getValueFromGit = require('../resolvers/valueFromGit')
+
 // 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+(\.[^}]+)*()}?)/
 
+const fileRefSyntax = RegExp(/^file\((~?[@\{\}\:\$a-zA-Z0-9._\-\/,'" ]+?)\)/g)
+const textRefSyntax = RegExp(/^text\((~?[@\{\}\:\$a-zA-Z0-9._\-\/,'" ]+?)\)/g)
+const selfRefSyntax = RegExp(/^self:/g)
+const deepRefSyntax = RegExp(/(\${)?deep:\d+(\.[^}]+)*()}?/)
+
+// Build variableTypes array similar to main.js
+const variableTypes = [
+  getValueFromEnv,
+  getValueFromOptions,
+  getValueFromGit,
+  {
+    type: 'self',
+    prefix: 'self',
+    match: selfRefSyntax,
+  },
+  {
+    type: 'file',
+    prefix: 'file',
+    match: fileRefSyntax,
+  },
+  {
+    type: 'text',
+    prefix: 'text',
+    match: textRefSyntax,
+  },
+  {
+    type: 'deep',
+    prefix: 'deep',
+    match: deepRefSyntax,
+  },
+]
+
 test('findNestedVariables - simple variables', () => {
   const input = '${simple}';
-  const result = findNestedVariables(input, regex, variablesKnownTypes, 'key');
+  const result = findNestedVariables(input, regex, variablesKnownTypes, 'key', variableTypes);
   deepLog('result', result)
   
   assert.equal(result.length, 1);
-  assert.equal(result[0].fullMatch, '${simple}');
+  assert.equal(result[0].varMatch, '${simple}');
   assert.equal(result[0].variable, 'simple');
   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, variablesKnownTypes);
+  const result = findNestedVariables(input, regex, variablesKnownTypes, undefined, variableTypes);
   
   assert.equal(result.length, 1);
-  assert.equal(result[0].fullMatch, '${opt:stage, dev}');
+  assert.equal(result[0].varMatch, '${opt:stage, dev}');
   assert.equal(result[0].variable, 'opt:stage, dev');
 });
 
 test('findNestedVariables - one level nesting', () => {
   const input = '${file(./config.${stage}.json)}';
-  const result = findNestedVariables(input, regex, variablesKnownTypes);
+  const result = findNestedVariables(input, regex, variablesKnownTypes, undefined, variableTypes);
   
   assert.equal(result.length, 2);
   // The innermost variable should be found first
-  assert.equal(result[0].fullMatch, '${stage}');
+  assert.equal(result[0].varMatch, '${stage}');
   assert.equal(result[0].variable, 'stage');
   // Then the outer variable
-  assert.equal(result[1].fullMatch, '${file(./config.${stage}.json)}');
+  assert.equal(result[1].varMatch, '${file(./config.${stage}.json)}');
   assert.equal(result[1].variable, 'file(./config.${stage}.json)');
 });   
 
 test('findNestedVariables - two levels of nesting', () => {
   const input = '${file(./config.${opt:stage, ${defaultStage}}.json):CREDS}';
-  const result = findNestedVariables(input, regex, variablesKnownTypes);
+  const result = findNestedVariables(input, regex, variablesKnownTypes, undefined, variableTypes);
   
   assert.equal(result.length, 3);
   // Innermost first
-  assert.equal(result[0].fullMatch, '${defaultStage}');
+  assert.equal(result[0].varMatch, '${defaultStage}');
   assert.equal(result[0].variable, 'defaultStage');
   // Middle next
-  assert.equal(result[1].fullMatch, '${opt:stage, ${defaultStage}}');
+  assert.equal(result[1].varMatch, '${opt:stage, ${defaultStage}}');
   assert.equal(result[1].variable, 'opt:stage, ${defaultStage}');
   // Outermost last
-  assert.equal(result[2].fullMatch, '${file(./config.${opt:stage, ${defaultStage}}.json):CREDS}');
+  assert.equal(result[2].varMatch, '${file(./config.${opt:stage, ${defaultStage}}.json):CREDS}');
   assert.equal(result[2].variable, 'file(./config.${opt:stage, ${defaultStage}}.json):CREDS');
 });
 
 test('findNestedVariables - multiple separate variables', () => {
   const input = 'Hello ${name}, welcome to ${service}!';
-  const result = findNestedVariables(input, regex, variablesKnownTypes);
+  const result = findNestedVariables(input, regex, variablesKnownTypes, undefined, variableTypes);
   
   assert.equal(result.length, 2);
-  assert.equal(result[0].fullMatch, '${name}');
-  assert.equal(result[1].fullMatch, '${service}');
+  assert.equal(result[0].varMatch, '${name}');
+  assert.equal(result[1].varMatch, '${service}');
 });
 
 test('findNestedVariables - complex mixed case', () => {
   const input = '${db.${envOne}.host}:${db.${envTwo}.port} using ${credentials.${user.role}}';
-  const result = findNestedVariables(input, regex, variablesKnownTypes);
+  const result = findNestedVariables(input, regex, variablesKnownTypes, undefined, variableTypes);
   console.log('result', result)
   assert.equal(result.length, 6);
   // Check the correct nesting order
-  assert.equal(result[0].fullMatch, '${envOne}');
-  assert.equal(result[1].fullMatch, '${db.${envOne}.host}');
-  assert.equal(result[2].fullMatch, '${envTwo}');
-  assert.equal(result[3].fullMatch, '${db.${envTwo}.port}');
-  assert.equal(result[4].fullMatch, '${user.role}');
+  assert.equal(result[0].varMatch, '${envOne}');
+  assert.equal(result[1].varMatch, '${db.${envOne}.host}');
+  assert.equal(result[2].varMatch, '${envTwo}');
+  assert.equal(result[3].varMatch, '${db.${envTwo}.port}');
+  assert.equal(result[4].varMatch, '${user.role}');
 });
 
 test('findNestedVariables - empty string', () => {
   const input = '';
-  const result = findNestedVariables(input, regex, variablesKnownTypes);
+  const result = findNestedVariables(input, regex, variablesKnownTypes, undefined, variableTypes);
   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, variablesKnownTypes);
+  const result = findNestedVariables(input, regex, variablesKnownTypes, undefined, variableTypes);
   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, variablesKnownTypes);
+  const result = findNestedVariables(input, regex, variablesKnownTypes, undefined, variableTypes);
   deepLog('result', result)
   // Check varString property for the outermost variable
   assert.equal(result[2].variable, 'file(./config.${opt:stage, ${defaultStage}}.json)');
@@ -100,13 +137,60 @@ test('findNestedVariables - varString property for nested variables', () => {
 
 test('findNestedVariables - mutliple fallback items', () => {
   const input = '${file(./config.${opt:stage, ${opt:stageOne}, ${opt:stageTwo}, "three"}.json)}';
-  const result = findNestedVariables(input, regex, variablesKnownTypes);
+  const result = findNestedVariables(input, regex, variablesKnownTypes, undefined, variableTypes);
   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('findNestedVariables - deep', () => {
+  const input =
+  '${file(./config.${opt:stage, ${opt:stageOne, ${env:foo}}, ${opt:stageTwo}, "three" }.json)}';
+  const result = findNestedVariables(input, regex, variablesKnownTypes, 'xyz', variableTypes);
+  deepLog('result', result)
+
+  // Should have 5 variables total
+  assert.equal(result.length, 5);
+
+  // Check the innermost variable
+  assert.equal(result[0].varMatch, '${env:foo}');
+  assert.equal(result[0].variable, 'env:foo');
+  assert.equal(result[0].variableType, 'env');
+
+  // Check opt:stageOne with env:foo fallback
+  assert.equal(result[1].varMatch, '${opt:stageOne, ${env:foo}}');
+  assert.equal(result[1].variable, 'opt:stageOne, ${env:foo}');
+  assert.equal(result[1].variableType, 'options');
+  assert.equal(result[1].hasFallback, true);
+  assert.equal(result[1].valueBeforeFallback, 'opt:stageOne');
+  assert.equal(result[1].fallbackValues.length, 1);
+  assert.equal(result[1].fallbackValues[0].isVariable, true);
+  assert.equal(result[1].fallbackValues[0].varMatch, '${env:foo}');
+  assert.equal(result[1].fallbackValues[0].variableType, 'env');
+
+  // Check opt:stageTwo
+  assert.equal(result[2].varMatch, '${opt:stageTwo}');
+  assert.equal(result[2].variable, 'opt:stageTwo');
+
+  // Check opt:stage with multiple fallbacks
+  assert.equal(result[3].varMatch, '${opt:stage, ${opt:stageOne, ${env:foo}}, ${opt:stageTwo}, "three" }');
+  assert.equal(result[3].variable, 'opt:stage, ${opt:stageOne, ${env:foo}}, ${opt:stageTwo}, "three"');
+  assert.equal(result[3].hasFallback, true);
+  assert.equal(result[3].valueBeforeFallback, 'opt:stage');
+  assert.equal(result[3].fallbackValues.length, 3);
+  assert.equal(result[3].fallbackValues[0].varMatch, '${opt:stageOne, ${env:foo}}');
+  assert.equal(result[3].fallbackValues[0].isVariable, true);
+  assert.equal(result[3].fallbackValues[1].varMatch, '${opt:stageTwo}');
+  assert.equal(result[3].fallbackValues[1].isVariable, true);
+  assert.equal(result[3].fallbackValues[2].varMatch, '"three"');
+  assert.equal(result[3].fallbackValues[2].isVariable, false);
+  assert.equal(result[3].fallbackValues[2].stringValue, 'three');
+
+  // Check outermost file variable
+  assert.equal(result[4].variable, 'file(./config.${opt:stage, ${opt:stageOne, ${env:foo}}, ${opt:stageTwo}, "three" }.json)');
+});
+
+test('findNestedVariables - deep - no var types passed', () => {
   const input =
   '${file(./config.${opt:stage, ${opt:stageOne, ${env:foo}}, ${opt:stageTwo}, "three" }.json)}';
   const result = findNestedVariables(input, regex, variablesKnownTypes, 'xyz');
@@ -116,36 +200,36 @@ test('findNestedVariables - deep', () => {
   assert.equal(result.length, 5);
 
   // Check the innermost variable
-  assert.equal(result[0].fullMatch, '${env:foo}');
+  assert.equal(result[0].varMatch, '${env:foo}');
   assert.equal(result[0].variable, 'env:foo');
-  assert.equal(result[0].varType, 'env:');
+  assert.equal(result[0].variableType, 'env');
 
   // Check opt:stageOne with env:foo fallback
-  assert.equal(result[1].fullMatch, '${opt:stageOne, ${env:foo}}');
+  assert.equal(result[1].varMatch, '${opt:stageOne, ${env:foo}}');
   assert.equal(result[1].variable, 'opt:stageOne, ${env:foo}');
-  assert.equal(result[1].varType, 'opt:');
+  assert.equal(result[1].variableType, 'options');
   assert.equal(result[1].hasFallback, true);
   assert.equal(result[1].valueBeforeFallback, 'opt:stageOne');
   assert.equal(result[1].fallbackValues.length, 1);
   assert.equal(result[1].fallbackValues[0].isVariable, true);
-  assert.equal(result[1].fallbackValues[0].fullMatch, '${env:foo}');
-  assert.equal(result[1].fallbackValues[0].varType, 'env:');
+  assert.equal(result[1].fallbackValues[0].varMatch, '${env:foo}');
+  assert.equal(result[1].fallbackValues[0].variableType, 'env');
 
   // Check opt:stageTwo
-  assert.equal(result[2].fullMatch, '${opt:stageTwo}');
+  assert.equal(result[2].varMatch, '${opt:stageTwo}');
   assert.equal(result[2].variable, 'opt:stageTwo');
 
   // Check opt:stage with multiple fallbacks
-  assert.equal(result[3].fullMatch, '${opt:stage, ${opt:stageOne, ${env:foo}}, ${opt:stageTwo}, "three" }');
+  assert.equal(result[3].varMatch, '${opt:stage, ${opt:stageOne, ${env:foo}}, ${opt:stageTwo}, "three" }');
   assert.equal(result[3].variable, 'opt:stage, ${opt:stageOne, ${env:foo}}, ${opt:stageTwo}, "three"');
   assert.equal(result[3].hasFallback, true);
   assert.equal(result[3].valueBeforeFallback, 'opt:stage');
   assert.equal(result[3].fallbackValues.length, 3);
-  assert.equal(result[3].fallbackValues[0].fullMatch, '${opt:stageOne, ${env:foo}}');
+  assert.equal(result[3].fallbackValues[0].varMatch, '${opt:stageOne, ${env:foo}}');
   assert.equal(result[3].fallbackValues[0].isVariable, true);
-  assert.equal(result[3].fallbackValues[1].fullMatch, '${opt:stageTwo}');
+  assert.equal(result[3].fallbackValues[1].varMatch, '${opt:stageTwo}');
   assert.equal(result[3].fallbackValues[1].isVariable, true);
-  assert.equal(result[3].fallbackValues[2].fullMatch, '"three"');
+  assert.equal(result[3].fallbackValues[2].varMatch, '"three"');
   assert.equal(result[3].fallbackValues[2].isVariable, false);
   assert.equal(result[3].fallbackValues[2].stringValue, 'three');
 

package/src/utils/getFullFilePath.js

@@ -2,6 +2,8 @@ const os = require('os')
 const fs = require('fs')
 const path = require('path')
 const findUp = require('find-up')
+const trimSurroundingQuotes = require('./trimSurroundingQuotes')
+const { resolveAlias } = require('./resolveAlias')
 
 module.exports = function getFullPath(fileString, cwd) {
   const configPath = cwd || process.cwd()
@@ -21,3 +23,39 @@ module.exports = function getFullPath(fileString, cwd) {
 
   return fullFilePath
 }
+
+/**
+ * Resolves a file path from a matched file string (e.g., from file() or text() syntax)
+ * @param {string} matchedFileString - The matched file string (e.g., "file(path/to/file.js)")
+ * @param {RegExp} syntax - The regex pattern used to match the file string (e.g., fileRefSyntax or textRefSyntax)
+ * @param {string} configPath - The base directory path for resolving relative paths
+ * @returns {{fullFilePath: string|null, resolvedPath: string}} - Object containing the resolved full file path and the resolved path (after alias resolution)
+ */
+function resolveFilePathFromMatch(matchedFileString, syntax, configPath) {
+  const relativePath = trimSurroundingQuotes(
+    matchedFileString.replace(syntax, (match, varName) => varName.trim()).replace('~', os.homedir()),
+  )
+
+  // Resolve alias if the path contains alias syntax
+  const resolvedPath = resolveAlias(relativePath, configPath)
+
+  let fullFilePath = path.isAbsolute(resolvedPath) ? resolvedPath : path.join(configPath, resolvedPath)
+
+  if (fs.existsSync(fullFilePath)) {
+    // Get real path to handle potential symlinks (but don't fatal error)
+    fullFilePath = fs.realpathSync(fullFilePath)
+
+    // Only match files that are relative
+  } else if (resolvedPath.match(/\.\//)) {
+    // TODO test higher parent refs
+    const cleanName = path.basename(resolvedPath)
+    const findUpResult = findUp.sync(cleanName, { cwd: configPath })
+    if (findUpResult) {
+      fullFilePath = findUpResult
+    }
+  }
+
+  return { fullFilePath, resolvedPath, relativePath }
+}
+
+module.exports.resolveFilePathFromMatch = resolveFilePathFromMatch

package/src/utils/getVariableType.js

@@ -0,0 +1,55 @@
+// Utility to determine variable type from variable string using resolver definitions
+
+const fallbackMap = {
+  opt: 'options',
+  file: 'file',
+  text: 'text',
+}
+
+/**
+ * Determines the type of a variable by matching against resolver definitions
+ * @param {string} varString - The variable string (without ${})
+ * @param {Array} variableTypes - Array of variable type definitions with match regex and type
+ * @returns {string} The type field from the matching resolver, or 'dot.prop' as fallback
+ */
+function getVariableType(varString, variableTypes) {
+  if (!varString || !variableTypes) {
+    // if no variable types passed, try to guess the type from the variable string
+    if (!variableTypes) {
+      const unWrappedVarString = varString.replace(/^\$\{(.*)\}$/, '$1')
+      // if var:
+      if (unWrappedVarString.match(/^[a-zA-Z0-9._-]+:/)) {
+        const type = unWrappedVarString.split(':')[0]
+        return fallbackMap[type] || type
+      } else if (unWrappedVarString.match(/^[a-zA-Z0-9._-]+\(/)) {
+        const type = unWrappedVarString.split('(')[0]
+        return fallbackMap[type] || 'function'
+      }
+    }
+    // console.log('getVariableType early return', { varString, hasVariableTypes: !!variableTypes })
+    return 'dot.prop'
+  }
+
+  for (const variableType of variableTypes) {
+    if (!variableType.match) continue
+
+    // Handle both regex and function matchers
+    if (typeof variableType.match === 'function') {
+      if (variableType.match(varString)) {
+        return variableType.type
+      }
+    } else if (variableType.match.test) {
+      // Reset regex lastIndex to ensure clean matching
+      variableType.match.lastIndex = 0
+      if (variableType.match.test(varString)) {
+        return variableType.type
+      }
+    }
+  }
+
+  // Fallback to dot.prop for simple property references
+  // console.log('varString no match, fallback to dot.prop:', varString)
+  return 'dot.prop'
+}
+
+module.exports = { getVariableType }

package/src/utils/logs.js

@@ -2,7 +2,7 @@ const { makeHeader } = require('@davidwells/box-logger')
 
 function logHeader(message) {
   console.log(makeHeader({
-    text: message, 
+    content: message, 
     rightBorder: true, 
     minWidth: 80, 
     textStyle: 'bold',

package/src/utils/parse.js

@@ -1,6 +1,7 @@
 const YAML = require('../parsers/yaml')
 const TOML = require('../parsers/toml')
 const INI = require('../parsers/ini')
+const JSON5 = require('../parsers/json5')
 const { executeTypeScriptFileSync } = require('../parsers/typescript')
 const { executeESMFileSync } = require('../parsers/esm')
 const cloudFormationSchema = require('./cloudformationSchema')
@@ -35,13 +36,14 @@ function parseFileContents(fileContents, fileType, filePath, varRegex, opts = {}
         configObject = result.data
       }
     }
-  } else if (fileType.match(/\.(toml)/)) {
+  } else if (fileType.match(/\.(toml|tml)/)) {
     configObject = TOML.parse(fileContents)
   } else if (fileType.match(/\.(ini)/)) {
     configObject = INI.parse(fileContents)
-  } else if (fileType.match(/\.(json)/)) {
-    configObject = JSON.parse(fileContents)
-  } else if (fileType.match(/\.(js)/)) {
+  } else if (fileType.match(/\.(json|json5)/)) {
+    configObject = JSON5.parse(fileContents)
+  // TODO detect js syntax and use appropriate parser
+  } else if (fileType.match(/\.(js|cjs)/)) {
     let jsFile
     try {
       jsFile = require(filePath)

package/src/utils/resolveAlias.js

@@ -1,6 +1,7 @@
 const path = require('path')
 const fs = require('fs')
 const findUp = require('find-up')
+const JSON5 = require('../parsers/json5')
 
 const DEBUG = false
 const DEBUG_LOG = (message) => {
@@ -57,7 +58,7 @@ function resolveAlias(filePath, configDir) {
     }
 
     // Read and parse config file
-    const config = JSON.parse(fs.readFileSync(configPath, 'utf8'))
+    const config = JSON5.parse(fs.readFileSync(configPath, 'utf8'))
     const { paths = {}, baseUrl = '.' } = config.compilerOptions || {}
 
     // Extract the alias prefix and path
@@ -128,7 +129,7 @@ function getAliases(configDir) {
       return { names: [], lookup: [] }
     }
 
-    const config = JSON.parse(fs.readFileSync(configPath, 'utf8'))
+    const config = JSON5.parse(fs.readFileSync(configPath, 'utf8'))
     const { paths = {}, baseUrl = '.' } = config.compilerOptions || {}
 
     const names = Object.keys(paths).map(key => key.replace('/*', ''))