configorama 0.9.0 → 0.9.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "configorama",
-  "version": "0.9.0",
+  "version": "0.9.3",
   "description": "Variable support for configuration files",
   "main": "src/index.js",
   "types": "index.d.ts",

package/src/main.js

@@ -335,21 +335,25 @@ class Configorama {
         /** */
         /* its file ref so we need to shift lookup for self in nested files */
         if (valueObject.isFileRef) {
-          const exists = dotProp.get(fullObject, varString)
-          // console.log('fallThroughSelfMatcher exists', exists)
-          if (!exists) {
-            // @ Todo make recursive
-            const deepProperties = [valueObject.path[0]].concat(varString)
-            const dotPropPath = deepProperties.join('.')
-            const deeperExists = dotProp.get(fullObject, dotPropPath)
-            // console.log('fallThroughSelfMatcher deeper', deeperExists)
-            return deeperExists
+          // First check if property exists in the nested file's context (preferred)
+          const nestedPath = [valueObject.path[0]].concat(varString)
+          const nestedDotPath = nestedPath.join('.')
+          if (dotProp.has(fullObject, nestedDotPath)) {
+            // Property exists in nested context - return true to indicate match
+            // (actual value resolution happens in resolver, not here)
+            return true
           }
+          // Fall back to top-level lookup
+          if (dotProp.has(fullObject, varString)) {
+            return true
+          }
+          return false
         }
         // console.log('fallthrough fullObject', fullObject)
         /* is simple ${whatever} reference in same file */
         const startOf = varString.split('.')
-        return fullObject[startOf[0]]
+        // Use has() to properly check existence for falsy values
+        return dotProp.has(fullObject, startOf[0])
       },
       resolver: (varString, options, config, pathValue) => {
         /*
@@ -2893,7 +2897,7 @@ Missing Value ${missingValue} - ${matchedString}
             // Find the most recent call for this variableString
             for (let i = this.resolutionTracking[pathKey].calls.length - 1; i >= 0; i--) {
               if (this.resolutionTracking[pathKey].calls[i].variableString === variableString) {
-                const v = (typeof val === 'object' && val.__internal_only_flag) ? val.value : val
+                const v = (val && typeof val === 'object' && val.__internal_only_flag) ? val.value : val
                 this.resolutionTracking[pathKey].calls[i].resolvedValue = v
                 this.resolutionTracking[pathKey].calls[i].resolverType = resolverType
                 break
@@ -3264,14 +3268,14 @@ Missing Value ${missingValue} - ${matchedString}
 
     /* its file ref so we need to shift lookup for self in nested files */
     if (data.isFileRef) {
-      const dotPropPath = deepProperties.length > 1 ? deepProperties.join('.') : deepProperties[0]
-      const exists = dotProp.get(valueToPopulate, dotPropPath)
-      // console.log('self exists', exists)
-      if (!exists) {
-        // @ Todo make recursive
-        deepProperties = [data.path[0]].concat(deepProperties)
-        // console.log('self fixed deepProperties', deepProperties)
+      // First check if property exists in the nested file's context (preferred for file refs)
+      const nestedPath = [data.path[0]].concat(deepProperties)
+      const nestedDotPath = nestedPath.join('.')
+      if (dotProp.has(valueToPopulate, nestedDotPath)) {
+        // Property exists in nested context, prefer it over top-level
+        deepProperties = nestedPath
       }
+      // Otherwise, keep deepProperties as-is to try top-level lookup
     }
 
     return this.getDeeperValue(deepProperties, valueToPopulate).then((res) => {
@@ -3447,7 +3451,7 @@ Missing Value ${missingValue} - ${matchedString}
     })
   }
   runFunction(variableString) {
-    console.log('runFunction', variableString)
+    // console.log('runFunction', variableString)
     /* If json object value return it */
     if (variableString.match(/^\s*{/) && variableString.match(/}\s*$/)) {
       return variableString
@@ -3473,7 +3477,14 @@ Missing Value ${missingValue} - ${matchedString}
       // TODO fix how commas + spaces are ned
       const splitter = splitCsv(rawArgs, ', ')
       // console.log('splitter', splitter)
-      argsToPass = formatFunctionArgs(splitter)
+      // Recursively evaluate any nested function calls in arguments
+      const evaluatedArgs = splitter.map((arg) => {
+        if (typeof arg === 'string' && funcRegex.test(arg)) {
+          return this.runFunction(arg)
+        }
+        return arg
+      })
+      argsToPass = formatFunctionArgs(evaluatedArgs)
     }
     // console.log('argsToPass runFunction', argsToPass)
     // TODO check for camelCase version. | toUpperCase messes with function name

package/src/parsers/yaml.js

@@ -132,8 +132,8 @@ function preProcess(ymlStr = '') {
           if (txt.indexOf(`'${nested}'`) > -1) {
             return
           }
-          /* Replace variable wrapped in quotes */
-          fixedText = fixedText.replace(nested, `"${nested}"`)
+          /* Replace ALL occurrences of variable wrapped in quotes */
+          fixedText = fixedText.replaceAll(nested, `"${nested}"`)
         })
         ymlStr = ymlStr.replace(txt, fixedText)
       }
@@ -171,8 +171,8 @@ function preProcess(ymlStr = '') {
             if (txt.indexOf(`'${nested}'`) > -1) {
               return
             }
-            /* Replace variable wrapped in quotes */
-            fixedText = fixedText.replace(nested, `"${nested}"`)
+            /* Replace ALL occurrences of variable wrapped in quotes */
+            fixedText = fixedText.replaceAll(nested, `"${nested}"`)
           })
           ymlStr = ymlStr.replace(txt, fixedText)
         }

