Source: instantiators/PrototypeWrapper.js

  1. /**
  2.  * @typedef Object PrototypeWrap
  3.  * @property {Object} targetPrototype The proxied and wired up prototype to use
  4.  * @property {Array} originalChain The original prototype chain to use later to restore the prototype
  5.  */
  7. /**
  8.  * The Prototype Wrapper will resolve dependencies up in the prototype tree.
  9.  * If you require a module which inherits other prototypes, this wrapper will insert proxies in
  10.  * between the inheritance steps which then will handle the dependency injections in the parent
  11.  * prototypes. You can still call super() with arguments in the constructor, the supplied arguments
  12.  * will then be appended to the injected properties in the constructor of the parent prototype.
  13.  *
  14.  * @author Wolfgang Felbermeier (@f3lang)
  15.  */
  16. class PrototypeWrapper {
  18. 	constructor(objectManager) {
  19. 		this.objectManager = objectManager;
  20. 	}
  22. 	/**
  23. 	 * Will wrap the node require and inject prototype proxies for the dependency injection.
  24. 	 * @param {String} module The path of the module to require
  25. 	 * @param {String} root The identifier of the tree to work in
  26. 	 * @param {String} requestId The id of the current injection request
  27. 	 * @return {PrototypeWrap} An Object containing the resolved prototype and the original chain
  28. 	 */
  29. 	require(module, root, requestId) {
  30. 		let mod = require(module);
  31. 		let prototypeChain = this.buildPrototypeChain(mod);
  32. 		if (prototypeChain.length === 1) {
  33. 			// no chain detected so we can continue with a regular require()
  34. 			return {targetPrototype: mod, originalChain: null};
  35. 		} else if (prototypeChain.length === 2) {
  36. 			// chain with one level of inheritance detected
  37. 			let targetPrototype = prototypeChain[0];
  38. 			let wrappedParentPrototype = this.wrapPrototype(prototypeChain[1], root, requestId + prototypeChain[1].name);
  39. 			Object.setPrototypeOf(targetPrototype, wrappedParentPrototype);
  40. 			return {targetPrototype, originalChain: prototypeChain};
  41. 		}
  42. 		// more complex chain detected with multiple levels of inheritance
  43. 		let originalChain = prototypeChain.slice();
  44. 		let i = prototypeChain.length;
  45. 		let targetPrototype = prototypeChain[i - 2];
  46. 		while (i-- && i > 1) {
  47. 			let upperPrototype = prototypeChain[i];
  48. 			let proxiedUpperPrototype = this.wrapPrototype(upperPrototype, root, requestId + upperPrototype.name);
  49. 			Object.setPrototypeOf(targetPrototype, proxiedUpperPrototype);
  50. 			prototypeChain[i - 1] = targetPrototype;
  51. 			targetPrototype = prototypeChain[i - 2];
  52. 		}
  53. 		Object.setPrototypeOf(targetPrototype, prototypeChain[1]);
  54. 		return {targetPrototype, originalChain};
  55. 	}
  57. 	/**
  58. 	 * Will traverse the prototype chain recursively up to the top and convert
  59. 	 * it to an array.
  60. 	 * @param {Object} prototype The prototype to build a chain for
  61. 	 * @return {Array} An array with all prototypes of the chain ordered from bottom to top.
  62. 	 */
  63. 	buildPrototypeChain(prototype) {
  64. 		let chain = [];
  65. 		chain.push(prototype);
  66. 		if (Object.getPrototypeOf(prototype) !== Object.getPrototypeOf(class {
  67. 			})) {
  68. 			chain.push(...this.buildPrototypeChain(Object.getPrototypeOf(prototype)));
  69. 		}
  70. 		return chain;
  71. 	}
  73. 	/**
  74. 	 * Will wrap a prototype in a proxy, that will inject the dependencies into the
  75. 	 * original prototype constructor.
  76. 	 * @param {Object} prototype The prototype to wrap
  77. 	 * @param {String} root The identifier of the tree to work in
  78. 	 * @param {String} requestId The id of the current injection request
  79. 	 * @return {Object} The wrapped prototype
  80. 	 */
  81. 	wrapPrototype(prototype, root, requestId) {
  82. 		let injectConfiguration = this.objectManager.getInjectionConfiguration(prototype.name);
  83. 		prototype.tree = root;
  84. 		if (!injectConfiguration || injectConfiguration.config.injectMap.length === 0) {
  85. 			return prototype;
  86. 		}
  87. 		let params = this.objectManager.getModuleParams(injectConfiguration.config.injectMap, root, requestId);
  88. 		return class extends prototype {
  89. 			constructor(...args) {
  90. 				module.exports.tree = root;
  91. 				super(...params, ...args);
  92. 			}
  93. 		};
  94. 	}
  96. 	/**
  97. 	 * After instantiation of the module it is important to restore the original
  98. 	 * prototype tree, since node will somehow cache it, which will lead to problems
  99. 	 * when traversing the tree again.
  100. 	 * @param {Array} originalChain The original prototype chain as an Array
  101. 	 */
  102. 	restoreOriginalPrototypeChain(originalChain) {
  103. 		if (originalChain.length === 2) {
  104. 			Object.setPrototypeOf(originalChain[0], originalChain[1]);
  105. 			return;
  106. 		}
  107. 		let i = originalChain.length - 1;
  108. 		while (i--) {
  109. 			Object.setPrototypeOf(originalChain[i], originalChain[i + 1]);
  110. 		}
  111. 	}
  113. }
  115. module.exports = PrototypeWrapper;
  116. module.exports.inject = ['ObjectManager'];