Node-config comes with a handy set of utilities necessary for implementing node-config. These utilities are exposed in the lib/util.js file for use in your own applications, although one or two remain in config.util object for now.

Below is a list of these utilities, in order of general usefulness - your mileage may vary.

Extend an object (and any object it contains) with one or more objects (and objects contained in them).

This does not replace deep objects as other extend functions do, but dives into them extending individual elements instead. If more than one of the extending objects define the same key, then:

• if all the respective values are objects, they are merged recursively by calling the same function.
• if none of the respective values are objects, then the latest one is respected.
• avoid mixing objects and non-objects for the same key as it can lead to unexpected behaviour.

The following example merges the contents of two objects into a new object.

var newObject = Util.extendDeep({}, baseObject, anotherObject);

Return a deep copy of the specified object.

This returns a new object with all elements copied from the specified object. Deep copies are made of objects and arrays so you can do anything with the returned object without affecting the input object.

Example:

var copy = Util.cloneDeep(fromObject);

Return true if two objects have equal contents.

Example:

var customerCopy = Util.cloneDeep(myCustomer);
var same = Util.equalsDeep(myCustomer, customerCopy); // <-- true
customerCopy.creditLimit = 7000;
var same = Util.equalsDeep(myCustomer, customerCopy); // <-- false

Make a javascript object property immutable (assuring it cannot be changed from the current value).

If the propertyName isn't supplied, all properties of the object are made immutable.

Properties which themselves are objects are called recursively, making sub-objects immutable.

New properties can be added to this (and sub) objects, and those properties will not be immutable unless this method is called after adding the properties.

This operation cannot be undone.

Example:

var a = {hello:'world'};
config.util.makeImmutable(a);
a.hello = 'there';
console.log ('Sorry, hello is still ' + a.hello);

Make an object property hidden so it doesn't appear when enumerating elements of the object.

The property still exists and can be read from and written to, but it won't show up in for ... in loops, Object.keys(), or JSON.stringify() type methods.

Example:

var a = {hello:'world'};
console.log ('Before hiding: ' + JSON.stringify(a));
Util.makeHidden(a, 'hello');
console.log ('After hiding: ' + JSON.stringify(a));
console.log ('Hidden, but still there: ' + a.hello);

Get the current value of a config environment variable

This method returns the value of the specified config environment variable, including any defaults or overrides.

Environment variables that you can inspect include NODE_ENV, NODE_CONFIG_DIR, NODE_CONFIG, HOSTNAME, NODE_APP_INSTANCE, and others listed in the environment variables wiki page.

Example:

console.log('Configuration directory: ' + config.util.getEnv('NODE_CONFIG_DIR'));

This is mostly useful in combination with setModuleDefaults, but can also be used for some validation workflows.

import { Load } from 'config/lib/util.js';

...
let options = Load.fromEnvironment().options;
let newLoad = new Load({ ...options, configDir: 'node_modules/mymodule/config' });

config.util.setModuleDefaults('MyModule', newLoad.scan());

Reads the given directory using the same conventions as the main config directory (including environment variable reading, except for NODE_CONFIG) and returns an object with the result.

If no directory is given, reads the standard config directory and parses NODE_CONFIG.

Returns a raw version of the current config object, or any part of the config if provided, deeply copied without the get, has and util functions.

If config is not provided (undefined), the current config object is dumped in its entirety.

var result = config.util.toObject(config.get('db'));