configorama 0.4.10 → 0.5.1

package/{lib → src}/parsers/yaml.js

@@ -83,28 +83,29 @@ function findOutermostVariables(text) {
 
 
 function matchOutermostBraces(text) {
-    let depth = 0;
-    let startIndex = -1;
-    let results = [];
-
-    for (let i = 0; i < text.length; i++) {
-        if (text[i] === '{') {
-            if (depth === 0) {
-                startIndex = i;
-            }
-            depth++;
-        } else if (text[i] === '}') {
-            depth--;
-            if (depth === 0 && startIndex !== -1) {
-                results.push(text.substring(startIndex, i + 1));
-                startIndex = -1;
-            }
-        }
+  let depth = 0
+  let startIndex = -1
+  let results = []
+
+  for (let i = 0; i < text.length; i++) {
+    if (text[i] === '{') {
+      if (depth === 0) {
+        startIndex = i
+      }
+      depth++
+    } else if (text[i] === '}') {
+      depth--
+      if (depth === 0 && startIndex !== -1) {
+        results.push(text.substring(startIndex, i + 1))
+        startIndex = -1
+      }
     }
+  }
 
-    return results;
+  return results
 }
 
+
 // https://regex101.com/r/XIltbc/1
 const KEY_OBJECT = /^[ \t]*[^":\s]*:\s+\{/gm
 
@@ -161,7 +162,18 @@ function preProcess(ymlStr = '') {
         if (hasNestedVars && hasNestedVars.length) {
           let fixedText = txt
           hasNestedVars.forEach((nested) => {
+            const isObject = txt.match(/^\{/) && txt.match(/}$/)
             // console.log('nested', nested)
+
+            if (nested.match(/^\${/) && (nested.match(/"/) || nested.match(/'/)) && !isObject) {
+              return
+            }
+
+            // Fallback comma ${opt:stage, dev}
+            if (nested.match(/^\${/) && nested.match(/,/) && !txt.match(/\n/) ) {
+              return
+            }
+
             if (txt.indexOf(`"${nested}"`) > -1) {
               return
             }

package/src/parsers/yaml.test.js

@@ -0,0 +1,169 @@
+const { test } = require('uvu')
+const assert = require('uvu/assert')
+const { preProcess } = require('./yaml')
+
+test('preProcess - should wrap variables in quotes inside array brackets', () => {
+  const input = `
+
+x: !Not [!Equals [!Join ['', "\${param:githubActionsAllowedAwsActions}"]]]
+
+y: !Not [!Equals [!Join ['', \${param:xyz}]]]
+
+# empty: "\${file(./config.json):na, ''}"
+
+TestThree:
+  foo: 
+    - ['a', 'b', 'c']
+    - ['d', 'e', \${ opt:otherFlag }, \${ opt:chillFlag }]
+    - ['d', 'e', "\${opt:otherFlag}", "\${opt:chillFlag}"]
+    - ['d', 'e', "\${opt:otherFlag}", "\${opt:chillFlag}"]
+
+
+key: ['string1', 'string2', 'string3', 
+  'string4', \${opt:otherFlag}, 
+  'string6'
+]
+
+keyTwo: ['string1', 'long
+  string', 'string3', 'string4', 'string5', 'string6']
+
+myarray: [
+  String1, String2, String3,
+  String4, String5, String5, String7
+]
+
+xx: {
+  cool: \${self:empty, 'no value here'}
+}
+
+myarrayTwo: [
+  String1, \${self:empty, 'no value here'}, String3,
+  String4, String5, String5, String7
+]
+
+normalObject: 
+  cool: \${self:empty, 'no value here'}
+
+# shorthand variable declaration
+domainNameTwo: my-site-two.com
+stage: dev
+domainsTwo:
+  prod:    api.\${domainNameTwo}
+  staging: api-staging.\${domainNameTwo}
+  dev:     api-dev.\${domainNameTwo}
+resolvedDomainNameTwo: \${domainsTwo.\${opt:stage, "prod"}}
+
+`
+  const expected = `
+
+x: !Not [!Equals [!Join ['', "\${param:githubActionsAllowedAwsActions}"]]]
+
+y: !Not [!Equals [!Join ['', "\${param:xyz}"]]]
+
+# empty: "\${file(./config.json):na, ''}"
+
+TestThree:
+  foo: 
+    - ['a', 'b', 'c']
+    - ['d', 'e', "\${ opt:otherFlag }", "\${ opt:chillFlag }"]
+    - ['d', 'e', "\${opt:otherFlag}", "\${opt:chillFlag}"]
+    - ['d', 'e', "\${opt:otherFlag}", "\${opt:chillFlag}"]
+
+
+key: ['string1', 'string2', 'string3', 
+  'string4', "\${opt:otherFlag}", 
+  'string6'
+]
+
+keyTwo: ['string1', 'long
+  string', 'string3', 'string4', 'string5', 'string6']
+
+myarray: [
+  String1, String2, String3,
+  String4, String5, String5, String7
+]
+
+xx: {
+  cool: "\${self:empty, 'no value here'}"
+}
+
+myarrayTwo: [
+  String1, "\${self:empty, 'no value here'}", String3,
+  String4, String5, String5, String7
+]
+
+normalObject: 
+  cool: \${self:empty, 'no value here'}
+
+# shorthand variable declaration
+domainNameTwo: my-site-two.com
+stage: dev
+domainsTwo:
+  prod:    api.\${domainNameTwo}
+  staging: api-staging.\${domainNameTwo}
+  dev:     api-dev.\${domainNameTwo}
+resolvedDomainNameTwo: \${domainsTwo.\${opt:stage, "prod"}}
+
+`
+  const result = preProcess(input)
+  console.log('result', result)
+  assert.equal(result, expected)
+})
+
+test('preProcess - should wrap variables in quotes inside array brackets', () => {
+  const input = `
+service: my-service
+custom:
+  myValue: !Not [!Equals [!Join ['', \${param:xyz}]]]
+`
+  const expected = `
+service: my-service
+custom:
+  myValue: !Not [!Equals [!Join ['', "\${param:xyz}"]]]
+`
+  const result = preProcess(input)
+  assert.equal(result, expected)
+})
+
+test('preProcess - should wrap variables in quotes inside objects', () => {
+  const input = `
+resources:
+  MyResource:
+    Type: AWS::Lambda::Function
+    Properties: {
+      FunctionName: \${env:FUNC_NAME},
+      Handler: index.handler
+    }
+`
+  const expected = `
+resources:
+  MyResource:
+    Type: AWS::Lambda::Function
+    Properties: {
+      FunctionName: "\${env:FUNC_NAME}",
+      Handler: index.handler
+    }
+`
+  const result = preProcess(input)
+  assert.equal(result, expected)
+})
+
+test('preProcess - should not wrap already quoted variables', () => {
+  const input = `
+custom:
+  alreadyQuoted: !Not [!Equals [!Join ['', "\${param:xyz}"]]]
+  objectQuoted:
+    Properties: {
+      Name: "\${env:NAME}"
+    }
+`
+  const result = preProcess(input)
+  assert.equal(result, input)
+})
+
+test('preProcess - should handle empty input', () => {
+  const result = preProcess()
+  assert.equal(result, '')
+})
+
+test.run() 

package/{lib → src}/resolvers/valueFromEnv.js

@@ -3,6 +3,16 @@ const envRefSyntax = RegExp(/^env:/g)
 
 function getValueFromEnv(variableString) {
   const requestedEnvVar = variableString.split(':')[1]
+  // console.log('requestedEnvVar', requestedEnvVar)
+  if (requestedEnvVar === '') {
+    throw new Error(`Invalid variable syntax for environment variable reference "${variableString}". 
+
+\${env} variable must have a key path. 
+
+Example: \${env:MY_ENV_VAR}
+`)
+  }
+
   let valueToPopulate
   if (requestedEnvVar !== '' || '' in process.env) {
     valueToPopulate = process.env[requestedEnvVar]

package/{lib → src}/resolvers/valueFromGit.js

@@ -1,9 +1,12 @@
 /* from https://github.com/jacob-meacham/serverless-plugin-git-variables/blob/develop/src/index.js */
 const os = require('os')
+const fs = require('fs')
+const path = require('path')
 const childProcess = require('child_process')
 const GitUrlParse = require('git-url-parse')
 const { functionRegex } = require('../utils/regex')
 const formatFunctionArgs = require('../utils/formatFunctionArgs')
+const { findProjectRoot } = require('../utils/find-project-root')
 const GIT_PREFIX = 'git'
 const gitVariableSyntax = RegExp(/^git:/g)
 
@@ -32,6 +35,17 @@ function createResolver(cwd) {
 
     const verifyMsg = `Verify the cwd has a .git directory\n`
     const normalizedVar = (variable || '').toLowerCase()
+    // console.log('normalizedVar', normalizedVar)
+
+    const argsMatch = (variable || '').match(/(.*)\((.*)\)/)
+    // console.log('argsMatch', argsMatch)
+    if (argsMatch) {
+      const funcName = argsMatch[1]
+      const args = argsMatch[2]
+      if (funcName === 'timestamp' && args) {
+        value = await getGitTimestamp(args, cwd)
+      }
+    }
 
     switch (normalizedVar) {
       // Repo owner/name
@@ -61,6 +75,7 @@ function createResolver(cwd) {
         break;
       // Repo name
       case 'dir':
+      case 'directory':
       case 'dirpath': // dirPath
       case 'dir-path':
       case 'dir_path':
@@ -152,13 +167,92 @@ function createResolver(cwd) {
         value = `${changes.length > 0}`
         break
       default:
-        throw new Error(`Git variable ${variable} is unknown. Candidates are 'describe', 'describeLight', 'sha1', 'commit', 'branch', 'message', 'repository'`)
+        if (!value) {
+          throw new Error(`Git variable ${variable} is unknown. Candidates are 'describe', 'describeLight', 'sha1', 'commit', 'branch', 'message', 'repository'`)
+        }
     }
     return value
   }
   return _getValueFromGit
 }
 
+const cache = new Map()
+
+/**
+ * Gets the last Git commit timestamp for a file
+ * @param {string} file - Path to the file to check
+ * @returns {Promise<Date|undefined>} The commit timestamp or undefined if not in Git
+ */
+async function getGitTimestamp(_file, cwd, throwOnMissing = true) {
+  // Validate file path to prevent command injection
+  if (typeof _file !== 'string') {
+    throw new Error('File path must be a string')
+  }
+
+  // Check for suspicious characters and patterns that could be used for command injection or path traversal
+  const dangerousPatterns = [
+    /[;&|`$]/,  // Command injection chars
+    // /\.\.\//,   // Directory traversal
+    // /\.\./,     // Directory traversal
+    // /^[\/\\]/,  // Absolute paths
+    /[\x00-\x1f\x7f-\x9f]/  // Control characters
+  ]
+
+  if (dangerousPatterns.some(pattern => pattern.test(_file))) {
+    throw new Error('Invalid characters or pattern in file path')
+  }
+
+  // Only allow alphanumeric chars, dashes, underscores, forward slashes, and dots
+  if (!/^[a-zA-Z0-9-_./\\'"]+$/.test(_file)) {
+    throw new Error('File path contains invalid characters')
+  }
+
+  // Normalize path and remove leading slash
+  const file = _file
+    .replace(/^\//, '')
+
+  const cachedTimestamp = cache.get(file)
+  if (cachedTimestamp) return cachedTimestamp
+
+  if (!fs.existsSync(cwd)) {
+    if (throwOnMissing) {
+      throw new Error(`Directory ${cwd} does not exist`)
+    }
+    return undefined
+  }
+
+  try {
+    const cmd = `git log -1 --pretty="%ai" ${file}`
+    // console.log('cmd', cmd)
+    // console.log('cwd', cwd)
+    const output = await _exec(cmd, { cwd })
+    const date = new Date(output)
+    cache.set(file, date)
+    return date.toISOString()
+  } catch (err) {
+    const projectRoot = findProjectRoot(cwd)
+    if (!projectRoot) {
+      if (throwOnMissing) {
+        throw new Error(`No Git repository found in ${cwd}`)
+      }
+      return undefined
+    }
+
+    try {
+      const backupFile = path.join(projectRoot, _file)
+      const output = await _exec(`git log -1 --pretty="%ai" ${backupFile}`, { cwd: projectRoot })
+      const date = new Date(output)
+      cache.set(file, date)
+      return date.toISOString()
+    } catch (err) {
+      if (throwOnMissing) {
+        throw new Error(`File ${file} does not exist in Git`)
+      }
+      return undefined
+    }
+  }
+}
+
 async function getGitRemote(name = 'origin') {
   const remoteValues = await _exec('git remote -v')
   const remotes = remoteValues.toString().split(os.EOL)

package/{lib → src}/utils/PromiseTracker.js

@@ -1,4 +1,4 @@
-const trim = require('lodash.trim')
+const { trim } = require('./lodash')
 
 // Track promise resolution
 class PromiseTracker {
@@ -41,7 +41,7 @@ class PromiseTracker {
     clearInterval(this.interval)
     this.reset()
   }
-  add(variable, promise, specifier, hasFilter) {
+  add(variable, promise, specifier, hasFilter, promiseKey) {
     // Refactor promise tracker to account for multiple instances of a given variable
 
     // console.log(`${specifier} hasFilter`, hasFilter)
@@ -55,8 +55,11 @@ class PromiseTracker {
       }, '')
     }
 
-    const nameSpacedVariable = `${variable}${uniqueId}`
-    // console.log('nameSpacedVariable', nameSpacedVariable)
+    let nameSpacedVariable = `${variable}${uniqueId}`
+    if (promiseKey) {
+      nameSpacedVariable = promiseKey
+    }
+    // console.log('SET PROMISE', nameSpacedVariable)
 
     promise.waitList = `${variable} waited on by: ${specifier} ${nameSpacedVariable}`
     promise.state = 'pending'

package/src/utils/arrayToJsonPath.js

@@ -0,0 +1,11 @@
+/**
+ * Convert array of paths to JSON path string
+ */
+function arrayToJsonPath(paths) {
+  return paths.reduce((result, path, index) => {
+    if (index === 0) return path.toString()
+    return typeof path === 'string' ? `${result}.${path}` : `${result}[${path}]`
+  }, '')
+}
+
+module.exports = { arrayToJsonPath } 

package/src/utils/find-project-root.js

@@ -0,0 +1,25 @@
+const fs = require('fs')
+const path = require('path')
+
+function findProjectRoot(startDir = process.cwd(), maxLookup = 7) {
+  // Start from the current directory or a specified directory
+  let currentDir = startDir
+  let lookupCount = 0
+  
+  // Keep looking up until we find .git, hit the root, or reach max lookup
+  while (currentDir !== path.parse(currentDir).root && lookupCount < maxLookup) {
+    if (fs.existsSync(path.join(currentDir, '.git'))) {
+      return currentDir
+    }
+    // Move up one directory
+    currentDir = path.dirname(currentDir)
+    lookupCount++
+  }
+  
+  // If we reach here, we couldn't find a .git directory within the limit
+  return null
+}
+
+module.exports = {
+  findProjectRoot
+}

package/{lib → src}/utils/formatFunctionArgs.js

@@ -1,4 +1,4 @@
-const trim = require('lodash.trim')
+const { trim } = require('./lodash')
 
 function formatArg(arg) {
   const cleanArg = trim(arg).replace(/^('|")/, '').replace(/('|")$/, '')

package/src/utils/lodash.js

@@ -0,0 +1,91 @@
+const isArray = require('lodash.isarray')
+const isString = require('lodash.isstring')
+const isNumber = require('lodash.isnumber')
+const isObject = require('lodash.isobject')
+const isDate = require('lodash.isdate')
+const isRegExp = require('lodash.isregexp')
+const isFunction = require('lodash.isfunction')
+const isEmpty = require('lodash.isempty')
+const camelCase = require('lodash.camelcase')
+const kebabCase = require('lodash.kebabcase')
+const capitalize = require('lodash.capitalize')
+const split = require('lodash.split')
+const map = require('lodash.map')
+const mapValues = require('lodash.mapvalues')
+const assign = require('lodash.assign')
+const cloneDeep = require('lodash.clonedeep')
+
+// Custom implementation of lodash.set
+function set(object, path, value) {
+  if (object === null || typeof object !== '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;
+  
+  for (let i = 0; i < lastIndex; i++) {
+    const key = keys[i];
+    
+    if (current[key] === undefined) {
+      // Create appropriate container based on next key type
+      current[key] = Number.isInteger(keys[i + 1]) && keys[i + 1] >= 0 ? [] : {};
+    }
+    
+    current = current[key];
+  }
+  
+  current[keys[lastIndex]] = value;
+  return object;
+}
+
+// Custom implementation of lodash.trim
+function trim(string, chars) {
+  if (string === null || string === undefined) {
+    return '';
+  }
+  
+  string = String(string);
+  
+  if (!chars && String.prototype.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';
+  }
+  
+  // Create a regex pattern with the characters to trim
+  const pattern = new RegExp(`^[${chars.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&')}]+|[${chars.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&')}]+$`, 'g');
+  
+  return string.replace(pattern, '');
+}
+
+module.exports = {
+  isArray,
+  isString,
+  isNumber,
+  isObject,
+  isDate,
+  isRegExp,
+  isFunction,
+  isEmpty,
+  trim,
+  camelCase,
+  kebabCase,
+  capitalize,
+  split,
+  map,
+  mapValues,
+  assign,
+  set,
+  cloneDeep,
+}

package/src/utils/mergeByKeys.js

@@ -0,0 +1,29 @@
+/**
+ * Merge objects by specified keys
+ */
+function mergeByKeys(data, path, keysToMerge) {
+  if (!data) return {}
+  
+  const items = path.split('.').reduce((obj, key) => obj?.[key], data)
+  if (!Array.isArray(items)) return {}
+  
+  const result = {}
+  const mergeAll = !keysToMerge || !Array.isArray(keysToMerge) || keysToMerge.length === 0
+  
+  for (const item of items) {
+    const key = Object.keys(item)[0]
+    
+    if (mergeAll || keysToMerge.includes(key)) {
+      if (!result[key]) {
+        result[key] = Object.assign({}, item[key])
+      } else {
+        result[key] = Object.assign({}, result[key], item[key])
+      }
+    } else {
+      result[key] = item[key]
+    }
+  }
+  return result
+}
+
+module.exports = { mergeByKeys } 

package/src/utils/parse.js

@@ -0,0 +1,62 @@
+const YAML = require('../parsers/yaml')
+const TOML = require('../parsers/toml')
+const cloudFormationSchema = require('./cloudformationSchema')
+
+/**
+ * Parse file contents based on file extension
+ * @param {string} fileContents - Raw file contents to parse
+ * @param {string} fileType - File extension (.yml, .yaml, .json, etc)
+ * @param {string} filePath - Full file path (used for error messages)
+ * @param {RegExp} varRegex - Variable syntax regex
+ * @param {Object} opts - Additional options
+ * @returns {Object} Parsed configuration object
+ */
+function parseFileContents(fileContents, fileType, filePath, varRegex, opts = {}) {
+  let configObject
+
+  if (fileType.match(/\.(yml|yaml)/)) {
+    try {
+      const ymlText = YAML.preProcess(fileContents, varRegex)
+      configObject = YAML.parse(ymlText)
+    } catch (err) {
+      // Attempt to fix cloudformation refs
+      if (err.message.match(/YAMLException/)) {
+        const ymlText = YAML.preProcess(fileContents, varRegex)
+        const result = YAML.load(ymlText, {
+          filename: filePath,
+          schema: cloudFormationSchema.schema,
+        })
+        if (result.error) {
+          throw result.error
+        }
+        configObject = result.data
+      }
+    }
+  } else if (fileType.match(/\.(toml)/)) {
+    configObject = TOML.parse(fileContents)
+  } else if (fileType.match(/\.(json)/)) {
+    configObject = JSON.parse(fileContents)
+  } else if (fileType.match(/\.(js)/)) {
+    let jsFile
+    try {
+      jsFile = require(filePath)
+      if (typeof jsFile !== 'function') {
+        configObject = jsFile
+      } else {
+        let jsArgs = opts.dynamicArgs || {}
+        if (jsArgs && typeof jsArgs === 'function') {
+          jsArgs = jsArgs()
+        }
+        configObject = jsFile(jsArgs)
+      }
+    } catch (err) {
+      throw new Error(err)
+    }
+  }
+
+  return configObject
+}
+
+module.exports = {
+  parseFileContents
+} 

package/src/utils/replaceAll.js

@@ -0,0 +1,16 @@
+const REPLACE_PATTERN = /([\/\,\!\\\^\$\{\}\[\]\(\)\.\*\+\?\|<>\-\&])/g
+
+/**
+ * Replace all occurrences of a string while handling regex special characters
+ * @param {string} replaceThis - String to replace
+ * @param {string} withThis - Replacement string
+ * @param {string} inThis - Source string
+ * @returns {string} String with all replacements made
+ */
+function replaceAll(replaceThis, withThis, inThis) {
+  withThis = withThis.replace(/\$/g, '$$$$')
+  const pat = new RegExp(replaceThis.replace(REPLACE_PATTERN, '\\$&'), 'g')
+  return inThis.replace(pat, withThis)
+}
+
+module.exports = { replaceAll } 

package/{lib → src}/utils/splitByComma.js

@@ -11,9 +11,10 @@ const stringRefSyntax = match
  => ["env:BAZ", "'defaultEnvValue'"]
  */
 
+// https://regex101.com/r/4uPmpt/1
 const commasOutsideOfParens = /(?!<(?:\(|\[)[^)\]]+),(?![^(\[]+(?:\)|\]))/
 // const commasOutOfParens = /(?!(?:\()[^)\]]+),(?![^(\[]+(?:\)))/g
-module.exports = function splitByComma(string) {
+function splitByComma(string) {
   // If comma is not outside of parens, return early,
   // for file(file.js, param, paramTwo) & function support
   // TODO clean this up
@@ -40,7 +41,7 @@ module.exports = function splitByComma(string) {
   while (match) {
     const matchContained = contained(match)
     const containedBy = stringMatches.find(matchContained)
-    if (!containedBy) { // if uncontained, this comma respresents a splitting location
+    if (!containedBy) { // if un-contained, this comma represents a splitting location
       commaReplacements.push({
         start: match.index,
         end: overwriteSyntax.lastIndex,
@@ -64,3 +65,7 @@ module.exports = function splitByComma(string) {
   results.push(input.slice(prior))
   return results
 }
+
+module.exports = {
+  splitByComma
+}