package/src/parsers/yaml.test.js

@@ -166,4 +166,56 @@ test('preProcess - should handle empty input', () => {
   assert.equal(result, '')
 })
 
+// ==========================================
+// Duplicate variable tests - Bug: String.replace() only replaces first occurrence
+// ==========================================
+
+test('preProcess - should wrap ALL duplicate variables in quotes within same array', () => {
+  const input = `
+items: [\${var:foo}, \${var:foo}, \${var:foo}]
+`
+  const result = preProcess(input)
+
+  // All three occurrences should be wrapped
+  const wrappedCount = (result.match(/"\$\{var:foo\}"/g) || []).length
+
+  assert.is(wrappedCount, 3, `Expected 3 wrapped occurrences, got ${wrappedCount}. Output: ${result}`)
+})
+
+test('preProcess - should wrap ALL duplicate variables in quotes within same object', () => {
+  const input = `
+config: {stage: \${env:STAGE}, region: \${env:STAGE}}
+`
+  const result = preProcess(input)
+
+  // Both occurrences should be wrapped
+  const wrappedCount = (result.match(/"\$\{env:STAGE\}"/g) || []).length
+
+  assert.is(wrappedCount, 2, `Expected 2 wrapped occurrences, got ${wrappedCount}. Output: ${result}`)
+})
+
+test('preProcess - should wrap duplicate variables mixed with unique variables in array', () => {
+  const input = `
+mixed: [\${env:FOO}, \${env:BAR}, \${env:FOO}]
+`
+  const result = preProcess(input)
+
+  const fooCount = (result.match(/"\$\{env:FOO\}"/g) || []).length
+  const barCount = (result.match(/"\$\{env:BAR\}"/g) || []).length
+
+  assert.is(fooCount, 2, `Expected 2 wrapped FOO occurrences, got ${fooCount}. Output: ${result}`)
+  assert.is(barCount, 1, `Expected 1 wrapped BAR occurrence, got ${barCount}. Output: ${result}`)
+})
+
+test('preProcess - should wrap duplicate variables in nested array structure', () => {
+  const input = `
+nested: [[\${opt:stage}, \${opt:stage}], [\${opt:stage}]]
+`
+  const result = preProcess(input)
+
+  const wrappedCount = (result.match(/"\$\{opt:stage\}"/g) || []).length
+
+  assert.is(wrappedCount, 3, `Expected 3 wrapped occurrences, got ${wrappedCount}. Output: ${result}`)
+})
+
 test.run() 

