configorama 0.6.12 → 0.6.13

package/src/utils/validation/warnIfNotFound.js

@@ -0,0 +1,52 @@
+/**
+ * Warns if a variable value is not found during resolution
+ */
+const isEmpty = require('lodash.isempty')
+
+function isValidValue(val) {
+  if (typeof val === 'object' && (val.hasOwnProperty('__internal_only_flag') || val.hasOwnProperty('__internal_metadata'))) {
+    return false
+  }
+  return val !== null && typeof val !== 'undefined' && !(typeof val === 'object' && isEmpty(val))
+}
+
+/**
+ * Check if variable resolved to valid value, log warning if not
+ * @param {string} variableString - The variable being resolved
+ * @param {*} valueToPopulate - The resolved value
+ * @param {object} options - Configuration options
+ * @param {object} options.patterns - Regex patterns for variable types
+ * @param {boolean} options.debug - Whether to log warnings
+ * @returns {*} The valueToPopulate unchanged
+ */
+function warnIfNotFound(variableString, valueToPopulate, options = {}) {
+  const { patterns = {}, debug = false } = options
+
+  let variableTypeText
+  if (patterns.env && variableString.match(patterns.env)) {
+    variableTypeText = 'environment variable'
+  } else if (patterns.opt && variableString.match(patterns.opt)) {
+    variableTypeText = 'option'
+  } else if (patterns.self && variableString.match(patterns.self)) {
+    variableTypeText = 'config attribute'
+  } else if (patterns.file && variableString.match(patterns.file)) {
+    variableTypeText = 'file'
+  } else if (patterns.deep && variableString.match(patterns.deep)) {
+    variableTypeText = 'deep'
+  } else if (patterns.text && variableString.match(patterns.text)) {
+    variableTypeText = 'text'
+  }
+
+  if (!isValidValue(valueToPopulate)) {
+    const notFoundMsg = `No ${variableTypeText} found to satisfy the '\${${variableString}}' variable. Attempting fallback value`
+    if (debug) {
+      console.log(notFoundMsg)
+    }
+  }
+  return valueToPopulate
+}
+
+module.exports = {
+  warnIfNotFound,
+  isValidValue
+}

package/src/utils/variables/appendDeepVariable.test.js

@@ -0,0 +1,41 @@
+const { test } = require('uvu')
+const assert = require('uvu/assert')
+const appendDeepVariable = require('./appendDeepVariable')
+
+test('appendDeepVariable - should append property to variable', () => {
+  const result = appendDeepVariable('${env:VAR}', 'subProp')
+  assert.equal(result, '${env:VAR.subProp}')
+})
+
+test('appendDeepVariable - should handle nested property', () => {
+  const result = appendDeepVariable('${self:config}', 'deep.nested.prop')
+  assert.equal(result, '${self:config.deep.nested.prop}')
+})
+
+test('appendDeepVariable - should handle variable with existing properties', () => {
+  const result = appendDeepVariable('${opt:stage.name}', 'region')
+  assert.equal(result, '${opt:stage.name.region}')
+})
+
+test('appendDeepVariable - should handle simple variable reference', () => {
+  const result = appendDeepVariable('${var}', 'prop')
+  assert.equal(result, '${var.prop}')
+})
+
+test('appendDeepVariable - should handle property with numbers', () => {
+  const result = appendDeepVariable('${obj}', 'prop123')
+  assert.equal(result, '${obj.prop123}')
+})
+
+test('appendDeepVariable - should handle property with underscores', () => {
+  const result = appendDeepVariable('${obj}', 'my_prop')
+  assert.equal(result, '${obj.my_prop}')
+})
+
+test('appendDeepVariable - should handle property with hyphens', () => {
+  const result = appendDeepVariable('${obj}', 'my-prop')
+  assert.equal(result, '${obj.my-prop}')
+})
+
+// Run all tests
+test.run()

package/src/utils/{cleanVariable.js → variables/cleanVariable.js}

