configorama 0.5.1 → 0.5.3

package/src/utils/cleanVariable.js

@@ -1,3 +1,4 @@
+const { findNestedVariables } = require('./find-nested-variables')
 /**
  * Convert variable into string
  * ${opt:foo} => 'opt:foo'
@@ -7,10 +8,37 @@
 
 const fileRefSyntax = RegExp(/^file\((~?[a-zA-Z0-9._\-\/,'" ]+?)\)/g)
 const funcRegex = /(\w+)\s*\(((?:[^()]+)*)?\s*\)\s*/
-module.exports = function cleanVariable(match, variableSyntax, simple) {
-  const clean = match.replace(variableSyntax, (context, contents) => {
+module.exports = function cleanVariable(match, variableSyntax, simple, caller) {
+  //console.log(`Clean input  [${caller}]`, match)
+
+  let varToClean = match
+
+  /*
+  const nestedVar = findNestedVariables(match, variableSyntax)
+  console.log('nestedVarssss', nestedVar)
+  if (nestedVar.length > 1) {
+    const lastMatch = nestedVar[nestedVar.length - 1]
+    console.log(`Clean output nested [${caller}]`, lastMatch.variable)
+    return lastMatch.variable
+    console.log('lastMatch', lastMatch)
+    const matchIndex = lastMatch.varString.match(/__VAR_(\d+)__/)
+    console.log('matchIndex', matchIndex)
+    if (matchIndex) {
+      const index = parseInt(matchIndex[1]) 
+      console.log('index', index)
+      console.log('nestedVar', nestedVar)
+      console.log('nestedVar[index]', nestedVar[index])
+      varToClean = lastMatch.varString.replace(/__VAR_(\d+)__/g, nestedVar[index].fullMatch)
+      return varToClean
+    }
+  }
+  // process.exit(1)
+  /** */
+
+  const clean = varToClean.replace(variableSyntax, (context, contents) => {
     return contents.trim()
   })
+  //console.log(`Clean output [${caller}]`, clean)
   return clean
 
   // Support for simple variable cleaning with no space tweaks

package/src/utils/cleanVariable.test.js

@@ -0,0 +1,98 @@
+const { test } = require('uvu')
+const assert = require('uvu/assert')
+const cleanVariable = require('./cleanVariable')
+
+test('cleanVariable - simple variable syntax without nesting', () => {
+  // Setup
+  const variableSyntax = /\${([^{}]+?)}/g
+  const match = '${opt:foo}'
+  
+  // Execute
+  const result = cleanVariable(match, variableSyntax, false, 'test')
+  
+  // Verify
+  assert.is(result, 'opt:foo')
+})
+
+test.skip('cleanVariable - with nested variables', () => {
+  // Setup
+  const variableSyntax = /\${([^{}]+?)}/g
+  const match = '${var:${opt:stage}}'
+  const nestedVars = [
+    { varString: 'var:__VAR_1__', fullMatch: '${opt:stage}' },
+    { varString: 'opt:stage', fullMatch: '${opt:stage}' }
+  ]
+  
+  // Execute
+  const result = cleanVariable(match, variableSyntax, false, 'test')
+  
+  // Verify
+  assert.is(result, 'var:${opt:stage}')
+})
+
+test('cleanVariable - file reference with commas', () => {
+  // Setup
+  const variableSyntax = /\${([^{}]+?)}/g
+  const match = '${file(path/to/file.yml, key1, key2)}'
+  
+  // Execute
+  const result = cleanVariable(match, variableSyntax, false, 'test')
+  
+  // Verify
+  assert.is(result, 'file(path/to/file.yml, key1, key2)')
+})
+
+test('cleanVariable - function format', () => {
+  // Setup
+  const variableSyntax = /\${([^{}]+?)}/g
+  const match = '${someFunc(param1, param2)}'
+  
+  // Execute
+  const result = cleanVariable(match, variableSyntax, false, 'test')
+  
+  // Verify
+  assert.is(result, 'someFunc(param1, param2)')
+})
+
+test('cleanVariable - simple mode', () => {
+  // Setup
+  const variableSyntax = /\${([^{}]+?)}/g
+  const match = '${opt:foo with spaces}'
+  
+  // Execute
+  const result = cleanVariable(match, variableSyntax, true, 'test')
+  
+  // Verify
+  assert.is(result, 'opt:foo with spaces', 'Should preserve spaces in simple mode')
+})
+
+test('cleanVariable - whitespace handling outside quotes', () => {
+  // Setup
+  const variableSyntax = /\${([^{}]+?)}/g
+  const match = '${empty, "fallback value with space"}'
+  
+  // Execute
+  const result = cleanVariable(match, variableSyntax, false, 'test')
+  
+  // Verify
+  assert.is(result, 'empty, "fallback value with space"')
+})
+
+test.skip('cleanVariable - complex nested variables', () => {
+  // Setup
+  const variableSyntax = /\${([^{}]+?)}/g
+  const match = '${var:${opt:${stage}}}'
+  const nestedVars = [
+    { varString: 'var:__VAR_1__', fullMatch: '${opt:${stage}}' },
+    { varString: 'opt:__VAR_2__', fullMatch: '${stage}' },
+    { varString: 'stage', fullMatch: '${stage}' }
+  ]
+  
+  // Execute
+  const result = cleanVariable(match, variableSyntax, false, 'test')
+  
+  // Verify
+  assert.is(result, 'var:${opt:${stage}}')
+})
+
+test.run() 

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

@@ -0,0 +1,227 @@
+/**
+ * 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
+}
+
+/**
+ * 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 {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) {
+  // Create a copy of the input for replacement tracking
+  let workingString = input
+  // console.log('workingString', workingString)
+  // Store matches with their positions in the original string
+  let matches = []
+  // Track original positions and replacements
+  let replacements = []
+  let match
+  let iteration = 0
+  
+  if (debug) console.log(`Initial string: ${input}`)
+
+  // First pass: Find all matches and create unique placeholders
+  while (true) {
+    iteration++
+    if (debug) console.log(`\nIteration ${iteration}:`)
+    
+    // Reset regex index
+    regex.lastIndex = 0
+    
+    // Find the next match in the working string
+    match = regex.exec(workingString)
+    if (!match) break
+    
+    // Generate a unique placeholder
+    const placeholder = `__VAR_${iteration - 1}__`
+    
+    // Store match details
+    const matchInfo = {
+      fullMatch: match[0],
+      variable: match[1],
+      order: iteration,
+      start: match.index,
+      end: match.index + match[0].length,
+      placeholder
+    }
+    
+    if (debug) {
+      console.log(`Match: ${match[0]}`)
+      console.log(`Captured group: ${match[1]}`)
+      console.log(`Position: ${match.index}`)
+    }
+    
+    matches.push(matchInfo)
+    
+    // Store replacement info
+    replacements.push({
+      original: match[0],
+      placeholder,
+      start: match.index,
+      end: match.index + match[0].length
+    })
+    
+    // Replace in working string (to find next match)
+    workingString = workingString.substring(0, match.index) + 
+                   placeholder + 
+                   workingString.substring(match.index + match[0].length)
+    
+    if (debug) console.log(`After replacement: ${workingString}`)
+  }
+  
+  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
+    }
+  }
+  
+  // 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) {
+    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]
+      if (result.includes(m.placeholder)) {
+        result = result.replace(
+          new RegExp(m.placeholder, 'g'), 
+          m.fullMatch
+        )
+        needsAnotherPass = true
+      }
+    }
+    
+    // If we made replacements, we might need another pass to handle nested placeholders
+    if (needsAnotherPass) {
+      return replaceAllPlaceholders(result, matchesArray)
+    }
+    
+    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_')) {
+      continue
+    }
+    
+    // Reconstruct with all nested variables
+    currentMatch.fullMatch = replaceAllPlaceholders(currentMatch.fullMatch, matches)
+    currentMatch.variable = replaceAllPlaceholders(currentMatch.variable, matches)
+  }
+  
+  if (debug) {
+    console.log("\nReconstructed matches:")
+    matches.forEach((m, i) => {
+      console.log(`Match #${i+1} (order ${m.order}):`)
+      console.log(`Full: ${m.fullMatch}`)
+      console.log(`Variable: ${m.variable}`)
+      console.log(`VarString: ${m.varString}`)
+      console.log(`Placeholder: ${m.placeholder}`)
+    })
+  }
+  
+  return matches
+}
+
+
+// // Test with the example
+// const regex = /\${((?!AWS|stageVariables)[ ~:a-zA-Z0-9=+!@#%*<>?._'",|\-\/\(\)\\]+?)}/g
+// const input = '${file(./config.${opt:stage, ${defaultStage}}.json):CREDS}'
+
+// // Run the function with debug output
+// const result = findNestedVariables(input, regex, true)
+
+// // Display final result
+// console.log("\nFinal result:")
+// console.log(JSON.stringify(result, null, 2))
+
+// module.exports = {
+//   findNestedVariables
+// }
+
+module.exports = {
+  findNestedVariables
+}

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

@@ -0,0 +1,99 @@
+const { test } = require('uvu');
+const assert = require('uvu/assert');
+const { findNestedVariables } = require('./find-nested-variables');
+
+// Define the regex pattern as used in the main function
+const regex = /\${((?!AWS|stageVariables)[ ~:a-zA-Z0-9=+!@#%*<>?._'",|\-\/\(\)\\]+?)}/g;
+
+test('findNestedVariables - simple variables', () => {
+  const input = '${simple}';
+  const result = findNestedVariables(input, regex);
+  
+  assert.equal(result.length, 1);
+  assert.equal(result[0].fullMatch, '${simple}');
+  assert.equal(result[0].variable, 'simple');
+  assert.equal(result[0].order, 1); 
+});
+
+test('findNestedVariables - complex variable with colon syntax', () => {
+  const input = '${opt:stage, dev}';
+  const result = findNestedVariables(input, regex);
+  
+  assert.equal(result.length, 1);
+  assert.equal(result[0].fullMatch, '${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);
+  
+  assert.equal(result.length, 2);
+  // The innermost variable should be found first
+  assert.equal(result[0].fullMatch, '${stage}');
+  assert.equal(result[0].variable, 'stage');
+  // Then the outer variable
+  assert.equal(result[1].fullMatch, '${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);
+  
+  assert.equal(result.length, 3);
+  // Innermost first
+  assert.equal(result[0].fullMatch, '${defaultStage}');
+  assert.equal(result[0].variable, 'defaultStage');
+  // Middle next
+  assert.equal(result[1].fullMatch, '${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].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);
+  
+  assert.equal(result.length, 2);
+  assert.equal(result[0].fullMatch, '${name}');
+  assert.equal(result[1].fullMatch, '${service}');
+});
+
+test('findNestedVariables - complex mixed case', () => {
+  const input = '${db.${envOne}.host}:${db.${envTwo}.port} using ${credentials.${user.role}}';
+  const result = findNestedVariables(input, regex, true);
+  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}');
+});
+
+test('findNestedVariables - empty string', () => {
+  const input = '';
+  const result = findNestedVariables(input, regex);
+  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);
+  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)
+  // Check varString property for the outermost variable
+  assert.equal(result[2].variable, 'file(./config.${opt:stage, ${defaultStage}}.json)');
+});
+
+// Run all tests
+test.run(); 

package/src/utils/splitByComma.js

@@ -1,6 +1,6 @@
-const { match } = require('../resolvers/valueFromString')
+const stringResolver = require('../resolvers/valueFromString')
 const overwriteSyntax = RegExp(/\s*(?:,\s*)+/g) // /\s*(?:,\s*)+/g
-const stringRefSyntax = match
+const stringRefSyntax = stringResolver.match
 /**
  * Split a given string by whitespace padded commas excluding those within single or double quoted
  * strings.
@@ -14,56 +14,68 @@ const stringRefSyntax = match
 // https://regex101.com/r/4uPmpt/1
 const commasOutsideOfParens = /(?!<(?:\(|\[)[^)\]]+),(?![^(\[]+(?:\)|\]))/
 // const commasOutOfParens = /(?!(?:\()[^)\]]+),(?![^(\[]+(?:\)))/g
-function splitByComma(string) {
-  // If comma is not outside of parens, return early,
-  // for file(file.js, param, paramTwo) & function support
-  // TODO clean this up
-  if (!string.match(commasOutsideOfParens)) {
-    return [ string ]
+function splitByComma(string, regexPattern) {
+  // Handle empty or undefined input
+  if (!string || string.trim() === "") {
+    return [""]
   }
-  const input = string.trim()
-  const stringMatches = []
-  let match = stringRefSyntax.exec(input)
-  while (match) {
-    stringMatches.push({
-      start: match.index,
-      end: stringRefSyntax.lastIndex,
+
+  // Extract regex patterns to protect them
+  const placeholders = []
+  let protectedString = string
+  if (regexPattern) {
+    protectedString = string.replace(regexPattern, (match) => {
+      placeholders.push(match)
+      return `__PLACEHOLDER_${placeholders.length - 1}__`
     })
-    match = stringRefSyntax.exec(input)
   }
-  const commaReplacements = []
-  const contained = (commaMatch) => { // curry the current commaMatch
-    return (stringMatch) => { // check whether stringMatch containing the commaMatch
-      return stringMatch.start < commaMatch.index && overwriteSyntax.lastIndex < stringMatch.end
+
+  const result = []
+  let current = ""
+  let inQuote = false
+  let quoteChar = ""
+  let bracketDepth = 0  // Includes both () and []
+  
+  for (let i = 0; i < protectedString.length; i++) {
+    const char = protectedString[i]
+    
+    // Handle quotes
+    if ((char === "'" || char === '"') && (i === 0 || protectedString[i-1] !== "\\")) {
+      if (!inQuote) {
+        inQuote = true
+        quoteChar = char
+      } else if (char === quoteChar) {
+        inQuote = false
+      }
     }
-  }
-  match = overwriteSyntax.exec(input)
-  while (match) {
-    const matchContained = contained(match)
-    const containedBy = stringMatches.find(matchContained)
-    if (!containedBy) { // if un-contained, this comma represents a splitting location
-      commaReplacements.push({
-        start: match.index,
-        end: overwriteSyntax.lastIndex,
-      })
+    
+    // Handle parentheses and brackets
+    if ((char === "(" || char === "[") && !inQuote) bracketDepth++
+    if ((char === ")" || char === "]") && !inQuote) bracketDepth--
+    
+    // Process comma
+    if (char === "," && !inQuote && bracketDepth === 0) {
+      result.push(current.trim())
+      current = ""
+    } else {
+      current += char
     }
-    match = overwriteSyntax.exec(input)
   }
-  let prior = 0
-  const results = []
-  commaReplacements.forEach((replacement) => {
-    results.push(input.slice(prior, replacement.start))
-    prior = replacement.end
+  
+  if (current.trim() || result.length > 0) {
+    result.push(current.trim())
+  }
+
+  if (!regexPattern) {
+    return result
+  }
+  
+  // Restore placeholders in the result
+  return result.map(item => {
+    return item.replace(/__PLACEHOLDER_(\d+)__/g, (match, index) => {
+      return placeholders[parseInt(index)]
+    })
   })
-  // const what = input.slice(prior)
-  // // TODO finish digit string matching
-  // const matchDigitString = /^['|"]\d+['|"]$/g
-  // if (what.match(matchDigitString)) {
-  //   console.log('Is digit string')
-  // }
-  // console.log('what', what)
-  results.push(input.slice(prior))
-  return results
 }
 
 module.exports = {

package/src/utils/splitByComma.test.js

@@ -0,0 +1,84 @@
+const { test } = require('uvu')
+const assert = require('uvu/assert')
+const { splitByComma } = require('./splitByComma')
+
+const variableSyntax = /\${((?!AWS|stageVariables)[ ~:a-zA-Z0-9=+!@#%*<>?._'",|\-\/\(\)\\]+?)}/g
+
+test('splitByComma - should return array with original string when no commas present', () => {
+  const result = splitByComma('singleString')
+  assert.equal(result, ['singleString'])
+})
+
+test('splitByComma - should split by comma and trim whitespace', () => {
+  const result = splitByComma('first, second, third')
+  assert.equal(result, ['first', 'second', 'third'])
+})
+
+test('splitByComma - should preserve quoted strings', () => {
+  const result = splitByComma("env:BAZ,'defaultEnvValue'")
+  assert.equal(result, ["env:BAZ", "'defaultEnvValue'"])
+})
+
+test('splitByComma - should not split commas inside parentheses', () => {
+  const result = splitByComma('file(file.js, param, paramTwo)')
+  assert.equal(result, ['file(file.js, param, paramTwo)'])
+})
+
+test('splitByComma - should not split commas inside square brackets', () => {
+  const result = splitByComma('array[item1, item2, item3]')
+  assert.equal(result, ['array[item1, item2, item3]'])
+})
+
+test('splitByComma - should handle multiple quoted strings', () => {
+  const result = splitByComma("'string one', 'string, with comma', \"double quoted\"")
+  assert.equal(result, ["'string one'", "'string, with comma'", "\"double quoted\""])
+})
+
+test('splitByComma - should handle empty input', () => {
+  const result = splitByComma('')
+  assert.equal(result, [''])
+})
+
+test('splitByComma - should handle input with extra whitespace', () => {
+  const result = splitByComma('  first  ,  second  ,  third  ')
+  assert.equal(result, ['first', 'second', 'third'])
+})
+
+test('splitByComma - should handle mixed scenarios', () => {
+  const result = splitByComma("normal, 'quoted, string', function(param1, param2)")
+  console.log('result', result)
+  assert.equal(result, ["normal", "'quoted, string'", "function(param1, param2)"])
+})
+
+test('splitByComma - should handle nested parentheses', () => {
+  const result = splitByComma('outer(inner(a, b), c)')
+  assert.equal(result, ['outer(inner(a, b), c)'])
+})
+
+test('splitByComma - should handle nested square brackets', () => {
+  const result = splitByComma('matrix[[1, 2], [3, 4]]')
+  assert.equal(result, ['matrix[[1, 2], [3, 4]]'])
+})
+
+test('splitByComma - should handle combination of parentheses and brackets', () => {
+  const result = splitByComma('func(array[1, 2], obj.method(a, b))')
+  assert.equal(result, ['func(array[1, 2], obj.method(a, b))'])
+})
+
+test('splitByComma - should handle escaped quotes in strings', () => {
+  const result = splitByComma("normal, 'string with \\'escaped\\' quotes', \"double \\\"escaped\\\" quotes\"")
+  assert.equal(result, ["normal", "'string with \\'escaped\\' quotes'", "\"double \\\"escaped\\\" quotes\""])
+})
+
+test('splitByComma - should handle complex nested structures', () => {
+  const result = splitByComma('func(arg1, {key: [1, 2], other: "value, with comma"}, callback())')
+  assert.equal(result, ['func(arg1, {key: [1, 2], other: "value, with comma"}, callback())'])
+})
+
+test('splitByComma - should handle backtick quotes', () => {
+  const result = splitByComma("normal, `template ${with, commas} inside`", variableSyntax)
+  assert.equal(result, ["normal", "`template ${with, commas} inside`"])
+})
+
+// Run all tests  
+test.run()