fix: select env after merging all files together (#47)

* fix: select env after merging all files together

* refactor: Use an internal ConfigLocation concept to represent override priority

* Actually commit the ConfigLocation file 🤦

* Some nice code comments

* Refactors createLoaders to take advantage of only having one location

Author: Nathan Lincoln

lib/ConfigLocation.js

@@ -0,0 +1,129 @@
+/**
+ * @projectName gofigure
+ * @github http://github.com/C2FO/gofigure
+ * @header [../README.md]
+ * @includeDoc [Change Log] ../History.md
+ */
+
+const _ = require('lodash');
+const PatternEventEmitter = require('./PatternEventEmitter');
+const loader = require('./loader');
+const processor = require('./processor');
+
+class ConfigLocation extends PatternEventEmitter {
+  /**
+   * Aggregate class for a single entry in the `locations` array.
+   *
+   * Locations will load all the config files specified within their list
+   * and then merge them together.
+   *
+   * @param {{ file: string }} locationName the location that this instance should own
+   * @param opts @see ConfigLoader
+   */
+  constructor(locationName, opts) {
+    super({});
+    if (!locationName) {
+      throw new Error('A locationName is required');
+    }
+    const options = opts || {};
+    this.environment = options.environment || process.env.NODE_ENV || null;
+    this.nodeType = options.nodeType || process.env.NODE_TYPE || null;
+    this.environmentVariables = options.environmentVariables || process.env || {};
+    this.defaultEnvironment = options.defaultEnvironment || '*';
+    this.config = {};
+    this.monitor = !!options.monitor;
+    this.locationName = locationName;
+    this.loaded = false;
+  }
+
+  /**
+   * Stops monitoring confgurations for changes.
+   *
+   * @return {Config} this config object.
+   */
+  stop() {
+    this.__loaders.forEach((l) => l.unWatch());
+    return this;
+  }
+
+  /**
+   * Asynchronously loads configs.
+   *
+   * @example
+   * configLoader.load().then((config) => {
+   *     // use the config.
+   * })
+   *
+   * @return {Promise<any>|Promise<any[] | never>} resolves with the merged configuration from all locations.s
+   */
+  load() {
+    if (this.__loaded) {
+      return Promise.resolve(this.config);
+    }
+    return loader.createLoadersAsync(this.locationName, { monitor: this.monitor }).then((loaders) => {
+      this.__loaders = loaders;
+      const loads = loaders.map((l) => l.load());
+      return Promise.all(loads).then((configs) => this.__postLoad(configs));
+    });
+  }
+
+  /**
+   * Synchronously loads configurations.
+   *
+   * @example
+   * const config = configLoader.loadSync()
+   * //use your config.
+   *
+   * @return {Object} the merged configuration from all locations.
+   */
+  loadSync() {
+    if (this.__loaded) {
+      return this.config;
+    }
+    this.__loaders = loader.createLoadersSync(this.locationName, { monitor: this.monitor });
+    return this.__postLoad(this.__loaders.map((l) => l.loadSync()));
+  }
+
+  __mergeConfigs(configs) {
+    return processor(_.cloneDeep(this.config), configs, {
+      environment: this.environment,
+      defaultEnvironment: this.defaultEnvironment,
+      nodeType: this.nodeType,
+      eventEmitter: this,
+      environmentVariables: this.environmentVariables,
+    });
+  }
+
+  /**
+   *  Merges configs and starts monitoring of configs if `monitor` is true.
+   * @param configs {Array<Object>} an array of configurations to merge into a single object.
+   * @return {Object} the merged config
+   * @private
+   */
+  __postLoad(configs) {
+    this.config = this.__mergeConfigs(configs);
+    this.__listenToChanges();
+    this.__loaded = true;
+    return this.config;
+  }
+
+  __listenToChanges() {
+    this.__loaders.forEach((l) =>
+      l.on('change', (path, config) => {
+        /**
+         * Whenever one of our loaders reports that their file was changed,
+         * we forward that event onward.
+         *
+         * The `config` object here is just the raw contents of the file. Our "parent"
+         * listener expects us to forward them the resolved config, so we process it before
+         * forwarding it.
+         */
+        this.config = this.__mergeConfigs([config]);
+
+        this.emit('change', this.config);
+      }),
+    );
+  }
+}
+
+module.exports = ConfigLocation;

lib/index.js

@@ -7,8 +7,8 @@
 
 const _ = require('lodash');
 const PatternEventEmitter = require('./PatternEventEmitter');
-const loader = require('./loader');
-const processor = require('./processor');
+const ConfigLocation = require('./ConfigLocation');
+const merger = require('./processor/merger');
 
 class ConfigLoader extends PatternEventEmitter {
   /**
@@ -28,15 +28,15 @@ class ConfigLoader extends PatternEventEmitter {
     if (!loaderConfig) {
       throw new Error('A loader configuration is required');
     }
-    const options = opts || {};
-    this.environment = options.environment || process.env.NODE_ENV || null;
-    this.nodeType = options.nodeType || process.env.NODE_TYPE || null;
-    this.environmentVariables = options.environmentVariables || process.env || {};
-    this.defaultEnvironment = options.defaultEnvironment || '*';
     this.config = {};
-    this.monitor = !!options.monitor;
-    this.loaderConfig = loaderConfig;
-    this.loaded = false;
+
+    /**
+     * Set up our child locations. They manage the act of getting all of the
+     * files in a given "location" and merging them together properly.
+     * Our job here is to merge the already-resolved configs together in priority
+     * order
+     */
+    this.locations = loaderConfig.locations.map((locationName) => new ConfigLocation(locationName, opts));
   }
 
   /**
@@ -45,7 +45,7 @@ class ConfigLoader extends PatternEventEmitter {
    * @return {Config} this config object.
    */
   stop() {
-    this.__loaders.forEach((l) => l.unWatch());
+    this.locations.forEach((l) => l.stop());
     return this;
   }
 
@@ -63,10 +63,8 @@ class ConfigLoader extends PatternEventEmitter {
     if (this.__loaded) {
       return Promise.resolve(this.config);
     }
-    return loader.createLoadersAsync(this.loaderConfig, { monitor: this.monitor }).then((loaders) => {
-      this.__loaders = loaders;
-      const loads = loaders.map((l) => l.load());
-      return Promise.all(loads).then((configs) => this.__postLoad(configs));
+    return Promise.all(this.locations.map((location) => location.load())).then((configs) => {
+      return this.__postLoad(configs);
     });
   }
 
@@ -83,18 +81,16 @@ class ConfigLoader extends PatternEventEmitter {
     if (this.__loaded) {
       return this.config;
     }
-    this.__loaders = loader.createLoadersSync(this.loaderConfig, { monitor: this.monitor });
-    return this.__postLoad(this.__loaders.map((l) => l.loadSync()));
+    return this.__postLoad(this.locations.map((location) => location.loadSync()));
   }
 
   __mergeConfigs(configs) {
-    return processor(_.cloneDeep(this.config), configs, {
-      environment: this.environment,
-      defaultEnvironment: this.defaultEnvironment,
-      nodeType: this.nodeType,
-      eventEmitter: this,
-      environmentVariables: this.environmentVariables,
-    });
+    const mergedConfigs = configs.reduce((merged, source) => _.merge(merged, source), {});
+    /**
+     * We can't just use the `mergedConfigs` here because the `merger` manages our event
+     * emitter.
+     */
+    return merger(this.config, mergedConfigs, { eventEmitter: this });
   }
 
   /**
@@ -111,8 +107,12 @@ class ConfigLoader extends PatternEventEmitter {
   }
 
   __listenToChanges() {
-    this.__loaders.forEach((l) =>
+    this.locations.forEach((l) =>
       l.on('change', (path, config) => {
+        /**
+         * When one of our locations reports a change to their
+         * config, merge it in.
+         */
         this.config = this.__mergeConfigs([config]);
       }),
     );

