dotenv-extended/lib/index.js

A module for loading .env files and optionally loading defaults and a schema for validating all values are present.

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = exports.load = exports.config = exports.parse = void 0;

var _dotenv = _interopRequireDefault(require("dotenv"));

var _configFromEnv = _interopRequireDefault(require("./utils/config-from-env"));

var _loadEnvironmentFile = _interopRequireDefault(require("./utils/load-environment-file"));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

/**
 * Created by Keith Morris on 2/9/16.
 */
var parse = _dotenv["default"].parse.bind(_dotenv["default"]);

exports.parse = parse;

var config = function config(options) {
  var defaultsData,
      environmentData,
      defaultOptions = {
    encoding: 'utf8',
    silent: true,
    path: '.env',
    defaults: '.env.defaults',
    schema: '.env.schema',
    errorOnMissing: false,
    errorOnExtra: false,
    errorOnRegex: false,
    includeProcessEnv: false,
    assignToProcessEnv: true,
    overrideProcessEnv: false
  },
      processEnvOptions = (0, _configFromEnv["default"])(process.env);
  options = Object.assign({}, defaultOptions, processEnvOptions, options);
  defaultsData = (0, _loadEnvironmentFile["default"])(options.defaults, options.encoding, options.silent);
  environmentData = (0, _loadEnvironmentFile["default"])(options.path, options.encoding, options.silent);
  var configData = Object.assign({}, defaultsData, environmentData);
  var config = options.includeProcessEnv ? Object.assign({}, configData, process.env) : configData;
  var configOnlyKeys = Object.keys(configData);
  var configKeys = Object.keys(config);

  if (options.errorOnMissing || options.errorOnExtra || options.errorOnRegex) {
    var schema = (0, _loadEnvironmentFile["default"])(options.schema, options.encoding, options.silent);
    var schemaKeys = Object.keys(schema);
    var missingKeys = schemaKeys.filter(function (key) {
      return configKeys.indexOf(key) < 0;
    });
    var extraKeys = configOnlyKeys.filter(function (key) {
      return schemaKeys.indexOf(key) < 0;
    });

    if (options.errorOnMissing && missingKeys.length) {
      throw new Error('MISSING CONFIG VALUES: ' + missingKeys.join(', '));
    }

    if (options.errorOnExtra && extraKeys.length) {
      throw new Error('EXTRA CONFIG VALUES: ' + extraKeys.join(', '));
    }

    if (options.errorOnRegex) {
      var regexMismatchKeys = schemaKeys.filter(function (key) {
        if (schema[key]) {
          return !new RegExp(schema[key]).test(typeof config[key] === 'string' ? config[key] : '');
        }
      });

      if (regexMismatchKeys.length) {
        throw new Error('REGEX MISMATCH: ' + regexMismatchKeys.join(', '));
      }
    }
  } // the returned configData object should include process.env that override


  if (options.includeProcessEnv && !options.overrideProcessEnv) {
    for (var i = 0; i < configKeys.length; i++) {
      if (typeof process.env[configKeys[i]] !== 'undefined') configData[configKeys[i]] = process.env[configKeys[i]];
    }
  }

  if (options.assignToProcessEnv) {
    if (options.overrideProcessEnv) {
      Object.assign(process.env, configData);
    } else {
      var tmp = Object.assign({}, configData, process.env);
      Object.assign(process.env, tmp);
    }
  }

  return configData;
};

exports.config = config;
var load = config;
exports.load = load;
var _default = {
  parse: parse,
  config: config,
  load: load
};
exports["default"] = _default;