config 4.2.1 → 4.3.0

package/LICENSE

@@ -1,4 +1,4 @@
-// Copyright 2010-2025, Loren West and other contributors
+// Copyright 2010-2026, Loren West and other contributors
 
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to

package/README.md

@@ -171,6 +171,6 @@ License
 
 May be freely distributed under the [MIT license](https://raw.githubusercontent.com/node-config/node-config/master/LICENSE).
 
-Copyright (c) 2010-2025 Loren West 
+Copyright (c) 2010-2026 Loren West 
 [and other contributors](https://github.com/node-config/node-config/graphs/contributors)
 

package/async.js

@@ -1,12 +1,16 @@
-var asyncSymbol = Symbol('asyncSymbol');
-var deferConfig = require('./defer').deferConfig;
+const asyncSymbol = Symbol('asyncSymbol');
+const { deferConfig } = require('./defer');
 
 /**
  * @param promiseOrFunc   the promise will determine a property's value once resolved
  *                        can also be a function to defer which resolves to a promise
  * @returns {Promise}     a marked promise to be resolve later using `resolveAsyncConfigs`
+ * @deprecated please use async functions with defer
  */
 function asyncConfig(promiseOrFunc) {
+  const { Util } = require('./lib/util.js');
+  Util.errorOnce("ASYNC_CONFIG", 'config/async.js is deprecated. Please use async functions with the new defer functionality');
+
   if (typeof promiseOrFunc === 'function') {  // also acts as deferConfig
     return deferConfig(function (config, original) {
       var release;
@@ -36,6 +40,7 @@ function asyncConfig(promiseOrFunc) {
  * Do not use `config.get` before executing this method, it will freeze the config object
  * @param config    the main config object, returned from require('config')
  * @returns {Promise<config>}   once all promises are resolved, return the original config object
+ * @deprecated please use async functions with defer and Util.resolveAsyncConfigs
  */
 function resolveAsyncConfigs(config) {
   var promises = [];

package/defer.js

@@ -1,23 +1,17 @@
-// Create a deferredConfig prototype so that we can check for it when reviewing the configs later.
-function DeferredConfig() {}
-DeferredConfig.prototype.prepare = function() {};
-DeferredConfig.prototype.resolve = function() {};
+const { deferConfig, DeferredConfig } = require('./lib/defer.js');
 
-// Accept a function that we'll use to resolve this value later and return a 'deferred' configuration value to resolve it later.
-function deferConfig(func) {
-  var obj = Object.create(DeferredConfig.prototype);
-  obj.prepare = function(config, prop, property) {
-    var original = prop[property]._original;
-    obj.resolve = function() {
-      var value = func.call(config, config, original);
-      Object.defineProperty(prop, property, {value: value});
-      return value;
-    };
-    Object.defineProperty(prop, property, {get: function() { return obj.resolve(); }});
-    return obj;
-  };
-  return obj;
+/**
+ * @deprecated please use the new callback mechanism
+ * @see lib/defer.js
+ */
+module.exports.deferConfig = (...args) => {
+  const { Util } = require('./lib/util.js');
+
+  Util.errorOnce("DEFER_CONFIG", 'node-config now supports config file callbacks in place of deferConfig(), which is deprecated.');
+  return deferConfig(...args);
 }
 
-module.exports.deferConfig = deferConfig;
+/**
+ * @deprecated please use the new callback mechanism
+ */
 module.exports.DeferredConfig = DeferredConfig;

package/lib/config.js

@@ -1,4 +1,4 @@
-// config.js (c) 2010-2022 Loren West and other contributors
+// config.js (c) 2010-2026 Loren West and other contributors
 // May be freely distributed under the MIT license.
 // For further details and documentation:
 // http://lorenwest.github.com/node-config

package/lib/defer.js

@@ -0,0 +1,42 @@
+const { isAsyncFunction } = require('node:util/types');
+
+// Create a deferredConfig prototype so that we can check for it when reviewing the configs later.
+function DeferredConfig() {}
+DeferredConfig.prototype.prepare = function() {};
+DeferredConfig.prototype.resolve = function() {};
+
+// Accept a function that we'll use to resolve this value later and return a 'deferred' configuration value to resolve it later.
+function deferConfig(func) {
+  const obj = Object.create(DeferredConfig.prototype);
+  obj.prepare = function(config, prop, property) {
+    const original = prop[property]._original;
+
+    if (isAsyncFunction(func)) {
+      obj.resolve = async function () {
+        const promise = func.call(config, config, original);
+
+        Object.defineProperty(prop, property, { value: promise });
+        Object.defineProperty(prop, property, { value: await promise });
+
+        return promise;
+      }
+    } else {
+      obj.resolve = function() {
+        const value = func.call(config, config, original);
+
+        Object.defineProperty(prop, property, {value: value});
+
+        return value;
+      };
+    }
+
+    Object.defineProperty(prop, property, { get: function() { return obj.resolve(); } });
+
+    return obj;
+  };
+
+  return obj;
+}
+
+module.exports.deferConfig = deferConfig;
+module.exports.DeferredConfig = DeferredConfig;

package/lib/util.js

@@ -1,15 +1,17 @@
-// config.js (c) 2010-2022 Loren West and other contributors
+// config.js (c) 2010-2026 Loren West and other contributors
 // May be freely distributed under the MIT license.
 // For further details and documentation:
 // http://lorenwest.github.com/node-config
 
 // Dependencies
-const DeferredConfig = require('../defer').DeferredConfig;
+const { deferConfig, DeferredConfig } = require('./defer.js');
+const { resolveAsyncConfigs } = require('../async');
 const Path = require('path');
 const FileSystem = require('fs');
 const OS = require("os");
 
 const DEFAULT_CONFIG_DIR = Path.join( process.cwd(), 'config');
+const SEEN_ERRORS = {};
 
 /**
  * A source in the configSources list
@@ -301,29 +303,78 @@ class Util {
       const propsToSort = Object.keys(prop).filter((property) => prop[property] != null);
 
       // Second step is to iterate of the elements in a predictable (sorted) order
-      propsToSort.sort().forEach(function (property) {
-        if (prop[property].constructor === Object) {
-          _iterate(prop[property]);
-        } else if (prop[property].constructor === Array) {
-          for (let i = 0; i < prop[property].length; i++) {
-            if (prop[property][i] instanceof DeferredConfig) {
-              deferred.push(prop[property][i].prepare(config, prop[property], i));
+      for (let name of propsToSort.sort()) {
+        const property = prop[name];
+
+        if (property.constructor === Object) {
+          _iterate(property);
+        } else if (property.constructor === Array) {
+          property.forEach(function (entry, i) {
+            if (entry instanceof DeferredConfig) {
+              deferred.push(entry.prepare(config, property, i));
             } else {
-              _iterate(prop[property][i]);
+              _iterate(property[i]);
+            }
+          });
+        } else if (property instanceof DeferredConfig) {
+            deferred.push(property.prepare(config, prop, name));
+        }
+        // else: Nothing to do. Keep the property how it is.
+      }
+    }
+
+    _iterate(config);
+
+    deferred.forEach((defer) => { defer.resolve() });
+  }
+
+  /**
+   * Used to resolve configs that have async functions.
+   *
+   * NOTE: Do not use `config.get` before executing this method, it will freeze the config object
+   *
+   * This replaces ./async.js, which is deprecated.
+   *
+   * @param config
+   * @returns {Promise<void>}
+   */
+  static async resolveAsyncConfigs(config) {
+    const promises = [];
+
+    await resolveAsyncConfigs(config);
+
+    function _iterate (prop) {
+      if (prop == null || prop.constructor === String) {
+        return;
+      }
+
+      // We put the properties we are going to look it in an array to keep the order predictable
+      const propsToSort = Object.keys(prop).filter((property) => prop[property] != null);
+
+      // Second step is to iterate of the elements in a predictable (sorted) order
+      for (let name of propsToSort.sort()) {
+        const property = prop[name];
+
+        if (property.constructor === Object) {
+          _iterate(property);
+        } else if (property.constructor === Array) {
+          for (let entry of property) {
+            if (entry instanceof Promise) {
+              promises.push(entry);
+            } else {
+              _iterate(entry);
             }
           }
-        } else {
-          if (prop[property] instanceof DeferredConfig) {
-            deferred.push(prop[property].prepare(config, prop, property));
-          }
-          // else: Nothing to do. Keep the property how it is.
+        } else if (property instanceof Promise) {
+          promises.push(property);
         }
-      });
+        // else: Nothing to do. Keep the property how it is.
+      }
     }
 
     _iterate(config);
 
-    deferred.forEach(function (defer) { defer.resolve(); });
+    await Promise.all(promises);
   }
 
   /**
@@ -649,6 +700,21 @@ class Util {
   static toObject(config) {
     return JSON.parse(JSON.stringify(config));
   }
+
+  /**
+   * Send a message to console.error once
+   * @param key {string} the subject of the error, used to prevent duplicates
+   * @param message {string} helpful message for library users
+   * @param [args] {object[]} additional arguments to console.error
+   */
+  static errorOnce(key, message, ...args) {
+    if (SEEN_ERRORS[key] === undefined) {
+      SEEN_ERRORS[key] = true;
+      let err = new Error;
+      Error.captureStackTrace(err, this.errorOnce);
+      console.error(message, ...args, err.stack);
+    }
+  }
 }
 
 /**
@@ -938,6 +1004,12 @@ class Load {
       throw new Error("Cannot parse config file: '" + fullFilename + "': " + e3);
     }
 
+    if (typeof configObject == 'function') {
+      let fn = configObject;
+
+      configObject = fn({ defer: deferConfig, util: Util });
+    }
+
     if (convert) {
       configObject = convert(configObject);
     }
@@ -1158,8 +1230,6 @@ class Load {
     }
 
     let configDir = env.initParam('NODE_CONFIG_DIR');
-    configDir = configDir && _toAbsolutePath(configDir);
-
     let appInstance = env.initParam('NODE_APP_INSTANCE');
     let gitCrypt = !env.initParam('CONFIG_SKIP_GITCRYPT');
     let parser = _loadParser(env.initParam('NODE_CONFIG_PARSER'), configDir);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "config",
-  "version": "4.2.1",
+  "version": "4.3.0",
   "main": "./lib/config.js",
   "description": "Configuration control for production node deployments",
   "author": "Loren West <open_source@lorenwest.com>",
@@ -29,6 +29,7 @@
     "c8": "^10.1.3",
     "coffeescript": "2.2.4",
     "cson": "^3.0.1",
+    "faceoff": "^1.3.0",
     "hjson": "^1.2.0",
     "properties": "~1.2.1",
     "request": "^2.88.2",
@@ -56,6 +57,8 @@
     "reporter": "lcov"
   },
   "scripts": {
-    "test": "NODE_OPTIONS='--no-experimental-strip-types' c8 node --test"
+    "ci": "npm run test && npm run benchmarks",
+    "test": "NODE_OPTIONS='--no-experimental-strip-types' c8 node --test",
+    "benchmarks": "node --allow-natives-syntax --expose-gc benchmarks/index.js"
   }
 }