configorama 0.4.9 → 0.5.0

package/lib/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/lib/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/lib/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/lib/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/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
+}

package/lib/utils/splitCsv.js

@@ -0,0 +1,29 @@
+/**
+ * Split a string by comma while preserving quoted content
+ * @param {string} str - String to split
+ * @param {string} splitter - Optional custom splitter (defaults to ',')
+ * @returns {string[]} Array of split strings
+ */
+function splitCsv(str, splitter) {
+  const splitSyntax = splitter || ','
+  // Split at comma SPACE ", "
+  return str.split(splitSyntax).reduce(
+    (accum, curr) => {
+      if (accum.isConcatting) {
+        accum.soFar[accum.soFar.length - 1] += ',' + curr
+      } else {
+        accum.soFar.push(curr)
+      }
+      if (curr.split('"').length % 2 == 0) {
+        accum.isConcatting = !accum.isConcatting
+      }
+      return accum
+    },
+    {
+      soFar: [],
+      isConcatting: false,
+    },
+  ).soFar
+}
+
+module.exports = { splitCsv } 

package/lib/utils/textUtils.js

@@ -0,0 +1,31 @@
+/**
+ * Get text after first occurrence of search string
+ * @param {string} str - Source string
+ * @param {string} search - String to search for
+ * @returns {string} Text after search string or empty string if not found
+ */
+function getTextAfterOccurance(str, search) {
+  const index = str.indexOf(search)
+  if (index === -1) return ''
+  return str.substring(index)
+}
+
+/**
+ * Find nested variable in split array that exists in original source
+ * @param {string[]} split - Array of potential variables
+ * @param {string} originalSource - Original source string
+ * @returns {string|undefined} Found nested variable or undefined
+ */
+function findNestedVariable(split, originalSource) {
+  return split.find((thing) => {
+    if (originalSource && typeof originalSource === 'string') {
+      return originalSource.indexOf(`\${${thing}}`) > -1
+    }
+    return false
+  })
+}
+
+module.exports = {
+  getTextAfterOccurance,
+  findNestedVariable
+} 

package/lib/utils/unknownValues.js

@@ -0,0 +1,46 @@
+/**
+ * Encode unknown variable for passthrough
+ */
+function encodeUnknown(v) {
+  return `>passthrough[_[${Buffer.from(v).toString('base64')}]_]`
+}
+
+/**
+ * Decode unknown variable from passthrough
+ */
+function decodeUnknown(rawValue) {
+  const x = findUnknownValues(rawValue)
+  let val = rawValue.replace(/>passthrough/g, '')
+  if (x.length) {
+    x.forEach(({ match, value }) => {
+      const decodedValue = Buffer.from(value, 'base64').toString('ascii')
+      val = val.replace(match, decodedValue)
+    })
+  }
+  return val
+}
+
+/**
+ * Find base64 encoded unknown values in text
+ */
+function findUnknownValues(text) {
+  const base64WrapperRegex = /\[_\[([A-Za-z0-9+/=\s]*)\]_\]/g
+  let matches
+  const links = []
+  while ((matches = base64WrapperRegex.exec(text)) !== null) {
+    if (matches.index === base64WrapperRegex.lastIndex) {
+      base64WrapperRegex.lastIndex++
+    }
+    links.push({
+      match: matches[0],
+      value: matches[1],
+    })
+  }
+  return links
+}
+
+module.exports = {
+  encodeUnknown,
+  decodeUnknown,
+  findUnknownValues
+} 

package/lib/utils/variableUtils.js