lib/loader/index.js

@@ -23,42 +23,33 @@ const createLoader = (options) => {
   throw new Error('Unable to determine loader type please specify a file location');
 };
 
-const normalizeLocations = (locations, options) =>
-  locations.map((location) => _.merge({}, options, _.isString(location) ? { file: location } : location));
-
 const createLocationsFromGlobedFiles = (location, globedFiles) =>
   globedFiles.map((file) => _.merge({}, location, { file }));
 
-const createLoadersSync = (loaderConfig, options) => {
-  let loaders = [];
-  if (loaderConfig.locations) {
-    const files = normalizeLocations(loaderConfig.locations, options).reduce((globedFiles, location) => {
-      const globPattern = createGlobPattern(location.file);
-      const filesFromGlob = glob.sync(globPattern);
-      return [...globedFiles, ...createLocationsFromGlobedFiles(location, filesFromGlob)];
-    }, []);
-    loaders = files.map((location) => createLoader(location));
-  }
-  return loaders;
+const createLoadersSync = (locationName, options) => {
+  const globPattern = createGlobPattern(locationName.file);
+  const filesFromGlob = glob.sync(globPattern);
+  const files = createLocationsFromGlobedFiles(locationName, filesFromGlob);
+  return files.map((file) =>
+    createLoader({
+      ...options,
+      ...file,
+    }),
+  );
 };
 
-const createLoadersAsync = (loaderConfig, options) => {
-  let loadersPromise = Promise.resolve([]);
-  if (loaderConfig.locations) {
-    const globFilesPromise = normalizeLocations(loaderConfig.locations, options).reduce(
-      (globedFilesPromise, location) =>
-        globedFilesPromise.then((globedFiles) => {
-          const globPattern = createGlobPattern(location.file);
-          return globP(globPattern).then((filesFromGlob) => [
-            ...globedFiles,
-            ...createLocationsFromGlobedFiles(location, filesFromGlob),
-          ]);
+const createLoadersAsync = (locationName, options) => {
+  const globPattern = createGlobPattern(locationName.file);
+  return globP(globPattern)
+    .then((filesFromGlob) => createLocationsFromGlobedFiles(locationName, filesFromGlob))
+    .then((files) =>
+      files.map((file) =>
+        createLoader({
+          ...options,
+          ...file,
         }),
-      Promise.resolve([]),
+      ),
     );
-    loadersPromise = globFilesPromise.then((files) => files.map((location) => createLoader(location)));
-  }
-  return loadersPromise;
 };
 
 module.exports = {

lib/processor/processor.js

@@ -4,15 +4,11 @@ const merger = require('./merger');
 const selector = require('./selector');
 const mixin = require('./mixin');
 
-const processConfig = (config, options) => {
-  const merged = mixin(config, options);
-  const mergeEnvConfig = selector(merged, options);
-  return replacer(mergeEnvConfig, options);
-};
-
 const processor = (configToMergeInto, sourceConfigs, options) => {
-  const mergedSource = sourceConfigs.reduce((merged, source) => _.merge(merged, processConfig(source, options)), {});
-  return merger(configToMergeInto, mergedSource, options);
+  const mergedSource = sourceConfigs.reduce((merged, source) => _.merge(merged, mixin(source, options)), {});
+  const mergeEnvConfig = selector(mergedSource, options);
+  const replaced = replacer(mergeEnvConfig, options);
+  return merger(configToMergeInto, replaced, options);
 };
 
 module.exports = processor;