Method makeImmutable

lib/util.js:159–230

* Make a javascript object immutable (assuring it cannot be changed from the current value) * * All attributes of that object are made immutable, including properties of contained * objects, recursively. * * This operation cannot be undone. * * Example: * *

(object)

   * @return object {Object} - The original object is returned - for chaining.
   */
  static makeImmutable(object) {
    if (Buffer.isBuffer(object)) {
      return object;
    }

    for (let propertyName of Object.keys(object)) {
      let value = object[propertyName];

      if (value instanceof RawConfig) {
        Object.defineProperty(object, propertyName, {
          value: value.resolve(),
          writable: false,
          configurable: false
        });
      } else if (Array.isArray(value)) {
        // Ensure object items of this array are also immutable.
        for (let item of value) {
          if (this.isObject(item) || Array.isArray(item)) {
            this.makeImmutable(item);
          }
        }

        Object.defineProperty(object, propertyName, {
          value: Object.freeze(value)
        });
      } else {
        // Call recursively if an object.
        if (this.isObject(value)) {
          // Create a proxy, to capture user updates of configuration options, and throw an exception for awareness, as per:
          // https://github.com/lorenwest/node-config/issues/514
          value = new Proxy(this.makeImmutable(value), {
            get(target, property, receiver) {
              // Bypass proxy receiver for properties directly on the target (e.g., RegExp.prototype.source)
              // or properties that are not functions to prevent errors related to internal object methods.
              if (Object.hasOwn(target, property) || (property in target && typeof target[property] !== 'function')) {
                return Reflect.get(target, property);
              }

              // Otherwise, use the proxy receiver to handle the property access
              const ref = Reflect.get(target, property, receiver);

              // Binds the method's `this` context to the target object (e.g., Date.prototype.toISOString)
              // to ensure it behaves correctly when called on the proxy.
              if (typeof ref === 'function') {
                return ref.bind(target);
              }
              return ref;
            },
            set(target, name) {
              const message = (Reflect.has(target, name) ? 'update' : 'add');
              // Notify the user.
              throw Error(`Can not ${message} runtime configuration property: "${name}". Configuration objects are immutable unless ALLOW_CONFIG_MUTATIONS is set.`)
            }
          });
        }

        // Check if property already has writable: false and configurable: false
        const currentDescriptor = Object.getOwnPropertyDescriptor(object, propertyName);