package/src/resolvers/valueFromFile.js

@@ -253,7 +253,19 @@ ${JSON.stringify(options.context, null, 2)}`,
   if (fileExtension === 'js' || fileExtension === 'cjs') {
     const jsFile = require(fullFilePath)
     const { moduleName } = parseModuleReference(variableString, matchedFileString)
-    const returnValueFunction = moduleName ? jsFile[moduleName] : jsFile
+    // For default export functions with :property syntax, keep the function and use deep properties
+    // For named exports (non-function module), look up the named export
+    let returnValueFunction = jsFile
+    let includeFirstProperty = false
+
+    if (moduleName && typeof jsFile === 'function') {
+      // Default export function with property access - include first property in path
+      returnValueFunction = jsFile
+      includeFirstProperty = true
+    } else if (moduleName) {
+      // Named export - look it up directly
+      returnValueFunction = jsFile[moduleName]
+    }
 
     return processExecutableFile({
       fileModule: jsFile,
@@ -264,7 +276,8 @@ ${JSON.stringify(options.context, null, 2)}`,
       matchedFileString,
       relativePath,
       fileType: 'javascript',
-      getDeeperValue: ctx.getDeeperValue
+      getDeeperValue: ctx.getDeeperValue,
+      includeFirstProperty
     })
   }
 

package/src/utils/encoders/unknown-values.js

