config.js

'use strict';

/*
  This configuration utility is designed to allow the definition of important constants in a
  way that is compatible with VSCode Intellisense.

  Secret (ignored) configurations can be set in a `.conf.js` file, and will overwrite default
  configurations. Environment variables can also be used to define string values, using the
  following format for the key: `NODE_CONF_${categoryKey}_${valueKey}`

  This utility expects there to be a `.conf.default.js` file in the same directory. The secret
  config file is optional

  See the default config for details on file formatting

  The config object will only get values from the related conf files the first time it is
  imported. Use the `config.loadConfig` method to force a read from file
*/

const config = require('./.conf.default.js');
let secretConfig = {};
try {
  secretConfig = require('./.conf.js');
} catch(e) {
  // Allow error
}

/**
 * Array containing falsy values that are explicitly permitted
 */
const allowedFalsyValues = [
  '',
  0,
  null
];

/**
 * Simple helper determines if a value exists in a config object
 *
 * @param {object} obj Object to check
 * @param {string} categoryKey Category to check
 * @param {string} valueKey Name of the value to check
 */
const checkExists = (obj, categoryKey, valueKey) => {
  return obj[categoryKey] && (obj[categoryKey][valueKey] || allowedFalsyValues.includes(obj[categoryKey][valueKey]));
};

/**
 * Helper function recursively travels a provided object and returns "false" if any values are undefined. A log
 * will also be automatically made to stderr detailing the nature of the failure
 * 
 * @param {object} obj The object to check
 * @param {string} originalKey The key related to the object being checked
 */
const checkForUndefinedRecursive = (obj, originalKey = 'this') => {
  if (typeof obj === 'undefined') {
    console.error(`Item with key ${originalKey} is undefined`);
    return false;
  }

  // Don't check strings
  if (typeof obj === 'string') return true;

  // For-in statements don't run on non-indexed datatypes
  for (const key in obj) {
    const item = obj[key];

    if (!checkForUndefinedRecursive(item, key)) return false;
  }

  return true;
};

/**
 * Method will load config values into the config object. Can be used to re-initialize the config
 * object, if needed
 *
 * @param {object} configOpts Overrides for any currently set config options
 */
const loadConfig = (configOpts = null) => {
  for (const categoryKey in config) {
    const category = config[categoryKey];

    for (const valueKey in category) {
      // Check for the value in the configuration options provided as an argument
      if (configOpts && checkExists(configOpts, categoryKey, valueKey)) {
        category[valueKey] = configOpts[categoryKey][valueKey];
        continue;
      }

      // Check for the value in the secret config
      if (checkExists(secretConfig, categoryKey, valueKey)) {
        category[valueKey] = secretConfig[categoryKey][valueKey];
        continue;
      }

      // Check for the value in environment vars
      const varName = `NODE_CONF_${categoryKey}_${valueKey}`;
      if (process.env[varName]) {
        category[valueKey] = process.env[varName];
        continue;
      }
    }
  }

  if (!config.config.errorOnUndefined) return;

  if (!checkForUndefinedRecursive(this)) {
    throw new Error('Undefined configurations detected');
  }
};

loadConfig();

config.loadConfig = loadConfig;
module.exports = config;