configorama 0.9.14 → 0.9.16

package/src/metadata.js

@@ -0,0 +1,451 @@
+// Variable metadata collection — traverses config to catalog variable usage
+// Pure function that receives all data as arguments
+
+const path = require('path')
+const fs = require('fs')
+const traverse = require('traverse')
+const dotProp = require('dot-prop')
+const { normalizePath, extractFilePath, resolveInnerVariables } = require('./utils/paths/filePathUtils')
+const { findNestedVariables } = require('./utils/variables/findNestedVariables')
+const { splitOnPipe } = require('./utils/strings/splitOnPipe')
+
+/**
+ * Collect metadata about all variables found in the configuration
+ * @param {Object} params
+ * @param {RegExp} params.variableSyntax
+ * @param {Object} params.variablesKnownTypes
+ * @param {Object} params.variableTypes
+ * @param {RegExp|null} params.filterMatch
+ * @param {string} params.configFilePath
+ * @param {Object} params.displayConfig - rawOriginalConfig || originalConfig, used for traversal
+ * @param {Object} params.originalConfig - this.originalConfig, used for dotProp.get checks
+ * @param {string} params.varSuffix
+ * @param {RegExp} params.varSuffixWithSpacePattern
+ * @returns {Object} Metadata object containing variables, fileDependencies, and summary
+ */
+function collectVariableMetadata({
+  variableSyntax,
+  variablesKnownTypes,
+  variableTypes,
+  filterMatch,
+  configFilePath,
+  displayConfig,
+  originalConfig,
+  varSuffix,
+  varSuffixWithSpacePattern,
+}) {
+  const foundVariables = []
+  const variableData = {}
+  const fileRefs = []
+  const fileGlobPatterns = []
+  const preResolvedPaths = new Set()
+  const byConfigPath = []
+  const referencesMap = new Map()
+  let matchCount = 1
+
+  traverse(displayConfig).forEach(function (rawValue) {
+    if (typeof rawValue === 'string' && rawValue.match(variableSyntax)) {
+      const configValuePath = this.path.join('.')
+      /* Skip Fn::Sub variables */
+      if (configValuePath.endsWith('Fn::Sub')) {
+        return
+      }
+
+      const nested = findNestedVariables(
+        rawValue,
+        variableSyntax,
+        variablesKnownTypes,
+        configValuePath,
+        variableTypes
+      )
+
+      const lastItem = nested[nested.length - 1]
+      const lastKeyPath = this.path[this.path.length - 1]
+      const itemKey = (lastKeyPath.match(/[\d+]$/)) ? `${this.path[this.path.length - 2]}[${lastKeyPath}]` : lastKeyPath
+
+      // Extract filters from varMatch
+      const originalSrc = lastItem.varMatch || ''
+      const hasFilters = filterMatch && originalSrc.match(filterMatch)
+      let foundFilters = []
+      let keyWithoutFilters = originalSrc
+
+      if (hasFilters) {
+        // Extract filter names from the match (e.g., "| String}" -> ["String"])
+        const filterPart = hasFilters[0].replace(/}?$/, '') // Remove trailing }
+        foundFilters = splitOnPipe(filterPart)
+          .map((filter) => filter.trim())
+          .filter(Boolean)
+
+        // Remove filters from the key (replace "| String}" with suffix)
+        // Also clean up any trailing whitespace before the closing brace
+        keyWithoutFilters = originalSrc.replace(filterMatch, varSuffix).replace(varSuffixWithSpacePattern, varSuffix)
+      }
+
+      const key = keyWithoutFilters
+
+      // Helper to pre-resolve a variable from config
+      const preResolveFromConfig = (varString, varType) => {
+        if (!varString) return undefined
+        // Handle self: prefix
+        const varPath = varString.startsWith('self:') ? varString.slice(5) : varString
+        // Only pre-resolve dot.prop and self references
+        if (varType === 'dot.prop' || varType === 'self') {
+          const value = dotProp.get(displayConfig, varPath)
+          if (value !== undefined && typeof value !== 'object') {
+            return { resolved: value, path: varPath }
+          }
+        }
+        return undefined
+      }
+
+      // Strip filters from resolveDetails
+      const cleanedResolveDetails = nested.map(detail => {
+        const cleaned = { ...detail }
+        if (cleaned.varMatch && filterMatch) {
+          const match = cleaned.varMatch.match(filterMatch)
+          if (match) {
+            cleaned.varMatch = cleaned.varMatch.replace(filterMatch, '').replace(/\s+$/, '') + varSuffix
+          }
+        }
+        if (cleaned.variable && filterMatch) {
+          const match = cleaned.variable.match(filterMatch)
+          if (match) {
+            cleaned.variable = cleaned.variable.replace(filterMatch, '').replace(/\s+$/, '')
+          }
+        }
+        if (cleaned.varString && filterMatch) {
+          const match = cleaned.varString.match(filterMatch)
+          if (match) {
+            cleaned.varString = cleaned.varString.replace(filterMatch, '').trim()
+          }
+        }
+
+        // Pre-resolve dot.prop and self references
+        const preResolved = preResolveFromConfig(cleaned.varString || cleaned.variable, cleaned.variableType)
+        if (preResolved) {
+          cleaned.varResolved = preResolved.resolved
+          cleaned.varResolvedPath = preResolved.path
+        }
+
+        // Also clean fallbackValues if present
+        if (cleaned.fallbackValues && Array.isArray(cleaned.fallbackValues)) {
+          cleaned.fallbackValues = cleaned.fallbackValues.map(fb => {
+            const cleanedFb = { ...fb }
+            if (cleanedFb.varMatch && filterMatch) {
+              const match = cleanedFb.varMatch.match(filterMatch)
+              if (match) {
+                cleanedFb.varMatch = cleanedFb.varMatch.replace(filterMatch, '').trim()
+              }
+            }
+            if (cleanedFb.variable && filterMatch) {
+              const match = cleanedFb.variable.match(filterMatch)
+              if (match) {
+                cleanedFb.variable = cleanedFb.variable.replace(filterMatch, '').trim()
+              }
+            }
+            if (cleanedFb.stringValue && filterMatch) {
+              const match = cleanedFb.stringValue.match(filterMatch)
+              if (match) {
+                cleanedFb.stringValue = cleanedFb.stringValue.replace(filterMatch, '').trim()
+              }
+            }
+
+            // Pre-resolve fallback variable references
+            if (cleanedFb.stringValue && cleanedFb.stringValue.match(/^\$\{[^}]+\}$/)) {
+              const innerVar = cleanedFb.stringValue.slice(2, -1)
+              const fbPreResolved = preResolveFromConfig(innerVar, 'dot.prop')
+              if (fbPreResolved) {
+                cleanedFb.varResolved = fbPreResolved.resolved
+                cleanedFb.varResolvedPath = fbPreResolved.path
+              }
+            }
+
+            return cleanedFb
+          })
+        }
+        return cleaned
+      })
+
+      const varData = {
+        filters: foundFilters.length > 0 ? foundFilters : undefined,
+        path: configValuePath,
+        key: itemKey,
+        originalStringValue: rawValue,
+        variable: keyWithoutFilters,
+        variableWithFilters: originalSrc,
+        isRequired: false,
+        defaultValue: undefined,
+        defaultValueIsVar: undefined,
+        defaultValueSrc: undefined,
+        hasFallback: false,
+        matchIndex: matchCount++,
+        resolveOrder: [],
+        resolveDetails: cleanedResolveDetails,
+      }
+      let defaultValueIsVar = false
+
+      function calculateResolveOrder(item) {
+        // Helper to strip filters from variable strings
+        const stripFilters = (str) => {
+          if (!str || !filterMatch) return str
+          const match = str.match(filterMatch)
+          if (match) {
+            return str.replace(filterMatch, '').trim()
+          }
+          return str
+        }
+
+        if (item && item.fallbackValues) {
+          let hasResolvedFallback
+          let defaultValueSrc
+          const isSingleFallback = item.fallbackValues.length === 1
+          const order = ([stripFilters(item.valueBeforeFallback)]).concat(item.fallbackValues.map((f, i) => {
+            if (f.fallbackValues) {
+              const [nestedOrder, nestedResolvedFallback, nestedDefaultSrc] = calculateResolveOrder(f)
+              if (!hasResolvedFallback && nestedResolvedFallback) {
+                hasResolvedFallback = nestedResolvedFallback
+                defaultValueSrc = nestedDefaultSrc
+              }
+              return nestedOrder
+            }
+
+            const valueStr = stripFilters(f.stringValue || f.variable)
+
+            // Only set default from first resolvable fallback
+            if (!hasResolvedFallback && f.isResolvedFallback) {
+              if (f.varResolved !== undefined) {
+                hasResolvedFallback = f.varResolved
+                defaultValueSrc = f.varResolvedPath
+              } else if (!valueStr.match(/^\$\{[^}]+\}$/)) {
+                // Literal value - use as default
+                hasResolvedFallback = valueStr
+              }
+              // If variable can't resolve, don't set - let next fallback try
+            }
+
+            if (!hasResolvedFallback && f.isVariable) {
+              defaultValueIsVar = f
+            }
+
+            if (f.isResolvedFallback) {
+              if (isSingleFallback) {
+                // Single fallback: show "value (default)"
+                return `${valueStr} (default)`
+              } else {
+                // Multiple fallbacks: show resolved value if available
+                if (f.varResolved !== undefined) {
+                  return `${valueStr} = ${f.varResolved}`
+                }
+                // If can't resolve, just show the value without annotation
+                return valueStr
+              }
+            }
+            return valueStr
+          })).flat()
+
+          return [order, hasResolvedFallback, defaultValueSrc]
+        }
+        return [[stripFilters(item.variable)], undefined, undefined]
+      }
+
+      const lastCleanedItem = cleanedResolveDetails[cleanedResolveDetails.length - 1]
+      const [resolveOrder, hasResolvedFallback, defaultValueSrc] = calculateResolveOrder(lastCleanedItem)
+      varData.resolveOrder = resolveOrder
+
+      if (defaultValueIsVar) {
+        varData.defaultValueIsVar = defaultValueIsVar
+      }
+
+      if (typeof hasResolvedFallback !== 'undefined') {
+        varData.defaultValue = hasResolvedFallback
+      }
+
+      if (defaultValueSrc) {
+        varData.defaultValueSrc = defaultValueSrc
+      }
+
+      if (typeof varData.defaultValue === 'undefined') {
+        varData.isRequired = true
+      }
+
+      if (varData.resolveOrder.length > 1) {
+        varData.hasFallback = true
+      }
+
+      // Extract file references
+      nested.forEach((detail) => {
+        // console.log('detail', detail)
+        if (detail.variableType && (detail.variableType === 'file' || detail.variableType === 'text')) {
+          const extracted = extractFilePath(detail.variable)
+          if (extracted) {
+            const normalizedPath = normalizePath(extracted.filePath)
+            if (!normalizedPath) return
+
+            // Handle variables in file paths - just record the pattern
+            if (!fileRefs.includes(normalizedPath)) {
+              fileRefs.push(normalizedPath)
+            }
+
+            // Check if path contains variables and create glob pattern
+            const containsVariables = !!normalizedPath.match(variableSyntax)
+            let globPattern
+            if (containsVariables) {
+              // Replace variable syntax ${...} with * for glob pattern
+              globPattern = normalizedPath.replace(variableSyntax, '*')
+              if (!fileGlobPatterns.includes(globPattern)) {
+                fileGlobPatterns.push(globPattern)
+              }
+            }
+
+            // Try to pre-resolve inner variables from originalConfig
+            let resolvedPath = normalizedPath
+            let resolvedVarString = rawValue
+            if (containsVariables) {
+              const pathResult = resolveInnerVariables(normalizedPath, variableSyntax, displayConfig, dotProp.get)
+              const varStringResult = resolveInnerVariables(rawValue, variableSyntax, displayConfig, dotProp.get)
+
+              if (pathResult.didResolve) {
+                resolvedPath = normalizePath(pathResult.resolved) || pathResult.resolved
+                resolvedVarString = varStringResult.resolved
+                preResolvedPaths.add(resolvedPath)
+              }
+            }
+
+            // Build byConfigPath entry
+            const absolutePath = configFilePath
+              ? path.resolve(path.dirname(configFilePath), resolvedPath)
+              : resolvedPath
+            const fileExists = configFilePath ? fs.existsSync(absolutePath) : false
+
+            const configPathEntry = {
+              location: configValuePath,
+              filePath: absolutePath,
+              relativePath: resolvedPath,
+              originalVariableString: rawValue,
+              resolvedVariableString: resolvedVarString,
+              containsVariables,
+              exists: fileExists,
+            }
+            if (globPattern) {
+              configPathEntry.pattern = globPattern
+            }
+            byConfigPath.push(configPathEntry)
+
+            // Build references entry (use resolvedPath as key when available)
+            const refKey = resolvedPath
+            if (!referencesMap.has(refKey)) {
+              referencesMap.set(refKey, {
+                resolvedPath: refKey,
+                refs: [],
+              })
+            }
+            const refEntry = referencesMap.get(refKey)
+            refEntry.refs.push({
+              location: configValuePath,
+              value: normalizedPath,
+              originalVariableString: rawValue,
+            })
+          }
+        }
+      })
+
+      variableData[key] = (variableData[key] || []).concat(varData)
+      foundVariables.push(rawValue)
+    }
+  })
+
+  // Make foundVariables array unique
+  const finalFoundVariables = [...new Set(foundVariables)]
+  const varKeys = Object.keys(variableData)
+
+  // Calculate summary using same logic as CLI display
+  let requiredCount = 0
+  let withDefaultsCount = 0
+  varKeys.forEach((key) => {
+    const instances = variableData[key]
+    const firstInstance = instances[0]
+
+    // Extract variable name from key (e.g. "${self:service}" -> "self:service")
+    const keyVarName = key.slice(2, -1).split(',')[0].trim()
+
+    // Find the resolveDetail that matches THIS variable (not any self-ref in the string)
+    let matchingDetail = null
+    for (const instance of instances) {
+      if (instance.resolveDetails && instance.resolveDetails.length > 0) {
+        const found = instance.resolveDetails.find((detail) => {
+          const detailVar = detail.valueBeforeFallback || detail.variable
+          return detailVar === keyVarName
+        })
+        if (found && (found.variableType === 'dot.prop' || found.variableType === 'self')) {
+          matchingDetail = found
+          break
+        }
+      }
+    }
+
+    // Also check defaultValueIsVar
+    if (!matchingDetail && firstInstance.defaultValueIsVar && (
+      firstInstance.defaultValueIsVar.variableType === 'self:' ||
+      firstInstance.defaultValueIsVar.variableType === 'dot.prop'
+    )) {
+      matchingDetail = firstInstance.defaultValueIsVar
+    }
+
+    // Check if truly required
+    let isTrulyRequired = false
+    if (matchingDetail) {
+      // Check if the self-reference resolves to a value
+      // Use valueBeforeFallback if present (strips inline fallback like ", false")
+      const varPath = matchingDetail.valueBeforeFallback || matchingDetail.variable
+      const cleanPath = varPath.replace('self:', '')
+      const dotPropValue = dotProp.get(originalConfig, cleanPath)
+      if (typeof dotPropValue === 'undefined') {
+        isTrulyRequired = true
+      } else {
+        // Enrich ALL instances with resolved self-reference value (overrides inline fallbacks)
+        instances.forEach((instance) => {
+          instance.defaultValueSrc = cleanPath
+          instance.defaultValue = dotPropValue
+          instance.isRequired = false
+        })
+      }
+    } else if (typeof firstInstance.defaultValue === 'undefined') {
+      isTrulyRequired = true
+    }
+
+    // Update isRequired based on computed isTrulyRequired
+    instances.forEach((instance) => {
+      instance.isRequired = isTrulyRequired
+    })
+
+    if (isTrulyRequired) {
+      requiredCount++
+    } else {
+      withDefaultsCount++
+    }
+  })
+
+  return {
+    variables: variableData,
+    uniqueVariables: {},
+    fileDependencies: {
+      globPatterns: fileGlobPatterns,
+      // all: fileRefs,
+      dynamicPaths: fileRefs.filter(ref => ref.indexOf('*') !== -1 || ref.match(variableSyntax)),
+      // Resolved paths: static paths + pre-resolved dynamic paths
+      resolvedPaths: [
+        ...fileRefs.filter(ref => ref.indexOf('*') === -1 && !ref.match(variableSyntax)),
+        ...preResolvedPaths
+      ],
+      byConfigPath,
+      references: Array.from(referencesMap.values()),
+    },
+    summary: {
+      totalVariables: varKeys.length,
+      requiredVariables: requiredCount,
+      variablesWithDefaults: withDefaultsCount
+    },
+  }
+}
+
+module.exports = { collectVariableMetadata }

