configorama 0.6.3 → 0.6.5

package/src/main.js

@@ -13,16 +13,20 @@ const findUp = require('find-up')
 const traverse = require('traverse')
 const dotProp = require('dot-prop')
 const chalk = require('./utils/chalk')
+const { resolveAlias } = require('./utils/resolveAlias')
 
 /* Default Value resolvers */
 const getValueFromString = require('./resolvers/valueFromString')
 const getValueFromNumber = require('./resolvers/valueFromNumber')
 const getValueFromEnv = require('./resolvers/valueFromEnv')
 const getValueFromOptions = require('./resolvers/valueFromOptions')
+const getValueFromCron = require('./resolvers/valueFromCron')
+const getValueFromEval = require('./resolvers/valueFromEval')
 const createGitResolver = require('./resolvers/valueFromGit')
 /* Default File Parsers */
 const YAML = require('./parsers/yaml')
 const TOML = require('./parsers/toml')
+const INI = require('./parsers/ini')
 /* functions */
 const md5Function = require('./functions/md5')
 
@@ -44,14 +48,15 @@ const {
 const { parseFileContents } = require('./utils/parse')
 const { splitCsv } = require('./utils/splitCsv')
 const { replaceAll } = require('./utils/replaceAll')
-const { getTextAfterOccurance, findNestedVariable } = require('./utils/textUtils')
+const { getTextAfterOccurrence, findNestedVariable } = require('./utils/textUtils')
 const { getFallbackString, verifyVariable } = require('./utils/variableUtils')
 const { encodeUnknown, decodeUnknown } = require('./utils/unknownValues')
 const { mergeByKeys } = require('./utils/mergeByKeys')
 const { arrayToJsonPath } = require('./utils/arrayToJsonPath')
 const { findNestedVariables } = require('./utils/find-nested-variables')
-const { makeBox } = require('@davidwells/box-logger')
+const { makeBox, makeStackedBoxes } = require('@davidwells/box-logger')
 const { logHeader } = require('./utils/logs')
+const { createEditorLink } = require('./utils/createEditorLink')
 /**
  * Maintainer's notes:
  *
@@ -70,7 +75,7 @@ const deepRefSyntax = RegExp(/(\${)?deep:\d+(\.[^}]+)*()}?/)
 const deepIndexReplacePattern = new RegExp(/^deep:|(\.[^}]+)*$/g)
 const deepIndexPattern = /deep\:(\d*)/
 const deepPrefixReplacePattern = /(?:^deep:)\d+\.?/g
-const fileRefSyntax = RegExp(/^file\((~?[\{\}\:\$a-zA-Z0-9._\-\/,'" ]+?)\)/g)
+const fileRefSyntax = RegExp(/^file\((~?[@\{\}\:\$a-zA-Z0-9._\-\/,'" ]+?)\)/g)
 // TODO update file regex ^file\((~?[a-zA-Z0-9._\-\/, ]+?)\)
 // To match file(asyncValue.js, lol) input params
 const envRefSyntax = RegExp(/^env:/g)
@@ -104,8 +109,6 @@ class Configorama {
     if (opts && !opts.sync) {
       handleSignalEvents()
     }
-
-    const showFoundVariables = opts && opts.dynamicArgs && (opts.dynamicArgs.list || opts.dynamicArgs.info)
   
     const options = opts || {}
     // Set opts to pass into JS file calls
@@ -148,44 +151,16 @@ class Configorama {
       const fileDirectory = path.dirname(path.resolve(fileOrObject))
       const fileType = path.extname(fileOrObject)
 
-      // Parse file contents using extracted function
-      const configObject = parseFileContents(
-        fileContents, 
-        fileType, 
-        fileOrObject, 
-        varRegex, 
-        this.opts
-      )
-
       this.configFilePath = fileOrObject
-      // set config objects
-      this.config = configObject
+      // Set configFileType
+      this.configFileType = fileType
       // Keep a copy of the original file contents
       this.originalString = fileContents
-      // Keep a copy
-      this.originalConfig = cloneDeep(configObject)
-
-      const useDotEnv = this.originalConfig.useDotenv || this.originalConfig.useDotEnv
-      if ((useDotEnv && useDotEnv === true) || this.opts.useDotEnvFiles) {
-        const loadStageEnv = require('env-stage-loader')
-        let providerStage
-        if (this.originalConfig && this.originalConfig.provider && this.originalConfig.provider.stage) {
-          providerStage = this.originalConfig.provider.stage
-          // @TODO check value to see if variable and needs pre-resolving to resolve stage vars
-        }
-        const stage = this.opts.stage || providerStage || 'dev'
-        /* Load env variables into process.env */
-        const values = loadStageEnv({
-          // silent: true,
-          // debug: true,
-          env: stage,
-          // defaultEnv: 'prod',
-          // ignoreFiles: ['.env']
-        })
-      }
-
       // Set configPath for file references
       this.configPath = fileDirectory