@@ -0,0 +1,52 @@
+/**
+ * Get fallback variable string
+ * @param {string[]} split - Array from split at comma
+ * @param {string} nestedVar - Fallback variable to reconstruct variable string from
+ * @returns {string} New ${variable, string}
+ */
+function getFallbackString(split, nestedVar) {
+  let isSet = false
+  const newVar = split
+    .reduce((acc, curr) => {
+      if (curr === nestedVar || isSet) {
+        acc = acc.concat(curr)
+        isSet = true
+      }
+      return acc
+    }, [])
+    .join(', ')
+  const cleanC = `\${${newVar.replace(/^\${/, '').replace(/}$/, '')}}`
+  return cleanC
+}
+
+/**
+ * Verify if variable string is valid
+ */
+function verifyVariable(variableString, valueObject, variableTypes, config) {
+  const isRealVariable = variableTypes.some((r) => {
+    if (r.match instanceof RegExp && variableString.match(r.match)) {
+      return true
+    } else if (typeof r.match === 'function') {
+      if (r.match(variableString, config, valueObject)) {
+        return true
+      }
+    }
+    return false
+  })
+  
+  if (!isRealVariable && variableString.match(/:/)) {
+    throw new Error(`
+Variable \${${variableString}} is invalid variable syntax.
+Value Path: ${valueObject.path ? valueObject.path.join('.') : 'na'}
+Original Value: ${valueObject.originalSource}
+
+Remove or update the \${${variableString}} to fix
+`)
+  }
+  return isRealVariable
+}
+
+module.exports = {
+  getFallbackString,
+  verifyVariable
+} 

package/package.json

@@ -1,19 +1,24 @@
 {
   "name": "configorama",
-  "version": "0.4.9",
+  "version": "0.5.0",
   "description": "Variable support for configuration files",
   "main": "lib/index.js",
   "files": [
+    "cli.js",
     "lib",
     "package.json",
     "package-lock.json",
     "README.md"
   ],
+  "bin": {
+    "configorama": "./cli.js"
+  },
   "scripts": {
     "docs": "node ./scripts/docs.js",
-    "test": "ava -v",
-    "test:api": "ava ./tests/api/api.test.js -v",
-    "watch": "npm test -- --watch -v",
+    "test": "npm run testlib && uvu tests \".*\\.test.js$\" ",
+    "test:api": "uvu tests/api api.test.js",
+    "testlib": "uvu lib \".*\\.test.js$\"",
+    "watch": "watchlist tests -- npm test",
     "publish": "git push origin && git push origin --tags",
     "release:patch": "npm version patch && npm publish",
     "release:minor": "npm version minor && npm publish",
@@ -33,26 +38,32 @@
     "git-url-parse": "^14.0.0",
     "js-yaml": "^3.14.1",
     "json5": "^2.2.3",
-    "lodash": "^4.17.21",
+    "lodash.isarray": "^4.0.0",
+    "lodash.isstring": "^4.0.1",
+    "lodash.isnumber": "^3.0.3",
+    "lodash.isobject": "^3.0.2",
+    "lodash.isdate": "^4.0.1",
+    "lodash.isregexp": "^4.0.1",
+    "lodash.isfunction": "^3.0.9",
+    "lodash.isempty": "^4.4.0",
+    "lodash.camelcase": "^4.3.0",
+    "lodash.kebabcase": "^4.1.1",
+    "lodash.capitalize": "^4.2.1",
+    "lodash.split": "^4.4.2",
+    "lodash.map": "^4.6.0",
+    "lodash.mapvalues": "^4.6.0",
+    "lodash.assign": "^4.2.0",
+    "lodash.clonedeep": "^4.5.0",
+    "lodash.includes": "^4.3.0",
+    "lodash.flatten": "^4.4.0",
     "promise.prototype.finally": "^3.1.8",
-    "replaceall": "^0.1.6",
     "sync-rpc": "^1.3.6",
     "traverse": "^0.6.8"
   },
   "devDependencies": {
-    "ava": "^2.4.0",
     "markdown-magic": "^2.6.1",
-    "minimist": "^1.2.8"
-  },
-  "ava": {
-    "files": [
-      "tests/**/*.test.js"
-    ],
-    "sources": [
-      "**/*.{js,jsx}",
-      "*.yml",
-      "**/*.yml"
-    ],
-    "verbose": true
+    "minimist": "^1.2.8",
+    "uvu": "^0.5.6",
+    "watchlist": "^0.3.1"
   }
 }