package/src/resolvers/valueFromGit.js

@@ -7,6 +7,7 @@ const GitUrlParse = require('git-url-parse')
 const { functionRegex } = require('../utils/regex')
 const formatFunctionArgs = require('../utils/strings/formatFunctionArgs')
 const { findProjectRoot } = require('../utils/paths/findProjectRoot')
+const BoundedMap = require('../utils/BoundedMap')
 const GIT_PREFIX = 'git'
 const gitVariableSyntax = RegExp(/^git:/g)
 
@@ -266,7 +267,7 @@ function createResolver(cwd) {
   return _getValueFromGit
 }
 
-const cache = new Map()
+const cache = new BoundedMap(200)
 
 /**
  * Gets the last Git commit timestamp for a file
@@ -332,7 +333,7 @@ async function getGitTimestamp(_file, cwd, throwOnMissing = true) {
   }
 }
 
-const remoteCache = new Map()
+const remoteCache = new BoundedMap(20)
 
 async function getGitRemote(name = 'origin') {
   if (remoteCache.has(name)) {

package/src/utils/BoundedMap.js

@@ -0,0 +1,25 @@
+// Bounded Map with FIFO eviction when capacity exceeded
+// Drop-in replacement for Map with get/set/has interface
+
+class BoundedMap {
+  constructor(maxSize = 100) {
+    this._map = new Map()
+    this._maxSize = maxSize
+  }
+  get(key) {
+    return this._map.get(key)
+  }
+  has(key) {
+    return this._map.has(key)
+  }
+  set(key, value) {
+    if (this._map.size >= this._maxSize && !this._map.has(key)) {
+      const firstKey = this._map.keys().next().value
+      this._map.delete(firstKey)
+    }
+    this._map.set(key, value)
+    return this
+  }
+}
+
+module.exports = BoundedMap

package/src/utils/BoundedMap.test.js

@@ -0,0 +1,91 @@
+/* eslint-disable no-template-curly-in-string */
+const { test } = require('uvu')
+const assert = require('uvu/assert')
+const BoundedMap = require('./BoundedMap')
+
+test('get returns undefined for missing key', () => {
+  const map = new BoundedMap(5)
+  assert.is(map.get('nope'), undefined)
+})
+
+test('set then get returns value', () => {
+  const map = new BoundedMap(5)
+  map.set('a', 1)
+  assert.is(map.get('a'), 1)
+})
+
+test('has returns true for existing, false for missing', () => {
+  const map = new BoundedMap(5)
+  map.set('a', 1)
+  assert.is(map.has('a'), true)
+  assert.is(map.has('b'), false)
+})
+
+test('set returns this for chaining', () => {
+  const map = new BoundedMap(5)
+  const ret = map.set('a', 1)
+  assert.is(ret, map)
+})
+
+test('evicts oldest entry when at maxSize', () => {
+  const map = new BoundedMap(3)
+  map.set('a', 1)
+  map.set('b', 2)
+  map.set('c', 3)
+  // At capacity — adding 'd' should evict 'a'
+  map.set('d', 4)
+  assert.is(map.has('a'), false, 'oldest entry should be evicted')
+  assert.is(map.get('b'), 2)
+  assert.is(map.get('c'), 3)
+  assert.is(map.get('d'), 4)
+})
+
+test('updating existing key does NOT evict', () => {
+  const map = new BoundedMap(3)
+  map.set('a', 1)
+  map.set('b', 2)
+  map.set('c', 3)
+  // Update existing key — no eviction should happen
+  map.set('a', 10)
+  assert.is(map.get('a'), 10)
+  assert.is(map.has('b'), true)
+  assert.is(map.has('c'), true)
+})
+
+test('eviction order is FIFO (insertion order)', () => {
+  const map = new BoundedMap(3)
+  map.set('a', 1)
+  map.set('b', 2)
+  map.set('c', 3)
+  map.set('d', 4) // evicts 'a'
+  map.set('e', 5) // evicts 'b'
+  assert.is(map.has('a'), false)
+  assert.is(map.has('b'), false)
+  assert.is(map.get('c'), 3)
+  assert.is(map.get('d'), 4)
+  assert.is(map.get('e'), 5)
+})
+
+test('constructor defaults to maxSize 100', () => {
+  const map = new BoundedMap()
+  // Fill to 100 — should be fine
+  for (let i = 0; i < 100; i++) {
+    map.set(`key${i}`, i)
+  }
+  assert.is(map.has('key0'), true)
+  // 101st entry evicts key0
+  map.set('overflow', 999)
+  assert.is(map.has('key0'), false)
+  assert.is(map.get('overflow'), 999)
+})
+
+test('maxSize of 1 works correctly', () => {
+  const map = new BoundedMap(1)
+  map.set('a', 1)
+  assert.is(map.get('a'), 1)
+  map.set('b', 2)
+  assert.is(map.has('a'), false)
+  assert.is(map.get('b'), 2)
+})
+
+test.run()