@@ -1,5 +1,5 @@
-const { findNestedVariables } = require('./find-nested-variables')
-const { functionRegex } = require('./regex')
+const { findNestedVariables } = require('./findNestedVariables')
+const { functionRegex } = require('../regex')
 
 const DEBUG = false
 /**
@@ -84,31 +84,10 @@ module.exports = function cleanVariable(
 }
 
 
+const { findOutermostBraces: findOutermostBracesUtil } = require('../strings/bracketMatcher')
+
 function findOutermostBraces(str) {
-  const matches = []
-  let i = 0
-  
-  while (i < str.length) {
-    if (str.substring(i, i + 2) === '${') {
-      let braceCount = 1
-      let start = i
-      i += 2
-      
-      while (i < str.length && braceCount > 0) {
-        if (str[i] === '{') braceCount++
-        else if (str[i] === '}') braceCount--
-        i++
-      }
-      
-      if (braceCount === 0) {
-        matches.push(str.substring(start, i))
-      }
-    } else {
-      i++
-    }
-  }
-  
-  return matches
+  return findOutermostBracesUtil(str, '{', '}', '$')
 }
 
 /**

package/src/utils/{find-nested-variables.js → variables/findNestedVariables.js}

@@ -1,5 +1,5 @@
-const { splitByComma } = require('./splitByComma')
-const trimQuotes = require('./trimSurroundingQuotes')
+const { splitByComma } = require('../strings/splitByComma')
+const { trimSurroundingQuotes: trimQuotes } = require('../strings/quoteUtils')
 const { getVariableType } = require('./getVariableType')
 const FALLBACK_REGEX = /,\s*/
 const VAR_MATCH_REGEX = /__VAR_\d+__/

package/src/utils/{find-nested-variables.test.js → variables/findNestedVariables.test.js}

@@ -1,12 +1,12 @@
 const { test } = require('uvu');
 const assert = require('uvu/assert');
-const { findNestedVariables } = require('./find-nested-variables');
-const deepLog = require('./deep-log')
+const { findNestedVariables } = require('./findNestedVariables');
+const deepLog = require('../ui/deep-log')
 
 // Import resolvers to build variableTypes array
-const getValueFromEnv = require('../resolvers/valueFromEnv')
-const getValueFromOptions = require('../resolvers/valueFromOptions')
-const getValueFromGit = require('../resolvers/valueFromGit')
+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;

package/src/utils/variables/getVariableType.test.js

