loopback-datasource-juggler/lib/jutil.js

var util = require('util');
/**
 *
 * @param newClass
 * @param baseClass
 */
exports.inherits = function (newClass, baseClass, options) {
  util.inherits(newClass, baseClass);

  options = options || {
    staticProperties: true,
    override: false
  };

  if (options.staticProperties) {
    Object.keys(baseClass).forEach(function (classProp) {
      if (classProp !== 'super_' && (!newClass.hasOwnProperty(classProp)
        || options.override)) {
        var pd = Object.getOwnPropertyDescriptor(baseClass, classProp);
        Object.defineProperty(newClass, classProp, pd);
      }
    });
  }
};

/**
 * Mix in the a class into the new class
 * @param newClass The target class to receive the mixin
 * @param mixinClass The class to be mixed in
 * @param options
 */
exports.mixin = function (newClass, mixinClass, options) {
  if (Array.isArray(newClass._mixins)) {
    if (newClass._mixins.indexOf(mixinClass) !== -1) {
      return;
    }
    newClass._mixins.push(mixinClass);
  } else {
    newClass._mixins = [mixinClass];
  }

  options = options || {
    staticProperties: true,
    instanceProperties: true,
    override: false,
    proxyFunctions: false
  };

  if (options.staticProperties === undefined) {
    options.staticProperties = true;
  }

  if (options.instanceProperties === undefined) {
    options.instanceProperties = true;
  }

  if (options.staticProperties) {
    var staticProxies = [];
    Object.keys(mixinClass).forEach(function (classProp) {
      if (classProp !== 'super_' && classProp !== '_mixins'
        && (!newClass.hasOwnProperty(classProp) || options.override)) {
        var pd = Object.getOwnPropertyDescriptor(mixinClass, classProp);
        if (options.proxyFunctions && pd.writable
          && typeof pd.value === 'function') {
          pd.value = exports.proxy(pd.value, staticProxies);
        }
        Object.defineProperty(newClass, classProp, pd);
      }
    });
  }

  if (options.instanceProperties) {
    if (mixinClass.prototype) {
      var instanceProxies = [];
      Object.keys(mixinClass.prototype).forEach(function (instanceProp) {
        if (!newClass.prototype.hasOwnProperty(instanceProp) || options.override) {
          var pd = Object.getOwnPropertyDescriptor(mixinClass.prototype, instanceProp);
          if (options.proxyFunctions && pd.writable && typeof pd.value === 'function') {
            pd.value = exports.proxy(pd.value, instanceProxies);
          }
          Object.defineProperty(newClass.prototype, instanceProp, pd);
        }
      });
    }
  }

  return newClass;
};

exports.proxy = function (fn, proxies) {
  // Make sure same methods referenced by different properties have the same proxy
  // For example, deleteById is an alias of removeById
  proxies = proxies || [];
  for (var i = 0; i < proxies.length; i++) {
    if (proxies[i]._delegate === fn) {
      return proxies[i];
    }
  }
  var f = function () {
    return fn.apply(this, arguments);
  };
  f._delegate = fn;
  proxies.push(f);
  Object.keys(fn).forEach(function (x) {
    f[x] = fn[x];
  });
  return f;
};