+      // Initialize config as null - will be populated in init
+      this.config = null
+      this.originalConfig = null
     }
 
     // Track promise resolution
@@ -207,6 +182,23 @@ class Configorama {
        * ${opt:other, "fallbackValue"}
        */
       getValueFromOptions,
+
+      /**
+       * Cron expressions
+       * Usage:
+       * ${cron(every minute)}
+       * ${cron(weekdays)}
+       * ${cron(at 9:30)}
+       */
+      getValueFromCron,
+
+      /**
+       * Eval expressions
+       * Usage:
+       * ${eval(${self:valueTwo} > ${self:valueOne})}
+       */
+      getValueFromEval,
+
       /**
        * Self references
        * Usage:
@@ -284,6 +276,7 @@ class Configorama {
             return deeperExists
           }
         }
+        // console.log('fallthrough fullObject', fullObject)
         /* is simple ${whatever} reference in same file */
         const startOf = varString.split('.')
         return fullObject[startOf[0]]
@@ -308,8 +301,9 @@ class Configorama {
     this.variableTypes = this.variableTypes.concat(fallThroughSelfMatcher)
 
     // const variablesKnownTypes = new RegExp(`^(${this.variableTypes.map((v) => v.prefix || v.type).join('|')}):`)
-    const variablesKnownTypes = combineRegexes(this.variableTypes.filter((v) => v.type !== 'string').map((v) => v.match))
-    // console.log('variablesKnownTypes', variablesKnownTypes)
+    const variablesKnownTypes = combineRegexes(
+      this.variableTypes.filter((v) => v.type !== 'string').map((v) => v.match)
+    )
     this.variablesKnownTypes = variablesKnownTypes
 
     // this.allPatterns = combineRegexes(...this.variableTypes.map((v) => v.match))
@@ -430,6 +424,49 @@ class Configorama {
       this.functions = Object.assign({}, this.functions, options.functions)
     }
 
+    this.deep = []
+    this.leaves = []
+    this.callCount = 0
+  }
+
+  initialCall(func) {
+    this.deep = []
+    this.tracker.start()
+    return func().finally(() => {
+      this.tracker.stop()
+      this.deep = []
+    })
+  }
+
+  /**
+   * Populate all variables in the service, conveniently remove and restore the service attributes
+   * that confuse the population methods.
+   * @param cliOpts An options hive to use for ${opt:...} variables.
+   * @returns {Promise.<TResult>|*} A promise resolving to the populated service.
+   */
+  async init(cliOpts) {
+    this.options = cliOpts || {}
+    const configoramaOpts = this.opts
+
+    const showFoundVariables = configoramaOpts && configoramaOpts.dynamicArgs && (configoramaOpts.dynamicArgs.list || configoramaOpts.dynamicArgs.info)
+
+    // If we have a file path but no config yet, parse it now
+    if (this.configFilePath && !this.config) {
+      const configObject = await parseFileContents(
+        this.originalString,
+        this.configFileType,
+        this.configFilePath,
+        this.variableSyntax,
+        this.opts
+      )
+      this.configFileContents = ''
+      if (VERBOSE || showFoundVariables) {
+        this.configFileContents = fs.readFileSync(this.configFilePath, 'utf8')
+      }
+      this.config = configObject
+      this.originalConfig = cloneDeep(configObject)
+    }
+
     if (VERBOSE) {
       logHeader('Config Input before processing')
       console.log()
@@ -437,10 +474,14 @@ class Configorama {
       console.log()
     }
 
+    const variableSyntax = this.variableSyntax
+    const variablesKnownTypes = this.variablesKnownTypes
+
     if (VERBOSE || showFoundVariables) {
       const foundVariables = []
       const variableData = {}
       let matchCount = 1
+      // console.log('this.originalConfig', this.originalConfig)
       traverse(this.originalConfig).forEach(function (rawValue) {
         if (typeof rawValue === 'string' && rawValue.match(variableSyntax)) {
           const configValuePath = this.path.join('.')
@@ -472,45 +513,63 @@ class Configorama {
             resolveOrder: [],
             resolveDetails: nested,
           }
-
+          let defaultValueIsVar = false
           function calculateResolveOrder(item) {
             if (item && item.fallbackValues) {
               let hasResolvedFallback
+              // console.log('item.fallbackValues', item.fallbackValues)
               const order = ([item.valueBeforeFallback]).concat(item.fallbackValues.map((f, i) => {
+                // console.log('f', f)
                 if (f.fallbackValues) {
                   const [nestedOrder, nestedResolvedFallback] = calculateResolveOrder(f)
+                  // console.log('nestedOrder', nestedOrder)
+                  // console.log('nestedResolvedFallback', nestedResolvedFallback)
                   if (!hasResolvedFallback && nestedResolvedFallback) {
                     hasResolvedFallback = nestedResolvedFallback
                   }
                   return nestedOrder // Return just the order part
                 }
+        
                 if (!hasResolvedFallback && f.isResolvedFallback) {
                   hasResolvedFallback = f.stringValue
                 }
+                if (f.isResolvedFallback) {
+                  hasResolvedFallback = f.stringValue
+                }
+
+                if (!hasResolvedFallback && f.isVariable) {
+                  defaultValueIsVar = f
+                }
+                // console.log('hasResolvedFallback', hasResolvedFallback)
                 return `${f.stringValue || f.variable}${f.isResolvedFallback ? ' (Resolved default fallback)' : ''}`
               })).flat()
               
               return [order, hasResolvedFallback]
             }
-            return [[item.variable], false] // Return array instead of just the value
+            return [[item.variable], undefined] // Return array instead of just the value
           }
 
           const [resolveOrder, hasResolvedFallback] = calculateResolveOrder(lastItem)
           varData.resolveOrder = resolveOrder
           
-          if (hasResolvedFallback) {
-            varData.defaultValue = hasResolvedFallback
+          if (defaultValueIsVar) {
+            varData.defaultValueIsVar = defaultValueIsVar
           }
 
+          // console.log('hasResolvedFallback', hasResolvedFallback)
+          if (typeof hasResolvedFallback !== 'undefined') {
+            varData.defaultValue = hasResolvedFallback
+          }
 
-          if (!varData.defaultValue) {
+          // console.log('varData.defaultValue', varData.defaultValue)
+          if (typeof varData.defaultValue === 'undefined') {
             varData.isRequired = true
           }
       
-
           if (varData.resolveOrder.length > 1) {
             varData.hasFallback = true
           }
+          //console.log('varData', varData)
 
           variableData[key] = (variableData[key] || []).concat(varData)
 
@@ -518,7 +577,6 @@ class Configorama {
         }
       })
 
-
       if (!foundVariables.length) {
         logHeader('No Variables Found in Config')
         if (this.configFilePath) {
@@ -565,20 +623,35 @@ class Configorama {
         }
 
         logHeader('Variable Details')
+
+        const lines = this.configFileContents.split('\n')
+        // console.log('lines', lines)
     
         const indent = ''
-        varKeys.forEach((key, i) => {
+        const boxes = varKeys.map((key, i) => {
           const variableInstances = variableData[key]
+          // console.log('variableInstances', variableInstances)
       
           const firstInstance = variableInstances[0]
 
           let requiredText = ''
           let defaultValueSrc = ''
-          if (!firstInstance.defaultValue) {
+          if (typeof firstInstance.defaultValue === 'undefined') {
             // console.log('no default value', firstInstance)
+
+            let dotPropArr = []
+            if (firstInstance.defaultValueIsVar && (
+              firstInstance.defaultValueIsVar.varType === 'self:' ||
+              firstInstance.defaultValueIsVar.varType === 'dot.prop'
+            )) {
+              dotPropArr = [firstInstance.defaultValueIsVar]
+            }
             /* Check if the fallback variable is a self reference */
             const hasDotPropOrSelf = variableInstances.reduce((acc, v) => {
-              const dotProp = v.resolveDetails.find((d) => d.varType === 'dot.prop')
+              const dotProp = v.resolveDetails.find((d) => {
+                // console.log('d', d)
+                return d.varType === 'dot.prop'
+              })
               if (dotProp) {
                 acc.push(dotProp)
               }
@@ -587,10 +660,12 @@ class Configorama {
                 acc.push(v.resolveDetails[0])
               }
               return acc
-            }, [])
+            }, dotPropArr)
             // console.log('hasDotPropOrSelf', hasDotPropOrSelf)
+            
             if (!hasDotPropOrSelf.length) {
-              requiredText = '[Required] '
+              const debug = (false) ? JSON.stringify(firstInstance, null, 2) : ''
+              requiredText = `[Required Variable] ${debug}`
             } else {
               const fallBackValues = variableInstances.filter((v) => v.resolveDetails.find((d) => d.hasFallback)).map((v) => v.resolveDetails)
               // console.log('fallBackValues', fallBackValues)
@@ -609,6 +684,9 @@ class Configorama {
                 // truncate niceString to 100 characters
                 const truncatedString = niceString.length > 100 ? niceString.substring(0, 90) + '...' : niceString
                 firstInstance.defaultValue = truncatedString
+              } else {
+                deepLog('Missing default var', firstInstance)
+                throw new Error(`Variable misconfiguration at ${firstInstance.variable}\n\n"${hasDotPropOrSelf[0].variable}" resolves to undefined value.\n`)
               }
             }
             //this.originalConfig[key] = undefined
@@ -621,14 +699,16 @@ class Configorama {
           const keyChalk = chalk.whiteBright
           const valueChalk = chalk.hex(VALUE_HEX)
 
-          if (firstInstance.defaultValue) {
-            const defaultValueText = `${indent}${keyChalk(`DefaultValue:`.padEnd(titleText.length, ' '))}`
+          if (typeof firstInstance.defaultValue !== 'undefined') {
+            // console.log('firstInstance.defaultValue', firstInstance.defaultValue)
+            const defaultValueRender = firstInstance.defaultValue === '' ? '""' : firstInstance.defaultValue
+            const defaultValueText = `${indent}${keyChalk(`Default value:`.padEnd(titleText.length, ' '))}`
             // ensure padding is even 
-            varMsg += `${defaultValueText} ${valueChalk(firstInstance.defaultValue)}`
+            varMsg += `${defaultValueText} ${valueChalk(defaultValueRender)}`
           }
 
-          if(defaultValueSrc) {
-            varMsg += `\n${indent}${keyChalk('DefaultValue path:'.padEnd(titleText.length, ' '))} `
+          if (defaultValueSrc) {
+            varMsg += `\n${indent}${keyChalk('Default value path:'.padEnd(titleText.length, ' '))} `
             varMsg += `${valueChalk(defaultValueSrc)}`
           }
 
@@ -640,26 +720,34 @@ class Configorama {
 
           let locationRender = valueChalk(variableInstances[0].path)
   
-          let locationLabel = `${indent}${keyChalk('Used at:'.padEnd(titleText.length, ' '))}`
+          let locationLabel = `${indent}${keyChalk('Path:'.padEnd(titleText.length, ' '))}`
           if (variableInstances.length > 1) {
             locationRender = `\n${variableInstances.map((v) => valueChalk(`${indent}- ${v.path}`)).join('\n')}`
-            const locationLabelText = `${indent}${keyChalk('Used at:')}`
+            const locationLabelText = `${indent}${keyChalk('Paths:')}`
             locationLabel = locationLabelText
           }
 
           varMsg += `\n${locationLabel} ${locationRender}`
+
+          // find the match in our lines
+          const line = lines.findIndex((line) => line.includes(key))
+          const lineNumber = line + 1
     
           // console.log(` ${chalk.bold(key)}`)
-          console.log(makeBox(varMsg, {
-            title: `${key}`,
-            borderColor: 'gray',
-            // style: 'bold',
-            minWidth: 120,
-          }))
-          if(i < varKeys.length - 1) {
-            //console.log()
+          return {
+            text: varMsg,
+            title: {
+              left: `▶ ${lineNumber ? createEditorLink(this.configFilePath, lineNumber, 1, key) : key}`,
+              right: lineNumber ? createEditorLink(this.configFilePath, lineNumber, 1, `Line: ${lineNumber}`, 'gray') : '',
+            },
           }
         })
+
+        console.log(makeStackedBoxes(boxes, {
+          borderColor: 'gray',
+          minWidth: 120,
+          borderStyle: 'bold',
+        }))
       }
     
       /* Exit early if list or info flag is set */
@@ -668,33 +756,32 @@ class Configorama {
       }
     }
 
-    this.deep = []
-    this.callCount = 0
-  }
-
-  initialCall(func) {
-    this.deep = []
-    this.tracker.start()
-    return func().finally(() => {
-      this.tracker.stop()
-      this.deep = []
-    })
-  }
-
-  /**
-   * Populate all variables in the service, conveniently remove and restore the service attributes
-   * that confuse the population methods.
-   * @param cliOpts An options hive to use for ${opt:...} variables.
-   * @returns {Promise.<TResult>|*} A promise resolving to the populated service.
-   */
-  init(cliOpts) {
-    this.options = cliOpts || {}
-    const configoramaOpts = this.opts
     const originalConfig = this.originalConfig
 
     /* If no variables found just return early */
     if (this.originalString && !this.originalString.match(this.variableSyntax)) {
-      return Promise.resolve(originalConfig)
+      return Promise.resolve(this.originalConfig)
+    }
+
+    const useDotEnv = this.originalConfig.useDotenv || this.originalConfig.useDotEnv
+    if ((useDotEnv && useDotEnv === true) || this.opts.useDotEnvFiles) {
+      let providerStage
+      /* has hardcoded stage */
+      if (
+        this.originalConfig && this.originalConfig.provider && 
+        this.originalConfig.provider.stage && !this.originalConfig.provider.stage.match(this.variableSyntax)
+      ) {
+        providerStage = this.originalConfig.provider.stage
+      }
+      const stage = cliOpts.stage || providerStage || process.env.NODE_ENV || 'dev'
+      /* Load env variables into process.env */
+      const values = require('env-stage-loader')({
+        // silent: true,
+        // debug: true,
+        env: stage,
+        // defaultEnv: 'prod',
+        // ignoreFiles: ['.env']
+      })
     }
 
     /* Parse variables */
@@ -706,18 +793,28 @@ class Configorama {
             // console.log('Final Config', this.config)
             const transform = this.runFunction.bind(this)
             const varSyntax = this.variableSyntax
+            const leaves = this.leaves
+            // console.log('leaves two', leaves)
             // Traverse resolved object and run functions
             // console.log('this.config', this.config)
             traverse(this.config).forEach(function (rawValue) {
               /* Pass through unknown variables */
               if (!configoramaOpts.allowUndefinedValues && typeof rawValue === 'undefined') {
                 const configValuePath = this.path.join('.')
+                console.log(this.path)
                 const ogValue = dotProp.get(originalConfig, configValuePath)
                 const varDisplay = ogValue ? `"${ogValue}" variable` : 'variable'
+
+                const leaf = leaves.find((l) => l.path.join('.') === configValuePath)
+                // if (leaf) {
+                //   deepLog('leaf', leaf)
+                // }
                 const errorMessage = `
- Config error:
- "${configValuePath}" resolved to "undefined"
- Verify the ${varDisplay} in config at "${configValuePath}"`
+  Config error:\n
+  Path "${configValuePath}" resolved to "undefined".\n
+  Verify the ${varDisplay} in config at "${configValuePath}".\n
+  ${leaf ? `See:\n  ${leaf.originalValuePath}: ${leaf.originalSource} ` : ''}
+  ${leaf && leaf.isFileRef ? `\n  The error could be deeper in the referenced file at ${configValuePath.replace(leaf.originalValuePath, '').replace(/^\./, '')} key.\n` : ''}`
                 throw new Error(errorMessage)
               }
               if (typeof rawValue === 'string') {
@@ -782,7 +879,7 @@ class Configorama {
     var hasFunc = funcRegex.exec(variableString)
     // TODO finish Function handling. Need to move this down below resolver to resolve inner refs first
     // console.log('hasFunc', hasFunc)
-    if (!hasFunc) {
+    if (!hasFunc || hasFunc && (hasFunc[1] === 'cron' || hasFunc[1] === 'eval')) {
       return variableString
     }
     // test for object
@@ -880,12 +977,23 @@ class Configorama {
         value: current,
       }
       const thePath = leaf.path.length > 1 ? leaf.path.join('.') : leaf.path[0]
+      // console.log('thePath', thePath)
+      // console.log('this.originalConfig', this.originalConfig)
       let originalValue = dotProp.get(this.originalConfig, thePath)
       // TODO @DWELLS make recursive
       if (!originalValue) {
-        const parentArray = leaf.path.slice(0, -1)
-        const parentPath = parentArray > 1 ? parentArray.join('.') : parentArray[0]
-        originalValue = dotProp.get(this.originalConfig, parentPath)
+        // Recurse up the tree until we find a value
+        let currentPathArray = leaf.path.slice(0, -1)
+        while (currentPathArray.length > 0 && !originalValue) {
+          const currentPath = currentPathArray.length > 1 ? currentPathArray.join('.') : currentPathArray[0]
+          // console.log('checking parent path:', currentPath)
+          originalValue = dotProp.get(this.originalConfig, currentPath)
+          if (typeof originalValue !== 'undefined') {
+            leaf.originalValuePath = currentPath
+            leaf.currentConfig = this.config
+          }
+          currentPathArray = currentPathArray.slice(0, -1)
+        }
       }
       leaf.originalSource = originalValue
       if (originalValue && isString(originalValue)) {
@@ -912,11 +1020,27 @@ class Configorama {
    */
   populateVariables(properties) {
     // console.log('properties', properties)
-    const variables = properties.filter((property) => {
+    let variables = properties.filter((property) => {
       // Initial check if value has variable string in it
       return isString(property.value) && property.value.match(this.variableSyntax)
     })
 
+    /*
+    console.log(`variables at call count ${this.callCount}`, variables)
+    /** */
+
+    /* Exclude git messages from being processed */
+    // Was failing on git msgs like "xyz cron:pattern to cron(pattern) for improved clarity"
+    if (this.callCount > 1) {
+      // filter out git vars
+      variables = variables.filter(property => {
+        if (property.originalSource && typeof property.originalSource === 'string') {
+          return !property.originalSource.startsWith('${git:')
+        }
+        return true
+      })
+    }
+
     return map(variables, (valueObject) => {
       // console.log('valueObject', valueObject)
       return this.populateValue(valueObject, false, '_populateVariables').then((populated) => {
@@ -958,6 +1082,7 @@ class Configorama {
     }
 
     const leaves = this.getProperties(objectToPopulate, true, objectToPopulate)
+    this.leaves = leaves
     // console.log('leaves', leaves)
     const populations = this.populateVariables(leaves)
     // console.log("FILL LEAVES", populations)
@@ -1301,7 +1426,19 @@ Missing Value ${missingValue} - ${matchedString}
 
     if (property && typeof property === 'string') {
       // console.log('property', property)
-      const prop = cleanVariable(property, this.variableSyntax, true, `populateVariable string ${this.callCount}`)
+      let prop = cleanVariable(
+        property, 
+        this.variableSyntax, 
+        true, 
+        `populateVariable string ${this.callCount}`,
+        // true // recursive
+      )
+      
+      // Double processing needed for `${eval(${self:three} > ${self:four})}`
+      if (prop.startsWith('${')) {
+        prop = cleanVariable(prop, this.variableSyntax, true, `populateVariable string ${this.callCount}`)
+      }
+      
       // console.log('prop', prop)
       if (property.match(/^> function /g) && prop) {
         // console.log('func prop', property)
@@ -1340,7 +1477,10 @@ Missing Value ${missingValue} - ${matchedString}
       }
       */
       // Does not match file refs with nested vars + args
-      if (!prop.match(/file\((~?[a-zA-Z0-9._\-\/,'"\{\}\.$: ]+?)\)/) && func) {
+      // @TODO fix this for eval refs
+      // console.log('prop', prop)
+      // console.log('func', func)
+      if (!prop.match(fileRefSyntax) && !prop.match(getValueFromEval.match) && func) {
         // console.log('IS FUNCTION')
         /* if matches function signature like ${merge('foo', 'bar')}
           rewrite the variable to run the function after inputs resolved
@@ -1491,7 +1631,7 @@ Missing Value ${missingValue} - ${matchedString}
     if (filters) {
       const string = cleanVariable(propertyString, this.variableSyntax, true, `getValueFromSrc filter ${this.callCount}`)
       // console.log('string', string)
-      const deeperValue = getTextAfterOccurance(string, variableString)
+      const deeperValue = getTextAfterOccurrence(string, variableString)
       // console.log('deeperValue', deeperValue)
       // console.log('filters', filters)
       // console.log('variableString', variableString)
@@ -1844,7 +1984,7 @@ Unable to resolve configuration variable
       return res
     })
   }
-  getValueFromFile(variableString) {
+  async getValueFromFile(variableString) {
     // console.log('From file', `"${variableString}"`)
     let matchedFileString = variableString.match(fileRefSyntax)[0]
     // console.log('matchedFileString', matchedFileString)
@@ -1875,7 +2015,11 @@ Unable to resolve configuration variable
       matchedFileString.replace(fileRefSyntax, (match, varName) => varName.trim()).replace('~', os.homedir()),
     )
 
-    let fullFilePath = path.isAbsolute(relativePath) ? relativePath : path.join(this.configPath, relativePath)
+    // Resolve alias if the path contains alias syntax
+    const resolvedPath = resolveAlias(relativePath, this.configPath)
+    // console.log('resolvedPath', resolvedPath)
+
+    let fullFilePath = path.isAbsolute(resolvedPath) ? resolvedPath : path.join(this.configPath, resolvedPath)
 
     // console.log('fullFilePath', fullFilePath)
 
@@ -1884,13 +2028,13 @@ Unable to resolve configuration variable
       fullFilePath = fs.realpathSync(fullFilePath)
 
       // Only match files that are relative
-    } else if (relativePath.match(/\.\//)) {
+    } else if (resolvedPath.match(/\.\//)) {
       // TODO test higher parent refs
-      const cleanName = path.basename(relativePath)
+      const cleanName = path.basename(resolvedPath)
       fullFilePath = findUp.sync(cleanName, { cwd: this.configPath })
     }
 
-    let fileExtension = relativePath.split('.')
+    let fileExtension = resolvedPath.split('.')
 
     fileExtension = fileExtension[fileExtension.length - 1]
 
@@ -1940,6 +2084,7 @@ Check if your javascript is exporting a function that returns a value.`
         config: this.config,
         opts: this.opts,
       }
+      
 
       valueToPopulate = returnValueFunction.call(jsFile, valueForFunction, ...argsToPass)
 
@@ -1962,8 +2107,115 @@ Check if your javascript is returning the correct data.`
       })
     }
 
-    // Process everything except JS
-    if (fileExtension !== 'js') {
+
+    if (fileExtension === 'ts') {
+      const { executeTypeScriptFile } = require('./parsers/typescript')
+      let returnValueFunction
+      const variableArray = variableString.split(':')
+
+      try {
+        const tsFile = await executeTypeScriptFile(fullFilePath, { dynamicArgs: () => argsToPass })
+        // console.log('fullFilePath', fullFilePath)
+        // console.log('tsFile', tsFile)
+        returnValueFunction = tsFile.config || tsFile.default || tsFile
+
+        if (variableArray[1]) {
+          let tsModule = variableArray[1]
+          tsModule = tsModule.split('.')[0]
+          returnValueFunction = tsFile[tsModule]
+        }
+
+        if (typeof returnValueFunction !== 'function') {
+          const errorMessage = `Invalid variable syntax when referencing file "${relativePath}".
+Check if your TypeScript is exporting a function that returns a value.`
+          return Promise.reject(new Error(errorMessage))
+        }
+
+        const valueForFunction = {
+          originalConfig: this.originalConfig,
+          config: this.config,
+          opts: this.opts,
+        }
+
+        valueToPopulate = returnValueFunction.call(tsFile, valueForFunction, ...argsToPass)
+
+        return Promise.resolve(valueToPopulate).then((valueToPopulateResolved) => {
+          let deepProperties = variableString.replace(matchedFileString, '')
+          deepProperties = deepProperties.slice(1).split('.')
+          deepProperties.splice(0, 1)
+          // Trim prop keys for starting/trailing spaces
+          deepProperties = deepProperties.map((prop) => {
+            return trim(prop)
+          })
+          return this.getDeeperValue(deepProperties, valueToPopulateResolved).then((deepValueToPopulateResolved) => {
+            if (typeof deepValueToPopulateResolved === 'undefined') {
+              const errorMessage = `Invalid variable syntax when referencing file "${relativePath}".
+Check if your TypeScript is returning the correct data.`
+              return Promise.reject(new Error(errorMessage))
+            }
+            return Promise.resolve(deepValueToPopulateResolved)
+          })
+        })
+      } catch (err) {
+        return Promise.reject(new Error(`Error processing TypeScript file: ${err.message}`))
+      }
+    }
+
+    if (fileExtension === 'mjs' || fileExtension === 'esm') {
+      const { executeESMFile } = require('./parsers/esm')
+      let returnValueFunction
+      const variableArray = variableString.split(':')
+
+      try {
+        const esmFile = await executeESMFile(fullFilePath, { dynamicArgs: () => argsToPass })
+        // console.log('ESM fullFilePath', fullFilePath)
+        // console.log('ESM esmFile', esmFile, 'type:', typeof esmFile)
+        returnValueFunction = esmFile.config || esmFile.default || esmFile
+
+        if (variableArray[1]) {
+          let esmModule = variableArray[1]
+          esmModule = esmModule.split('.')[0]
+          returnValueFunction = esmFile[esmModule]
+        }
+
+        if (typeof returnValueFunction !== 'function') {
+          const errorMessage = `Invalid variable syntax when referencing file "${relativePath}".
+Check if your ESM is exporting a function that returns a value.`
+          return Promise.reject(new Error(errorMessage))
+        }
+
+        const valueForFunction = {
+          originalConfig: this.originalConfig,
+          config: this.config,
+          opts: this.opts,
+        }
+
+        valueToPopulate = returnValueFunction.call(esmFile, valueForFunction, ...argsToPass)
+
+        return Promise.resolve(valueToPopulate).then((valueToPopulateResolved) => {
+          let deepProperties = variableString.replace(matchedFileString, '')
+          deepProperties = deepProperties.slice(1).split('.')
+          deepProperties.splice(0, 1)
+          // Trim prop keys for starting/trailing spaces
+          deepProperties = deepProperties.map((prop) => {
+            return trim(prop)
+          })
+          return this.getDeeperValue(deepProperties, valueToPopulateResolved).then((deepValueToPopulateResolved) => {
+            if (typeof deepValueToPopulateResolved === 'undefined') {
+              const errorMessage = `Invalid variable syntax when referencing file "${relativePath}".
+Check if your ESM is returning the correct data.`
+              return Promise.reject(new Error(errorMessage))
+            }
+            return Promise.resolve(deepValueToPopulateResolved)
+          })
+        })
+      } catch (err) {
+        return Promise.reject(new Error(`Error processing ESM file: ${err.message}`))
+      }
+    }
+
+    // Process everything except JS, TS, and ESM
+    if (fileExtension !== 'js' && fileExtension !== 'ts' && fileExtension !== 'mjs' && fileExtension !== 'esm') {
       /* Read initial file */
       valueToPopulate = fs.readFileSync(fullFilePath, 'utf-8')
 
@@ -1975,6 +2227,9 @@ Check if your javascript is returning the correct data.`
         if (fileExtension === 'toml') {
           valueToPopulate = JSON.stringify(TOML.parse(valueToPopulate))
         }
+        if (fileExtension === 'ini') {
+          valueToPopulate = INI.toJson(valueToPopulate)
+        }
         // console.log('deep', variableString)
         // console.log('matchedFileString', matchedFileString)
         let deepProperties = variableString.replace(matchedFileString, '')
@@ -1997,11 +2252,17 @@ Please use ":" to reference sub properties`
         return Promise.resolve(valueToPopulate)
       }
 
+      if (fileExtension === 'ini') {
+        valueToPopulate = INI.parse(valueToPopulate)
+        return Promise.resolve(valueToPopulate)
+      }
+
       if (fileExtension === 'json') {
         valueToPopulate = JSON.parse(valueToPopulate)
         return Promise.resolve(valueToPopulate)
       }
     }
+    console.log('fall thru', valueToPopulate)
     return Promise.resolve(valueToPopulate)
   }
   getVariableFromDeep(variableString) {