package/src/utils/parsing/parse.js

@@ -12,6 +12,50 @@ const cloudFormationSchema = require('./cloudformationSchema')
 
 const DEFAULT_VAR_SYNTAX = '\\${((?!AWS|stageVariables)[ ~:a-zA-Z0-9=+!@#%*<>?._\'",|\\-\\/\\(\\)\\\\]+?)}'
 
+const KNOWN_EXTENSIONS = new Set([
+  '.yml', '.yaml', '.json', '.json5', '.jsonc',
+  '.toml', '.tml', '.ini',
+  '.tf', '.hcl',
+  '.js', '.cjs', '.mjs', '.esm',
+  '.ts', '.tsx', '.mts', '.cts',
+  '.md', '.mdx', '.markdown', '.mdown', '.mkdn', '.mkd', '.mdwn', '.markdn', '.mdtxt', '.mdtext'
+])
+
+/**
+ * Detect config format from file contents when extension is missing
+ * @param {string} contents - Raw file contents
+ * @returns {string} Detected file extension (e.g. '.json', '.yml', '.toml')
+ */
+function detectFormat(contents) {
+  const trimmed = contents.trimStart()
+
+  // JSON object: starts with {
+  if (trimmed[0] === '{') return '.json'
+
+  // TOML section headers must be checked before JSON array (both start with [)
+  // TOML: [section.subsection] (dots distinguish from INI)
+  if (/^\[[\w-]+\.[\w.-]+\]/.test(trimmed)) return '.toml'
+  // TOML: array-of-tables [[section]]
+  if (/^\[\[[\w.-]+\]\]/.test(trimmed)) return '.toml'
+
+  // JSON array: starts with [ followed by non-word char (quotes, numbers, braces, whitespace)
+  if (trimmed[0] === '[') return '.json'
+
+  // TOML: multi-line strings
+  if (trimmed.startsWith('"""')) return '.toml'
+  // TOML: key = value
+  if (/^\w[\w.-]*\s*=\s/m.test(trimmed)) return '.toml'
+
+  // YAML: starts with document marker
+  if (trimmed.startsWith('---')) return '.yml'
+
+  // HCL: terraform keywords
+  if (/^(resource|variable|locals|provider|data|module|output|terraform)\s/.test(trimmed)) return '.tf'
+
+  // Default: YAML (most permissive parser)
+  return '.yml'
+}
+
 /**
  * @typedef {Object} ParseOptions
  * @property {string} contents - Raw file contents to parse
@@ -26,7 +70,13 @@ const DEFAULT_VAR_SYNTAX = '\\${((?!AWS|stageVariables)[ ~:a-zA-Z0-9=+!@#%*<>?._
  * @returns {Object} Parsed configuration object
  */
 function parseFileContents({ contents, filePath, varRegex, dynamicArgs }) {
-  const fileType = path.extname(filePath)
+  let fileType = path.extname(filePath)
+
+  // Content-based detection for extensionless or unrecognized files
+  if (!fileType || !KNOWN_EXTENSIONS.has(fileType.toLowerCase())) {
+    fileType = detectFormat(contents)
+  }
+
   const regex = varRegex || new RegExp(DEFAULT_VAR_SYNTAX, 'g')
   let configObject