configorama 0.6.13 → 0.6.14

package/package.json

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

package/src/resolvers/valueFromFile.js

@@ -4,7 +4,7 @@
 const fs = require('fs')
 const { trim } = require('../utils/lodash')
 const { splitCsv } = require('../utils/strings/splitCsv')
-const { resolveFilePathFromMatch } = require('../utils/paths/getFullFilePath')
+const { resolveFilePathFromMatch, resolveFilePath } = require('../utils/paths/getFullFilePath')
 const { findNestedVariables } = require('../utils/variables/findNestedVariables')
 const { makeBox } = require('@davidwells/box-logger')
 const { encodeJsSyntax } = require('../utils/encoders/js-fixes')
@@ -94,19 +94,48 @@ async function getValueFromFile(ctx, variableString, options) {
   const fileDetails = resolveFilePathFromMatch(matchedFileString, syntax, ctx.configPath)
   // console.log('fileDetails', fileDetails)
 
-  const { fullFilePath, resolvedPath, relativePath } = fileDetails
+  let { fullFilePath, resolvedPath, relativePath } = fileDetails
+
+  // Check for file path overrides
+  let wasOverridden = false
+  let originalFilePath = null
+  const filePathOverrides = ctx.opts && ctx.opts.filePathOverrides
+  if (filePathOverrides) {
+    // Try matching against relativePath (e.g., './env.yml')
+    const overrideKey = Object.keys(filePathOverrides).find((key) => {
+      // Normalize paths for comparison
+      const normalizedKey = key.replace(/^\.\//, '')
+      const normalizedRelPath = relativePath.replace(/^\.\//, '')
+      return normalizedKey === normalizedRelPath || key === relativePath
+    })
+
+    if (overrideKey) {
+      originalFilePath = fullFilePath
+      const overridePath = filePathOverrides[overrideKey]
+      // Resolve the override path (could be relative or absolute)
+      fullFilePath = resolveFilePath(overridePath, ctx.configPath)
+      resolvedPath = overridePath
+      wasOverridden = true
+    }
+  }
 
   const exists = fs.existsSync(fullFilePath)
 
-  ctx.fileRefsFound.push({
-    // location: options.context.path.join('.'),
+  const fileRefEntry = {
     filePath: fullFilePath,
     relativePath,
     resolvedVariableString: options.context.value,
     originalVariableString: options.context.originalSource,
     containsVariables: options.context.value !== options.context.originalSource,
     exists,
-  })
+  }
+
+  if (wasOverridden) {
+    fileRefEntry.wasOverridden = true
+    fileRefEntry.originalFilePath = originalFilePath
+  }
+
+  ctx.fileRefsFound.push(fileRefEntry)
 
   let fileExtension = resolvedPath.split('.')
 

package/src/utils/parsing/enrichMetadata.js

@@ -304,26 +304,37 @@ async function enrichMetadata(
     }
   }
 
+  // Add overrideFilePath to references if file was overridden
+  for (const refData of references) {
+    const details = fileDetailsMap.get(refData.resolvedPath)
+    if (details && details.wasOverridden) {
+      refData.overrideFilePath = details.filePath
+    }
+  }
+
   const byConfigPath = []
   if (references.length > 0) {
     for (const resolvedFileData of references) {
       const details = fileDetailsMap.get(resolvedFileData.resolvedPath)
       if (details) {
         for (const ref of resolvedFileData.refs) {
+          // Use original file path if overridden, otherwise use the resolved path
+          const filePath = details.wasOverridden ? details.originalFilePath : details.filePath
           const confDetails = {
             location: ref.location,
-            filePath: details.filePath,
+            filePath: filePath,
             relativePath: details.relativePath,
             originalVariableString: ref.originalVariableString,
             resolvedVariableString: details.resolvedVariableString,
             containsVariables: !!ref.hasInnerVariable,
             exists: details.exists,
-            // Get glob patterns from the individual ref, default to empty array
-            
           }
           if (ref.pattern) {
             confDetails.pattern = ref.pattern
           }
+          if (details.wasOverridden) {
+            confDetails.overrideFilePath = details.filePath
+          }
           byConfigPath.push(confDetails)
         }
       }
@@ -338,6 +349,25 @@ async function enrichMetadata(
     if (references.length > 0) {
       metadata.fileDependencies.references = references
     }
+
+    // Collect unique overridden files from fileRefsFound
+    const overriddenFilesMap = new Map()
+    for (const ref of fileRefsFound) {
+      if (ref.wasOverridden) {
+        // Use originalFilePath as key to dedupe
+        if (!overriddenFilesMap.has(ref.originalFilePath)) {
+          overriddenFilesMap.set(ref.originalFilePath, {
+            originalPath: ref.originalFilePath,
+            overridePath: ref.filePath,
+            relativePath: ref.relativePath,
+          })
+        }
+      }
+    }
+
+    if (overriddenFilesMap.size > 0) {
+      metadata.fileDependencies.overriddenFiles = Array.from(overriddenFilesMap.values())
+    }
   }
 
   // Build uniqueVariables rollup - group by base variable (without fallbacks)

package/src/utils/paths/getFullFilePath.js

@@ -29,7 +29,7 @@ function resolveFilePath(pathToResolve, basePath) {
   return fullFilePath
 }
 
-module.exports = function getFullPath(fileString, cwd) {
+function getFullPath(fileString, cwd) {
   const configPath = cwd || process.cwd()
   const relativePath = fileString.replace('~', os.homedir())
   return resolveFilePath(relativePath, configPath)
@@ -54,4 +54,6 @@ function resolveFilePathFromMatch(matchedFileString, syntax, configPath) {
   return { fullFilePath, resolvedPath, relativePath }
 }
 
+module.exports = getFullPath
 module.exports.resolveFilePathFromMatch = resolveFilePathFromMatch
+module.exports.resolveFilePath = resolveFilePath