@@ -0,0 +1,109 @@
+const { test } = require('uvu')
+const assert = require('uvu/assert')
+const { getVariableType } = require('./getVariableType')
+
+// Tests without variableTypes array (fallback mode)
+test('getVariableType - should detect colon-based type', () => {
+  const result = getVariableType('env:VAR')
+  assert.equal(result, 'env')
+})
+
+test('getVariableType - should detect opt type', () => {
+  const result = getVariableType('opt:stage')
+  assert.equal(result, 'options')
+})
+
+test('getVariableType - should detect file type', () => {
+  const result = getVariableType('file:path/to/file.txt')
+  assert.equal(result, 'file')
+})
+
+test('getVariableType - should detect text type', () => {
+  const result = getVariableType('text:some content')
+  assert.equal(result, 'text')
+})
+
+test('getVariableType - should detect function type', () => {
+  const result = getVariableType('md5(input)')
+  assert.equal(result, 'function')
+})
+
+test('getVariableType - should return dot.prop for simple reference', () => {
+  const result = getVariableType('simple.property')
+  assert.equal(result, 'dot.prop')
+})
+
+test('getVariableType - should handle variable with ${} wrapper', () => {
+  const result = getVariableType('${env:VAR}')
+  assert.equal(result, 'env')
+})
+
+test('getVariableType - should handle custom type with colon', () => {
+  const result = getVariableType('custom:value')
+  assert.equal(result, 'custom')
+})
+
+test('getVariableType - should return dot.prop for no match', () => {
+  const result = getVariableType('noMatch')
+  assert.equal(result, 'dot.prop')
+})
+
+// Tests with variableTypes array
+test('getVariableType - should match regex in variableTypes', () => {
+  const variableTypes = [
+    { match: /^env:/, type: 'environment' },
+    { match: /^opt:/, type: 'option' }
+  ]
+  const result = getVariableType('env:VAR', variableTypes)
+  assert.equal(result, 'environment')
+})
+
+test('getVariableType - should match function matcher', () => {
+  const variableTypes = [
+    {
+      match: (str) => str.startsWith('custom:'),
+      type: 'custom-type'
+    }
+  ]
+  const result = getVariableType('custom:value', variableTypes)
+  assert.equal(result, 'custom-type')
+})
+
+test('getVariableType - should fallback to dot.prop with variableTypes', () => {
+  const variableTypes = [
+    { match: /^env:/, type: 'environment' }
+  ]
+  const result = getVariableType('simple.prop', variableTypes)
+  assert.equal(result, 'dot.prop')
+})
+
+test('getVariableType - should match first matching type', () => {
+  const variableTypes = [
+    { match: /^env:/, type: 'first' },
+    { match: /^env:/, type: 'second' }
+  ]
+  const result = getVariableType('env:VAR', variableTypes)
+  assert.equal(result, 'first')
+})
+
+test('getVariableType - should skip types without match property', () => {
+  const variableTypes = [
+    { type: 'no-match' },
+    { match: /^env:/, type: 'env-type' }
+  ]
+  const result = getVariableType('env:VAR', variableTypes)
+  assert.equal(result, 'env-type')
+})
+
+test('getVariableType - should handle regex with global flag', () => {
+  const variableTypes = [
+    { match: /^env:/g, type: 'environment' }
+  ]
+  const result1 = getVariableType('env:VAR1', variableTypes)
+  const result2 = getVariableType('env:VAR2', variableTypes)
+  assert.equal(result1, 'environment')
+  assert.equal(result2, 'environment')
+})
+
+// Run all tests
+test.run()

package/src/utils/variables/variableUtils.test.js