@@ -20,7 +20,7 @@ function decodeUnknown(rawValue) {
   let val = rawValue.replace(PASSTHROUGH_PATTERN, '')
   if (x.length) {
     x.forEach(({ match, value }) => {
-      const decodedValue = Buffer.from(value, 'base64').toString('ascii')
+      const decodedValue = Buffer.from(value, 'base64').toString('utf8')
       val = val.replace(match, decodedValue)
     })
   }

package/src/utils/encoders/unknown-values.test.js

@@ -0,0 +1,146 @@
+/**
+ * Tests for unknown-values.js - encoding/decoding passthrough variables
+ * 
+ * These functions handle variables that cannot be resolved by Configorama
+ * but need to be passed through to external systems (like Serverless Dashboard).
+ */
+const { test } = require('uvu')
+const assert = require('uvu/assert')
+const {
+  encodeUnknown,
+  decodeUnknown,
+  findUnknownValues,
+  hasEncodedUnknown,
+  PASSTHROUGH_PATTERN
+} = require('./unknown-values')
+
+// ==========================================
+// encodeUnknown tests
+// ==========================================
+
+test('encodeUnknown - encodes string with passthrough wrapper', () => {
+  const result = encodeUnknown('${param:test}')
+  assert.ok(result.startsWith('>passthrough[_['))
+  assert.ok(result.endsWith(']_]'))
+})
+
+test('encodeUnknown - produces valid base64', () => {
+  const result = encodeUnknown('${param:test}')
+  const base64Part = result.replace('>passthrough[_[', '').replace(']_]', '')
+  // Should not throw
+  const decoded = Buffer.from(base64Part, 'base64').toString('utf8')
+  assert.is(decoded, '${param:test}')
+})
+
+// ==========================================
+// decodeUnknown tests - basic functionality
+// ==========================================
+
+test('decodeUnknown - decodes encoded value back to original', () => {
+  const input = '${param:simpleValue}'
+  const encoded = encodeUnknown(input)
+  const decoded = decodeUnknown(encoded)
+  assert.is(decoded, input)
+})
+
+test('decodeUnknown - handles multiple encoded values', () => {
+  const input1 = '${param:first}'
+  const input2 = '${param:second}'
+  const combined = `prefix ${encodeUnknown(input1)} middle ${encodeUnknown(input2)} suffix`
+  const decoded = decodeUnknown(combined)
+  assert.is(decoded, `prefix ${input1} middle ${input2} suffix`)
+})
+
+test('decodeUnknown - returns original string if no encoded values', () => {
+  const input = 'no encoded values here'
+  const result = decodeUnknown(input)
+  assert.is(result, input)
+})
+
+// ==========================================
+// decodeUnknown tests - UTF-8 support (bug fix)
+// ==========================================
+
+test('encodeUnknown/decodeUnknown - handles UTF-8 accented characters', () => {
+  const input = '${param:café}'
+  const encoded = encodeUnknown(input)
+  const decoded = decodeUnknown(encoded)
+  assert.is(decoded, input, 'UTF-8 accented characters should decode correctly')
+})
+
+test('encodeUnknown/decodeUnknown - handles UTF-8 emoji', () => {
+  const input = '${param:celebration-🎉}'
+  const encoded = encodeUnknown(input)
+  const decoded = decodeUnknown(encoded)
+  assert.is(decoded, input, 'UTF-8 emoji should decode correctly')
+})
+
+test('encodeUnknown/decodeUnknown - handles multi-byte UTF-8 characters (Japanese)', () => {
+  const input = '${param:日本語}'
+  const encoded = encodeUnknown(input)
+  const decoded = decodeUnknown(encoded)
+  assert.is(decoded, input, 'Multi-byte UTF-8 characters should decode correctly')
+})
+
+test('encodeUnknown/decodeUnknown - handles Chinese characters', () => {
+  const input = '${param:中文测试}'
+  const encoded = encodeUnknown(input)
+  const decoded = decodeUnknown(encoded)
+  assert.is(decoded, input, 'Chinese characters should decode correctly')
+})
+
+test('encodeUnknown/decodeUnknown - handles mixed ASCII and UTF-8', () => {
+  const input = '${param:hello-世界-🌍}'
+  const encoded = encodeUnknown(input)
+  const decoded = decodeUnknown(encoded)
+  assert.is(decoded, input, 'Mixed ASCII and UTF-8 should decode correctly')
+})
+
+test('encodeUnknown/decodeUnknown - handles special UTF-8 punctuation', () => {
+  const input = '${param:price-€100-£50}'
+  const encoded = encodeUnknown(input)
+  const decoded = decodeUnknown(encoded)
+  assert.is(decoded, input, 'UTF-8 currency symbols should decode correctly')
+})
+
+// ==========================================
+// findUnknownValues tests
+// ==========================================
+
+test('findUnknownValues - finds encoded values in text', () => {
+  const encoded = encodeUnknown('${param:test}')
+  const results = findUnknownValues(encoded)
+  assert.is(results.length, 1)
+  assert.ok(results[0].match.startsWith('[_['))
+  assert.ok(results[0].value.length > 0)
+})
+
+test('findUnknownValues - returns empty array for text without encoded values', () => {
+  const results = findUnknownValues('no encoded values')
+  assert.is(results.length, 0)
+})
+
+test('findUnknownValues - finds multiple encoded values', () => {
+  const text = `${encodeUnknown('${a}')} and ${encodeUnknown('${b}')}`
+  const results = findUnknownValues(text)
+  assert.is(results.length, 2)
+})
+
+// ==========================================
+// hasEncodedUnknown tests
+// ==========================================
+
+test('hasEncodedUnknown - returns true for encoded values', () => {
+  const encoded = encodeUnknown('${param:test}')
+  assert.is(hasEncodedUnknown(encoded), true)
+})
+
+test('hasEncodedUnknown - returns false for plain text', () => {
+  assert.is(hasEncodedUnknown('plain text'), false)
+})
+
+test('hasEncodedUnknown - returns false for regular variables', () => {
+  assert.is(hasEncodedUnknown('${param:test}'), false)
+})
+
+test.run()

package/src/utils/lodash.js

@@ -32,14 +32,15 @@ function set(object, path, value) {
   const lastIndex = keys.length - 1;
   
   for (let i = 0; i < lastIndex; i++) {
-    const key = keys[i];
+    const key = keys[i]
     
-    if (current[key] === undefined) {
+    // Check if value is undefined, null, or not an object (primitives can't have properties)
+    if (current[key] == null || typeof current[key] !== 'object') {
       // Create appropriate container based on next key type
-      current[key] = Number.isInteger(keys[i + 1]) && keys[i + 1] >= 0 ? [] : {};
+      current[key] = Number.isInteger(keys[i + 1]) && keys[i + 1] >= 0 ? [] : {}
     }
     
-    current = current[key];
+    current = current[key]
   }
   
   current[keys[lastIndex]] = value;

package/src/utils/lodash.test.js

@@ -0,0 +1,172 @@
+/**
+ * Tests for custom lodash utility implementations
+ */
+const { test } = require('uvu')
+const assert = require('uvu/assert')
+const { set, trim } = require('./lodash')
+
+// ==========================================
+// set() - basic functionality
+// ==========================================
+
+test('set - sets value at simple path', () => {
+  const obj = {}
+  set(obj, 'a', 'value')
+  assert.is(obj.a, 'value')
+})
+
+test('set - sets value at nested path', () => {
+  const obj = {}
+  set(obj, 'a.b.c', 'value')
+  assert.is(obj.a.b.c, 'value')
+})
+
+test('set - creates intermediate objects', () => {
+  const obj = {}
+  set(obj, 'a.b.c', 'value')
+  assert.type(obj.a, 'object')
+  assert.type(obj.a.b, 'object')
+})
+
+test('set - handles array path', () => {
+  const obj = {}
+  set(obj, ['a', 'b', 'c'], 'value')
+  assert.is(obj.a.b.c, 'value')
+})
+
+test('set - creates arrays for numeric keys', () => {
+  const obj = {}
+  set(obj, 'items.0.name', 'first')
+  assert.ok(Array.isArray(obj.items))
+  assert.is(obj.items[0].name, 'first')
+})
+
+test('set - overwrites existing value', () => {
+  const obj = { a: { b: 'old' } }
+  set(obj, 'a.b', 'new')
+  assert.is(obj.a.b, 'new')
+})
+
+test('set - returns the object', () => {
+  const obj = {}
+  const result = set(obj, 'a', 'value')
+  assert.is(result, obj)
+})
+
+test('set - returns object unchanged if object is null', () => {
+  const result = set(null, 'a.b', 'value')
+  assert.is(result, null)
+})
+
+test('set - returns object unchanged if object is primitive', () => {
+  const result = set('string', 'a.b', 'value')
+  assert.is(result, 'string')
+})
+
+// ==========================================
+// set() - null intermediate values (bug fix)
+// ==========================================
+
+test('set - overwrites null intermediate value with object', () => {
+  const obj = { a: null }
+  set(obj, 'a.b.c', 'value')
+  assert.type(obj.a, 'object')
+  assert.is(obj.a.b.c, 'value')
+})
+
+test('set - overwrites null at deeper level', () => {
+  const obj = { a: { b: null } }
+  set(obj, 'a.b.c', 'value')
+  assert.type(obj.a.b, 'object')
+  assert.is(obj.a.b.c, 'value')
+})
+
+// ==========================================
+// set() - primitive intermediate values (bug fix)
+// ==========================================
+
+test('set - overwrites string intermediate value', () => {
+  const obj = { a: 'string' }
+  set(obj, 'a.b.c', 'value')
+  assert.type(obj.a, 'object')
+  assert.is(obj.a.b.c, 'value')
+})
+
+test('set - overwrites number intermediate value', () => {
+  const obj = { a: 42 }
+  set(obj, 'a.b.c', 'value')
+  assert.type(obj.a, 'object')
+  assert.is(obj.a.b.c, 'value')
+})
+
+test('set - overwrites boolean intermediate value', () => {
+  const obj = { a: true }
+  set(obj, 'a.b.c', 'value')
+  assert.type(obj.a, 'object')
+  assert.is(obj.a.b.c, 'value')
+})
+
+test('set - overwrites false intermediate value', () => {
+  const obj = { a: false }
+  set(obj, 'a.b.c', 'value')
+  assert.type(obj.a, 'object')
+  assert.is(obj.a.b.c, 'value')
+})
+
+test('set - overwrites zero intermediate value', () => {
+  const obj = { a: 0 }
+  set(obj, 'a.b.c', 'value')
+  assert.type(obj.a, 'object')
+  assert.is(obj.a.b.c, 'value')
+})
+
+test('set - overwrites empty string intermediate value', () => {
+  const obj = { a: '' }
+  set(obj, 'a.b.c', 'value')
+  assert.type(obj.a, 'object')
+  assert.is(obj.a.b.c, 'value')
+})
+
+// ==========================================
+// set() - array handling with null/primitives
+// ==========================================
+
+test('set - creates array when overwriting null for numeric path', () => {
+  const obj = { items: null }
+  set(obj, 'items.0.name', 'value')
+  assert.ok(Array.isArray(obj.items))
+  assert.is(obj.items[0].name, 'value')
+})
+
+test('set - creates array when overwriting primitive for numeric path', () => {
+  const obj = { items: 'not an array' }
+  set(obj, 'items.0.name', 'value')
+  assert.ok(Array.isArray(obj.items))
+  assert.is(obj.items[0].name, 'value')
+})
+
+// ==========================================
+// trim() - basic functionality
+// ==========================================
+
+test('trim - removes whitespace from both ends', () => {
+  assert.is(trim('  hello  '), 'hello')
+})
+
+test('trim - handles null', () => {
+  assert.is(trim(null), '')
+})
+
+test('trim - handles undefined', () => {
+  assert.is(trim(undefined), '')
+})
+
+test('trim - removes custom characters', () => {
+  assert.is(trim('---hello---', '-'), 'hello')
+})
+
+test('trim - handles string with no trim needed', () => {
+  assert.is(trim('hello'), 'hello')
+})
+
+test.run()

package/src/utils/parsing/cloudformationSchema.js

@@ -6,6 +6,7 @@ const flatten = require('lodash.flatten');
 const map = require('lodash.map');
 
 const functionNames = [
+  // Standard intrinsic functions
   'And',
   'Base64',
   'Cidr',
@@ -23,6 +24,16 @@ const functionNames = [
   'Select',
   'Split',
   'Sub',
+  'Transform',
+  // AWS::LanguageExtensions functions
+  'ForEach',
+  'Length',
+  'ToJsonString',
+  // Rule-specific functions (valid in Rules section)
+  'EachMemberEquals',
+  'EachMemberIn',
+  'ValueOf',
+  'ValueOfAll',
 ];
 
 const yamlType = (name, kind) => {
@@ -31,8 +42,19 @@ const yamlType = (name, kind) => {
     kind,
     construct: data => {
       if (name === 'GetAtt') {
-        // special GetAtt dot syntax
-        return { [functionName]: isString(data) ? split(data, '.', 2) : data };
+        // special GetAtt dot syntax - split only at FIRST dot
+        // Attribute names can contain dots (e.g., Endpoint.Address, CertificateDetails.CAIdentifier)
+        if (isString(data)) {
+          const dotIndex = data.indexOf('.');
+          if (dotIndex === -1) {
+            return { [functionName]: [data] };
+          }
+          return { [functionName]: [
+            data.substring(0, dotIndex),      // Resource name (before first dot)
+            data.substring(dotIndex + 1)      // Attribute name (after first dot, may contain dots)
+          ]};
+        }
+        return { [functionName]: data };
       }
       return { [functionName]: data };
     },