configorama 0.9.13 → 0.9.15

package/cli.js

@@ -225,7 +225,7 @@ configorama(inputFile, options)
       content: error.message,
       type: 'error',
     })
-    console.log(errorMsg)
+    console.error(errorMsg)
     if (argv.debug) {
       console.error('error', error)
     }

package/index.d.ts

@@ -124,6 +124,7 @@ declare namespace configorama {
     toml: any
     ini: any
     hcl: any
+    markdown: any
   }
 
   /** The Configorama class for advanced usage */

package/package.json

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

package/src/main.js

@@ -94,15 +94,15 @@ const deepPrefixReplacePattern = /(?:^deep:)\d+\.?/g
 // TODO update file regex ^file\((~?[a-zA-Z0-9._\-\/, ]+?)\)
 // To match file(asyncValue.js, lol) input params
 const selfRefSyntax = RegExp(/^self:/g)
-const base64WrapperRegex = /\[_\[([A-Za-z0-9+/=\s]*)\]_\]/g
 const logLines = '─────────────────────────────────────────────────'
+const evalIfPattern = /\b(eval|if)\s*\(/
+const functionPrefixPattern = /^> function /
 
 let DEBUG = process.argv.includes('--debug') ? true : false
 let VERBOSE = process.argv.includes('--verbose') ? true : false
 let SETUP_MODE = process.argv.includes('--setup') ? true : false
 // DEBUG = true
 let DEBUG_TYPE = false
-const ENABLE_FUNCTIONS = true
 
 class Configorama {
   constructor(fileOrObject, opts) {
@@ -562,7 +562,6 @@ class Configorama {
         }
         return assign({}, value, otherValue)
       },
-      math: () => {},
       upperKeys: (o) => {
         return Object.keys(o).reduce((c, k) => ((c[k.toUpperCase()] = o[k]), c), {}) // eslint-disable-line
       },
@@ -1235,8 +1234,7 @@ class Configorama {
     
       /* Exit early if list or info flag is set */
       if (showFoundVariables) {
-        // TODO re-enable this
-        // process.exit(0)
+        return Promise.resolve(this.config)
       }
     }
 
@@ -1262,7 +1260,7 @@ class Configorama {
       }
       const stage = cliOpts.stage || providerStage || process.env.NODE_ENV || 'dev'
       /* Load env variables into process.env */
-      const values = require('env-stage-loader')({
+      require('env-stage-loader')({
         // silent: true,
         // debug: true,
         env: stage,
@@ -1311,7 +1309,7 @@ class Configorama {
               if (typeof rawValue === 'string') {
                 // console.log('rawValue', rawValue)
                 /* Process inline functions like merge() */
-                if (ENABLE_FUNCTIONS && rawValue.match(/> function /)) {
+                if (rawValue.match(functionPrefixPattern)) {
                   // console.log('RAW FUNCTION', rawFunction)
                   const funcString = rawValue.replace(/> function /g, '')
                   // console.log('funcString', funcString)
@@ -2152,9 +2150,6 @@ class Configorama {
 
       historyEntry.match = matches[i].match
       historyEntry.variable = matches[i].variable
-      if (historyEntry.resultType === 'string' && historyEntry.result.match(/^>passthrough\[/)) {
-        historyEntry.variableType = 'encodedUnknown'
-      }
       if (resolverType) {
         historyEntry.variableType = resolverType
       }
@@ -2167,6 +2162,9 @@ class Configorama {
       }
 
       historyEntry.resultType = typeof finalResult
+      if (historyEntry.resultType === 'string' && typeof cleanResult === 'string' && cleanResult.match(/^>passthrough\[/)) {
+        historyEntry.variableType = 'encodedUnknown'
+      }
       historyEntry.valueBeforeResolution = valueBeforeResolution
       historyEntry.from = 'renderMatches'
       if (isDeepResult) {
@@ -2383,7 +2381,7 @@ class Configorama {
       }
     }
 
-    const originalSrc = valueObject.originalSource || ''
+    const originalSrc = (typeof valueObject.originalSource === 'string') ? valueObject.originalSource : ''
     const hasFilters = originalSrc.match(this.filterMatch)
     let foundFilters = []
     if (hasFilters) {
@@ -2485,7 +2483,7 @@ class Configorama {
 
       // For eval/if expressions, string values need quotes unless already quoted
       // BUT don't quote strings that contain variable refs (they need further resolution)
-      if (/\b(eval|if)\s*\(/.test(property) && !valueToPopulate.match(this.variableSyntax)) {
+      if (evalIfPattern.test(property) && !valueToPopulate.match(this.variableSyntax)) {
         const matchIdx = property.indexOf(currentMatchedString)
         const charBefore = matchIdx > 0 ? property[matchIdx - 1] : ''
         // Always escape quotes in values for eval/if context
@@ -2513,7 +2511,7 @@ class Configorama {
       if (DEBUG_TYPE) console.log('DEBUG_TYPE isObject')
 
       // For eval/if expressions, encode objects to avoid {} breaking variable syntax
-      const isEvalOrIf = /\b(eval|if)\s*\(/.test(property)
+      const isEvalOrIf = evalIfPattern.test(property)
       if (isEvalOrIf) {
         const encoded = encodeValueForEval(valueToPopulate)
         property = replaceAll(matchedString, encoded, property)
@@ -2550,12 +2548,12 @@ class Configorama {
       // console.log('other new prop', property)
 
     // partial replacement, boolean inside eval/if expressions
-    } else if (typeof valueToPopulate === 'boolean' && /\b(eval|if)\s*\(/.test(property)) {
+    } else if (typeof valueToPopulate === 'boolean' && evalIfPattern.test(property)) {
       if (DEBUG_TYPE) console.log('DEBUG_TYPE isBoolean in eval/if')
       property = replaceAll(matchedString, String(valueToPopulate), property)
 
     // partial replacement, null inside eval/if expressions
-    } else if (valueToPopulate === null && /\b(eval|if)\s*\(/.test(property)) {
+    } else if (valueToPopulate === null && evalIfPattern.test(property)) {
       if (DEBUG_TYPE) console.log('DEBUG_TYPE isNull in eval/if')
       property = replaceAll(matchedString, '__NULL__', property)
 
@@ -2655,13 +2653,13 @@ Missing Value ${missingValue} - ${matchedString}
       }
       
       // console.log('prop', prop)
-      if (property.match(/^> function /g) && prop) {
+      if (property.match(functionPrefixPattern) && prop) {
         // console.log('func prop', property)
         // console.log('Prop', prop)
       }
       const func = funcRegex.exec(property)
       // console.log('func', func)
-      if (func && property.match(/^> function /g)) {
+      if (func && property.match(functionPrefixPattern)) {
         /* IMPORTANT fix `finalProp` for nested function reference
           nestedOne: 'hi'
           nestedTwo: ${merge('nice', 'wow')}
@@ -2712,7 +2710,7 @@ Missing Value ${missingValue} - ${matchedString}
         /* if matches function signature like ${merge('foo', 'bar')}
           rewrite the variable to run the function after inputs resolved
         */
-        const rep = property.replace(/^> function /g, '')
+        const rep = property.replace(functionPrefixPattern, '')
         property = `> function ${rep}`
       }
       // if (prop.match(/\s\|/)) {
@@ -3624,7 +3622,7 @@ Missing Value ${missingValue} - ${matchedString}
       return variableString
     }
     // console.log('runFunction', variableString)
-    var hasFunc = funcRegex.exec(variableString)
+    const hasFunc = funcRegex.exec(variableString)
     // TODO finish Function handling. Need to move this down below resolver to resolve inner refs first
     // console.log('hasFunc', hasFunc)
     // Skip special expressions (cron, eval, if) - these aren't user functions

package/src/resolvers/valueFromEnv.js

@@ -1,3 +1,5 @@
+// Resolves values from process.env environment variables
+// Matches ${env:VAR_NAME} syntax with optional fallback values
 
 const envRefSyntax = RegExp(/^env:/g)
 
@@ -13,12 +15,7 @@ Example: \${env:MY_ENV_VAR}
 `)
   }
 
-  let valueToPopulate
-  if (requestedEnvVar !== '' || '' in process.env) {
-    valueToPopulate = process.env[requestedEnvVar]
-  } else {
-    valueToPopulate = process.env
-  }
+  const valueToPopulate = process.env[requestedEnvVar]
   return Promise.resolve(valueToPopulate)
 }
 

package/src/resolvers/valueFromFile.js

@@ -121,9 +121,9 @@ async function getValueFromFile(ctx, variableString, options) {
 
   // Get function input params if any supplied https://regex101.com/r/qlNFVm/1
   // var funcParamsRegex = /(\w+)\s*\(((?:[^()]+)*)?\s*\)\s*/g
-  var funcParamsRegex = /(\w+)\s*\(((?:[^()]+)*)?\s*\)/g
+  const funcParamsRegex = /(\w+)\s*\(((?:[^()]+)*)?\s*\)/g
   // tighter (?<![.\w-])\b(\w+)\s*\(((?:[^()]+)*)?\s*\)\s*
-  var hasParams = funcParamsRegex.exec(matchedFileString)
+  const hasParams = funcParamsRegex.exec(matchedFileString)
 
   let argsToPass = []
   if (hasParams) {
@@ -257,8 +257,8 @@ ${JSON.stringify(options.context, null, 2)}`,
   const variableFileContents = fs.readFileSync(fullFilePath, 'utf-8')
 
   /* handle case for referencing raw JS files to inline them */
-  if (argsToPass.length
-    && (argsToPass && argsToPass[0] && typeof argsToPass[0] === 'string' && argsToPass[0].toLowerCase() === 'raw')
+  if ((argsToPass.length
+    && argsToPass[0] && typeof argsToPass[0] === 'string' && argsToPass[0].toLowerCase() === 'raw')
     || opts.asRawText
   ) {
     // Encode foo() to foo__PH_PAREN_OPEN__) to avoid function collisions

package/src/resolvers/valueFromGit.js

@@ -10,6 +10,21 @@ const { findProjectRoot } = require('../utils/paths/findProjectRoot')
 const GIT_PREFIX = 'git'
 const gitVariableSyntax = RegExp(/^git:/g)
 
+/**
+ * Check if a directory is inside a git repository.
+ * @param {string} [dir] - Directory to check (defaults to process.cwd())
+ * @returns {boolean}
+ */
+function isGitRepo(dir) {
+  const start = dir || process.cwd()
+  try {
+    if (!fs.existsSync(start)) return false
+    return findProjectRoot(start) !== null
+  } catch (err) {
+    return false
+  }
+}
+
 /**
  * Execute a shell command
  * @param {string} cmd - Command to execute
@@ -45,6 +60,25 @@ async function _execFile(command, args, options = { timeout: 1000 }) {
   })
 }
 
+/**
+ * Run a git command and return undefined on failure. This lets the variable
+ * resolver fall through to user-provided fallbacks (e.g. `${git:branch, "main"}`)
+ * when not in a git repo, without surfacing raw `fatal: not a git repository`
+ * errors. When no fallback is provided, the outer resolver in main.js still
+ * produces a clear "Unable to resolve config variable" error pointing at the
+ * exact config path.
+ *
+ * @param {() => Promise<string>} cmdFn - Function that runs the git command
+ * @returns {Promise<string|undefined>}
+ */
+async function _safeGit(cmdFn) {
+  try {
+    return await cmdFn()
+  } catch (err) {
+    return undefined
+  }
+}
+
 // TODO denote computed fields in metadata
 /*
 {
@@ -83,14 +117,21 @@ function createResolver(cwd) {
     const variable = variableString.split(`${GIT_PREFIX}:`)[1]
     let value = null
     // console.log('createResolver variableString', variableString)
+
+    // If we're not inside a git repository, every git: variable resolves to
+    // undefined. This lets fallbacks like `${git:branch, "main"}` work, and
+    // when there's no fallback the outer resolver throws a clear "Unable to
+    // resolve config variable" error pointing at the config path.
+    if (!isGitRepo(cwd)) {
+      return undefined
+    }
+
     if (variable.match(/^remote/i)) {
       const hasParams = functionRegex.exec(variableString)
       const remoteName = (hasParams && hasParams[2]) ? formatFunctionArgs(hasParams[2]) : 'origin'
-      value = await getGitRemote(remoteName)
-      return value
+      return _safeGit(() => getGitRemote(remoteName))
     }
 
-    const verifyMsg = `Verify the cwd has a .git directory\n`
     const normalizedVar = (variable || '').toLowerCase()
     // console.log('normalizedVar', normalizedVar)
 
@@ -100,7 +141,7 @@ function createResolver(cwd) {
       const funcName = argsMatch[1]
       const args = argsMatch[2]
       if (funcName === 'timestamp' && args) {
-        value = await getGitTimestamp(args, cwd)
+        value = await getGitTimestamp(args, cwd, false)
       }
     }
 
@@ -109,55 +150,61 @@ function createResolver(cwd) {
       case GIT_KEYS.repo:
       case 'repository':
       case 'reposlug':
-      case 'repo-slug':
-        const urla = await getGitRemote()
+      case 'repo-slug': {
+        const urla = await _safeGit(() => getGitRemote())
+        if (!urla) return undefined
         const parseda = GitUrlParse(urla)
         value = parseda.full_name
-        break;
+        break
+      }
       // Repo name
       case GIT_KEYS.name:
       case 'reponame': // repoName
-      case 'repo-name':
-        value = await _exec('basename `git rev-parse --show-toplevel`')
-        break;
+      case 'repo-name': {
+        const toplevel = await _safeGit(() => _execFile('git', ['rev-parse', '--show-toplevel']))
+        if (!toplevel) return undefined
+        value = path.basename(toplevel)
+        break
+      }
       // Repo org or owner
       case GIT_KEYS.org:
       case 'owner':
       case 'organization':
       case 'repoowner': // repoOwner
-      case 'repo-owner':
-        const url = await getGitRemote()
+      case 'repo-owner': {
+        const url = await _safeGit(() => getGitRemote())
+        if (!url) return undefined
         const parsed = GitUrlParse(url)
         value = parsed.organization || parsed.owner
-        break;
+        break
+      }
       // Repo name
       case GIT_KEYS.dir:
       case 'directory':
       case 'dirpath': // dirPath
       case 'dir-path':
-      case 'dir_path':
-        const gitBasePath = await _exec('git rev-parse --show-toplevel')
+      case 'dir_path': {
+        const gitBasePath = await _safeGit(() => _execFile('git', ['rev-parse', '--show-toplevel']))
+        if (!gitBasePath) return undefined
         if (cwd) {
           const subPath = cwd.replace(gitBasePath, '')
-          const branch = await _exec('git rev-parse --abbrev-ref HEAD')
-          const url = await getGitRemote()
-          value = (subPath) ? `${url}/tree/${branch}${subPath}` : url
+          const branch = await _safeGit(() => _execFile('git', ['rev-parse', '--abbrev-ref', 'HEAD']))
+          const url = await _safeGit(() => getGitRemote())
+          if (!url) return undefined
+          value = (subPath && branch) ? `${url}/tree/${branch}${subPath}` : url
         }
-        break;
+        break
+      }
       // Repo url
       case GIT_KEYS.url:
       case 'repourl': // repoUrl
       case 'repo-url':
-        value = await getGitRemote()
-        break;
+        value = await _safeGit(() => getGitRemote())
+        break
       // Current commit sha
       case 'sha':
       case 'sha1':
-        try {
-          value = await _exec('git rev-parse --short HEAD')
-        } catch (err) {
-          throw new Error(`\${git:sha1} error ${verifyMsg}`)
-        }
+        value = await _safeGit(() => _execFile('git', ['rev-parse', '--short', 'HEAD']))
         break
       // Current commit full sha
       case GIT_KEYS.commit:
@@ -165,11 +212,7 @@ function createResolver(cwd) {
       case 'commit-sha':
       case 'commithash':
       case 'commit-hash':
-        try {
-          value = await _exec('git rev-parse HEAD')
-        } catch (err) {
-          throw new Error(`\${git:commit} error. ${verifyMsg}`)
-        }
+        value = await _safeGit(() => _execFile('git', ['rev-parse', 'HEAD']))
         break
       // Branches
       case GIT_KEYS.branch:
@@ -177,11 +220,7 @@ function createResolver(cwd) {
       case 'branch-name':
       case 'currentbranch': // currentBranch
       case 'current-branch':
-        try {
-          value = await _exec('git rev-parse --abbrev-ref HEAD')
-        } catch (err) {
-          throw new Error(`\${git:branch} error. ${verifyMsg}`)
-        }
+        value = await _safeGit(() => _execFile('git', ['rev-parse', '--abbrev-ref', 'HEAD']))
         break
       // Commit msg
       case GIT_KEYS.message:
@@ -190,42 +229,36 @@ function createResolver(cwd) {
       case 'commit-message':
       case 'commitmsg': // commitMsg
       case 'commit-msg':
-        try {
-          value = await _exec('git log -1 --pretty=%B')
-        } catch (err) {
-          throw new Error(`\${git:message} error. ${verifyMsg}`)
-        }
-        break;
+        value = await _safeGit(() => _execFile('git', ['log', '-1', '--pretty=%B']))
+        break
       // Git tags
       case GIT_KEYS.tag:
       case 'describe':
-        try {
-          value = await _exec('git describe --always')
-        } catch (err) {
-          throw new Error(`\${git:describeLight} error. ${verifyMsg}`)
-        }
-        break;
+        value = await _safeGit(() => _execFile('git', ['describe', '--always']))
+        break
       // Git tags
       case 'describeLight':
       case 'describelight':
       case 'describe-light':
-        try {
-          value = await _exec('git describe --always --tags')
-        } catch (err) {
-          throw new Error(`\${git:describeLight} error. ${verifyMsg}`)
-        }
-        break;
+        value = await _safeGit(() => _execFile('git', ['describe', '--always', '--tags']))
+        break
       // Is branch dirty
       case 'isDirty':
       case 'isdirty':
-      case 'is-dirty':
-        const writeTree = await _exec('git write-tree')
-        const changes = await _exec(`git diff-index ${writeTree} --`)
+      case 'is-dirty': {
+        const writeTree = await _safeGit(() => _execFile('git', ['write-tree']))
+        if (!writeTree) return undefined
+        const changes = await _safeGit(() => _execFile('git', ['diff-index', writeTree.trim(), '--']))
+        if (changes === undefined) return undefined
         value = `${changes.length > 0}`
         break
+      }
       default:
         if (!value) {
-          throw new Error(`Git variable ${variable} is unknown. Candidates are 'describe', 'describeLight', 'sha1', 'commit', 'branch', 'message', 'repository'`)
+          // Unknown variable name (likely a typo). This is a config error,
+          // not an environment one, so throw a helpful message listing the
+          // valid keys.
+          throw new Error(`Git variable "${variable}" is unknown. Valid options: ${Object.values(GIT_KEYS).join(', ')}`)
         }
     }
     return value
@@ -299,14 +332,19 @@ async function getGitTimestamp(_file, cwd, throwOnMissing = true) {
   }
 }
 
+const remoteCache = new Map()
+
 async function getGitRemote(name = 'origin') {
-  const remoteValues = await _exec('git remote -v')
+  if (remoteCache.has(name)) {
+    return remoteCache.get(name)
+  }
+  const remoteValues = await _execFile('git', ['remote', '-v'])
   const remotes = remoteValues.toString().split(os.EOL)
     .filter(function filterOnlyFetchRows(remote) {
       return remote.match('(fetch)')
     })
     .map(function mapRemoteLineToObject(remote) {
-      var parts = remote.split('\t')
+      const parts = remote.split('\t')
       if (parts.length < 2) {
         return
       }
@@ -326,7 +364,6 @@ async function getGitRemote(name = 'origin') {
 
   if (!originUrl) {
     throw new Error(`No git remote "${name}" found. Please double check your remote names`)
-    return
   }
   // console.log('originUrl', originUrl)
   const parsed = GitUrlParse(originUrl)
@@ -334,7 +371,9 @@ async function getGitRemote(name = 'origin') {
   // @TODO finish git api
   // console.log('parsed', parsed)
   if (parsed && parsed.source && parsed.full_name) {
-    return `https://${parsed.source}/${parsed.full_name}`
+    const result = `https://${parsed.source}/${parsed.full_name}`
+    remoteCache.set(name, result)
+    return result
   }
 }
 

package/src/resolvers/valueFromOptions.js

@@ -1,14 +1,10 @@
-
+// Resolves values from CLI option flags
+// Matches ${opt:FLAG_NAME} syntax with optional fallback values
 const optRefSyntax = RegExp(/^opt:/g)
 
 function getValueFromOptions(variableString, options) {
   const requestedOption = variableString.split(':')[1]
-  let valueToPopulate
-  if (requestedOption !== '' || '' in options) {
-    valueToPopulate = options[requestedOption]
-  } else {
-    valueToPopulate = options
-  }
+  const valueToPopulate = options[requestedOption]
   return Promise.resolve(valueToPopulate)
 }
 

package/src/resolvers/valueFromParam.js

@@ -1,4 +1,5 @@
-
+// Resolves values from named parameters
+// Matches ${param:KEY} syntax with optional fallback values
 const paramRefSyntax = RegExp(/^param:/g)
 
 /**

package/src/utils/lodash.js

@@ -67,34 +67,34 @@ function mapValues(obj, fn) {
  */
 function set(object, path, value) {
   if (object === null || typeof object !== 'object') {
-    return object;
+    return object
   }
-  
+
   const keys = Array.isArray(path) ? path : String(path)
     .split('.')
     .map(key => {
-      const numKey = Number(key);
-      return Number.isInteger(numKey) && numKey >= 0 ? numKey : key;
-    });
-  
-  let current = object;
-  const lastIndex = keys.length - 1;
-  
+      const numKey = Number(key)
+      return Number.isInteger(numKey) && numKey >= 0 ? numKey : key
+    })
+
+  let current = object
+  const lastIndex = keys.length - 1
+
   for (let i = 0; i < lastIndex; i++) {
     const key = keys[i]
-    
+
     // 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
       const nextKey = keys[i + 1]
       current[key] = Number.isInteger(nextKey) && /** @type {number} */ (nextKey) >= 0 ? [] : {}
     }
-    
+
     current = current[key]
   }
-  
-  current[keys[lastIndex]] = value;
-  return object;
+
+  current[keys[lastIndex]] = value
+  return object
 }
 
 // Cache for trim regex patterns (perf: avoid recompilation)
@@ -107,18 +107,18 @@ const trimRegexCache = new Map()
  */
 function trim(string, chars) {
   if (string === null || string === undefined) {
-    return '';
+    return ''
   }
 
-  string = String(string);
+  string = String(string)
 
   if (!chars && String.prototype.trim) {
-    return string.trim();
+    return string.trim()
   }
 
   if (!chars) {
     // Default characters to trim (whitespace)
-    chars = ' \t\n\r\f\v\u00a0\u1680\u2000\u200a\u2028\u2029\u202f\u205f\u3000\ufeff';
+    chars = ' \t\n\r\f\v\u00a0\u1680\u2000\u200a\u2028\u2029\u202f\u205f\u3000\ufeff'
   }
 
   // Check cache first
@@ -132,7 +132,7 @@ function trim(string, chars) {
 
   // Reset lastIndex for global regex reuse
   pattern.lastIndex = 0
-  return string.replace(pattern, '');
+  return string.replace(pattern, '')
 }
 
 module.exports = {

package/src/utils/parsing/parse.js

@@ -103,7 +103,7 @@ function parseFileContents({ contents, filePath, varRegex, dynamicArgs }) {
         configObject = jsFile(jsArgs)
       }
     } catch (err) {
-      throw new Error(err)
+      throw err
     }
   } else if (fileType.match(/\.(ts|tsx|mts|cts)/i)) {
     try {