Updated working version using multiple prototype chain implementation.

Author: Dr. Safi

module/multiplePrototypeChain/entrypoint.js

@@ -66,7 +66,10 @@ let self = class MultiplePrototypeChain {
                         return Reflect.set(delegatedPrototype, property, value)
                     break;
                 }
-            }
+            }, 
+            has: function(target, prop) {
+                return prop in delegatedPrototype
+            }          
         }
     }
 

module/multiplePrototypeChain/entrypoint.test.js

@@ -29,6 +29,11 @@ describe('Multiple Prototype Chain creation', () => {
             assert.strictEqual(newInstance.t, 't')                        
             assert.strictEqual(newInstance.delegatedPrototype.t, 't')                        
         })        
+
+        it('In operator should check in the delegatedPrototype', () => {
+            newInstance.b = 'b'
+            assert.strictEqual('b' in newInstance, true)                        
+        })        
 
         it('create new prototypes with corresponding delegatedPrototypes values equal to original proto chain', () => {
             // Subclass

module/reusableNestedUnit/Controller.class.js

@@ -85,7 +85,6 @@ module.exports = ({
             if(!(nestedUnitKey in this.instance.nestedUnit)) {
                 nestedUnitInstance = await this.callSubclass('NestedUnit', [nestedUnitKey])
                 await nestedUnitInstance.initializeInstance()
-                console.log(nestedUnitInstance)
                 // add children trees: 
                 nestedUnitInstance.additionalChildNestedUnit = additionalChildNestedUnit
                 // add pathPointerKey to allow applying additional corresponding additional children.

module/reusableNestedUnit/implementation/condition/NestedUnit.class.js

@@ -61,7 +61,6 @@ module.exports = ({ superclass }) => {
             let promiseArray = []
             promiseArray = conditionTreeChildren.map(conditionTreeChild => {
                 return new Promise(async (resolve, reject) => {
-                    let controllerInstancePrototype = this.__proto__.__proto__.__proto__
                     // Add the rest of the immediate children to the next tree as additional children. propagate children to the next tree.
 
                      if(this.children.length != 0) {
@@ -72,7 +71,6 @@ module.exports = ({ superclass }) => {
 
                     let callback = await this.initializeConditionTree({
                         nestedUnitKey: conditionTreeChild.nestedUnit, 
-                        controllerInstance: controllerInstancePrototype, 
                         additionalChildNestedUnit: this.children,
                         pathPointerKey: conditionTreeChild.pathPointerKey
                     })

module/reusableNestedUnit/implementation/condition/controllerMixin.mixin.js

@@ -10,18 +10,19 @@ export default Mixin(({ superclass }) => {
         /**
          * @description when first called "this" context is assigned to the AppInstance for the comming request. And on subsequest calls it is assigned to the nestedUnit instance.
          * 
-         * @param {any} {nestedUnitKey, controllerInstance = this} 
+         * @param {any} {nestedUnitKey} 
          * @returns 
          */
-        async initializeConditionTree({ nestedUnitKey, controllerInstance = this, additionalChildNestedUnit = [], pathPointerKey = null}) { // Entrypoint Instance
+        async initializeConditionTree({ nestedUnitKey, additionalChildNestedUnit = [], pathPointerKey = null}) { // Entrypoint Instance
             // self.debug.push(nestedUnitKey)
             // let nestedUnitInstance = await ConditionTree.createInstance(this.instance.nestedUnit, nestedUnitKey, ConditionTree.getDocumentQuery)
 
             // [1] get nestedUnit
-            let nestedUnitInstance = await this.getNestedUnit({ nestedUnitKey, controllerInstance, additionalChildNestedUnit, pathPointerKey })
+            let nestedUnitInstance = await this.getNestedUnit({ nestedUnitKey, additionalChildNestedUnit, pathPointerKey })
+            
             // [2] Check condition.
             let {conditionImplementation:unitKey} = nestedUnitInstance
-            let unitInstance = await this.getUnit({unitKey, controllerInstance})
+            let unitInstance = await this.getUnit({unitKey})
 
             let conditionMet = await unitInstance.checkCondition()
 

module/reusableNestedUnit/implementation/template/NestedUnit.class.js

@@ -61,7 +61,6 @@ module.exports = ({ superclass }) => {
             let renderedStringArray = []
             for (var index = 0; index < treeChildren.length; index++) {
                 let treeChild = treeChildren[index]
-                let controllerInstancePrototype = this.__proto__.__proto__.__proto__
                 // Add the rest of the immediate children to the next tree as additional children. propagate children to the next tree.
                 if(this.children.length != 0) {
                     await Array.prototype.push.apply(this.children, this.additionalChildNestedUnit)
@@ -71,7 +70,6 @@ module.exports = ({ superclass }) => {
                 let subsequentRenderedTemplate = [
                     await this.initializeNestedUnit({
                         nestedUnitKey: treeChild.nestedUnit,
-                        controllerInstance: controllerInstancePrototype,
                         additionalChildNestedUnit: this.children,
                         pathPointerKey: treeChild.pathPointerKey
                     })

module/reusableNestedUnit/implementation/template/controllerMixin.mixin.js

@@ -17,12 +17,12 @@ export default Mixin(({ superclass }) => {
             }
         }
 
-        async initializeNestedUnit({ nestedUnitKey, controllerInstance = this, additionalChildNestedUnit = [], pathPointerKey = null }) { // Entrypoint Instance
+        async initializeNestedUnit({ nestedUnitKey, additionalChildNestedUnit = [], pathPointerKey = null }) { // Entrypoint Instance
             // [1] get nestedUnit
-            let nestedUnitInstance = await this.getNestedUnit({ nestedUnitKey, controllerInstance, additionalChildNestedUnit, pathPointerKey })
+            let nestedUnitInstance = await this.getNestedUnit({ nestedUnitKey, additionalChildNestedUnit, pathPointerKey })
             // [2] get unit.
             let { viewImplementation: unitKey } = nestedUnitInstance
-            let unitInstance = await this.getUnit({ unitKey, controllerInstance })
+            let unitInstance = await this.getUnit({ unitKey })
             await unitInstance.pupolateTemplateFile()
 
             // views argument that will be initiallized inside templates:

utilityFunction/middleware/implementConditionActionOnModuleUsingJson.js

@@ -14,13 +14,14 @@ let MiddlewareController = createStaticInstanceClasses({
 export default ({setting}) => {
     return async (context, next) => {
         let isCalledNext = false
+        // console.log(setting)
         switch(setting.type) {
             case 'middlewareNestedUnit':
                 // await context.instance.handleMiddlewareNestedUnit(setting.name) // another way is to create a method in the instance class.        
                 const nestedUnitKey = setting.name
                 const portAppInstance = context.instance
                 let middlewareArray;
-                let middlewareController = await new MiddlewareController(false, { portAppInstance: portAppInstance })
+                let middlewareController = await MiddlewareController.createContext({ portAppInstance: portAppInstance })
                 middlewareArray = await middlewareController.initializeNestedUnit({ nestedUnitKey: nestedUnitKey })
                 await implementMiddlewareOnModuleUsingJson(middlewareArray)(context, next)
                 isCalledNext = true