@@ -0,0 +1,117 @@
+const { test } = require('uvu')
+const assert = require('uvu/assert')
+const { getFallbackString, verifyVariable } = require('./variableUtils')
+
+// Tests for getFallbackString
+test('getFallbackString - should reconstruct variable from split array', () => {
+  const split = ['env:VAR', 'default']
+  const result = getFallbackString(split, 'default')
+  assert.equal(result, '${default}')
+})
+
+test('getFallbackString - should handle nested variable', () => {
+  const split = ['env:VAR', 'env:FALLBACK']
+  const result = getFallbackString(split, 'env:FALLBACK')
+  assert.equal(result, '${env:FALLBACK}')
+})
+
+test('getFallbackString - should include all items after nested var', () => {
+  const split = ['env:VAR', 'env:FALLBACK', 'final']
+  const result = getFallbackString(split, 'env:FALLBACK')
+  assert.equal(result, '${env:FALLBACK, final}')
+})
+
+test('getFallbackString - should handle first item as nested var', () => {
+  const split = ['env:VAR', 'default']
+  const result = getFallbackString(split, 'env:VAR')
+  assert.equal(result, '${env:VAR, default}')
+})
+
+test('getFallbackString - should clean existing ${} wrappers', () => {
+  const split = ['${env:VAR}', 'default']
+  // The function only matches if nestedVar equals the array element exactly
+  // So it reconstructs from the matched element, not from the beginning
+  const result = getFallbackString(split, '${env:VAR}')
+  // Since match is found, it creates from '${env:VAR}', 'default' -> ${env:VAR}, default}
+  // Then regex cleans wrappers: ${env:VAR}, default}
+  assert.equal(result, '${env:VAR}, default}')
+})
+
+// Tests for verifyVariable
+test('verifyVariable - should return true for valid regex variable', () => {
+  const variableTypes = [
+    { match: /^env:/ }
+  ]
+  const valueObject = { path: ['config', 'var'], originalSource: '${env:VAR}' }
+  const result = verifyVariable('env:VAR', valueObject, variableTypes)
+  assert.is(result, true)
+})
+
+test('verifyVariable - should return true for valid function matcher', () => {
+  const variableTypes = [
+    { match: (str) => str.startsWith('custom:') }
+  ]
+  const valueObject = { path: ['config'], originalSource: '${custom:value}' }
+  const result = verifyVariable('custom:value', valueObject, variableTypes)
+  assert.is(result, true)
+})
+
+test('verifyVariable - should return false for non-colon variable', () => {
+  const variableTypes = [
+    { match: /^env:/ }
+  ]
+  const valueObject = { path: ['config'], originalSource: '${simple.prop}' }
+  const result = verifyVariable('simple.prop', valueObject, variableTypes)
+  assert.is(result, false)
+})
+
+test('verifyVariable - should throw for invalid colon variable', () => {
+  const variableTypes = [
+    { match: /^env:/ }
+  ]
+  const valueObject = { path: ['config', 'var'], originalSource: '${invalid:VAR}' }
+
+  assert.throws(
+    () => verifyVariable('invalid:VAR', valueObject, variableTypes),
+    /invalid variable syntax/
+  )
+})
+
+test('verifyVariable - should include path in error message', () => {
+  const variableTypes = [
+    { match: /^env:/ }
+  ]
+  const valueObject = { path: ['config', 'nested', 'var'], originalSource: '${bad:VAR}' }
+
+  assert.throws(
+    () => verifyVariable('bad:VAR', valueObject, variableTypes),
+    /config\.nested\.var/
+  )
+})
+
+test('verifyVariable - should include original source in error', () => {
+  const variableTypes = [
+    { match: /^env:/ }
+  ]
+  const valueObject = { path: ['config'], originalSource: 'this is ${bad:VAR}' }
+
+  assert.throws(
+    () => verifyVariable('bad:VAR', valueObject, variableTypes),
+    /this is \$\{bad:VAR\}/
+  )
+})
+
+test('verifyVariable - should match with function and config param', () => {
+  const config = { stage: 'prod' }
+  const variableTypes = [
+    {
+      match: (str, cfg) => str.startsWith('stage:') && cfg.stage === 'prod'
+    }
+  ]
+  const valueObject = { path: ['config'], originalSource: '${stage:name}' }
+  const result = verifyVariable('stage:name', valueObject, variableTypes, config)
+  assert.is(result, true)
+})
+
+// Run all tests
+test.run()

package/src/utils/isValidValue.js

@@ -1,8 +0,0 @@
-const isEmpty = require('lodash.isempty')
-
-module.exports = function isValidValue(val) {
-  if (typeof val === 'object' && (val.hasOwnProperty('__internal_only_flag') || val.hasOwnProperty('__internal_metadata'))) {
-    return false
-  }
-  return val !== null && typeof val !== 'undefined' && !(typeof val === 'object' && isEmpty(val))
-}

package/src/utils/splitCsv.js

@@ -1,29 +0,0 @@
-/**
- * Split a string by comma while preserving quoted content
- * @param {string} str - String to split
- * @param {string} splitter - Optional custom splitter (defaults to ',')
- * @returns {string[]} Array of split strings
- */
-function splitCsv(str, splitter) {
-  const splitSyntax = splitter || ','
-  // Split at comma SPACE ", "
-  return str.split(splitSyntax).reduce(
-    (acc, curr) => {
-      if (acc.isConcatting) {
-        acc.soFar[acc.soFar.length - 1] += ',' + curr
-      } else {
-        acc.soFar.push(curr)
-      }
-      if (curr.split('"').length % 2 == 0) {
-        acc.isConcatting = !acc.isConcatting
-      }
-      return acc
-    },
-    {
-      soFar: [],
-      isConcatting: false,
-    },
-  ).soFar
-}
-
-module.exports = { splitCsv } 

package/src/utils/trimSurroundingQuotes.js

@@ -1,5 +0,0 @@
-module.exports = function trimQuotes(str = '') {
-  return str
-    .replace(/^(")([^"\n]*?)(\1)$/, "$2")
-    .replace(/^(')([^'\n]*?)(\1)$/, "$2")
-}