Refactoring - Aggregated common patterns into decorators.

Cleanning code, removing duplication and refactoring to use decorators.

Author: Dr. Safi

class/Application.class.js

@@ -8,26 +8,19 @@ import _ from '../../../node_modules/underscore' // To affect changes of _ to th
 import { connect } from 'appscript/utilityFunction/middleware/commonDatabaseFunctionality.js'
 import { add, execute, applyMixin } from 'appscript/utilityFunction/decoratorUtility.js'
 import addStaticSubclassToClassArray from 'appscript/module/addStaticSubclassToClassArray.staticMethod'
+import { extendedSubclassPattern } from 'appscript/utilityFunction/extendedSubclassPattern.js'
 
 const self = 
 @add({ to: 'static'}, {
     addStaticSubclassToClassArray
 })
+@extendedSubclassPattern.Superclass()
 class Application extends EventEmitter {
 
-    static eventEmitter = (new EventEmitter()).setMaxListeners(200) // increase maximum eventliseners (default = 10) // i.e. new EventEmitter()
     static rethinkdbConnection = {}
     static config = configuration // Array
     static frontend;
-    static extendedSubclass = {
-        static: []
-    }
 
-    constructor(skipConstructor = false) {
-        super();
-        if(skipConstructor) return;
-    }
-
     static async initialize(/*staticSubclass*/) { // One-time initialization of Applicaiton Class.
         console.info(`☕%c Running Application as ${self.config.DEPLOYMENT} - '${self.config.PROTOCOL}${self.config.HOST}'`, self.config.style.green)
         self.rethinkdbConnection = await connect()
@@ -37,17 +30,11 @@ class Application extends EventEmitter {
             escape: /\{\%-(.+?)\%\}/g
         };
         await self.eventEmitter.emit('initializationEnd')
+        await self.eventEmitter.emit('addSubclass')
         // if(staticSubclass) self.addStaticSubclassToClassArray(staticSubclass)
     }
 
 // Used by extended subclasses:
-    // Add subclasses to list
-    static addSubclass({ keyName, Subclass = this } = {}) {
-        if(!keyName) keyName = Subclass.name
-        self.eventEmitter.on('initializationEnd', () => {
-            self.extendedSubclass.static[keyName] = Subclass
-        })
-    }
 
     static initializeStaticClass() { // used for extended subclasses
         let self = this
@@ -59,7 +46,7 @@ class Application extends EventEmitter {
         if(middlewareArray) self.middlewareArray = middlewareArray
         await self.middlewareArray.forEach((middleware) => {
             self.serverKoa.use(middleware)
-        }, this);
+        }, this)
     }
 
     static createKoaServer() {

module/reusableNestedUnit/Controller.class.js

@@ -1,13 +1,34 @@
 import commonMethod from './commonMethod.mixin'
-const EventEmitter = require('events')
 import createInstance from 'appscript/module/createInstance.staticMethod'
 import { usingGenericInstance as populateInstancePropertyFromJson, usingThis as populateInstancePropertyFromJson_this } from 'appscript/module/populateInstancePropertyFromJson.method'
 import addStaticSubclassToClassArray from 'appscript/module/addStaticSubclassToClassArray.staticMethod'
 import { classDecorator as prototypeChainDebug} from 'appscript/module/prototypeChainDebug'
-import { MultiplePrototypeChain } from 'appscript/module/multiplePrototypeChain'
-import { add, execute, applyMixin } from 'appscript/utilityFunction/decoratorUtility.js'
+import { add, execute, applyMixin, conditional } from 'appscript/utilityFunction/decoratorUtility.js'
+import { extendedSubclassPattern } from 'appscript/utilityFunction/extendedSubclassPattern.js'
+import { superclassInstanceContextPattern } from 'appscript/utilityFunction/superclassInstanceContextPattern.js'
 import { mix } from 'mixwith'
 
+function cacheInstance({ cacheArrayName, keyArgumentName = 'key' }) { // decorator + proxy
+    return (target, name, descriptor) => {
+        let method = target[name]
+        descriptor.value = new Proxy(method, {
+            apply: async (target, thisArg, argumentsList) => {
+                let [{ [keyArgumentName]: key }] = argumentsList // extract key using the specified key parameter name in the method.
+                let cacheArray = thisArg.instance[cacheArrayName] // Sub array of 'this.instance' in which instances are saved.
+                let instance;
+                if(key in cacheArray) {
+                    instance = cacheArray[key]
+                } else {
+                    instance = await target.apply(thisArg, argumentsList)
+                    cacheArray[key] = instance // add to class cache
+                }
+                return instance
+            }          
+        })
+        return descriptor
+    }
+}
+
 /**
  * @class
  * @usage new instance is created for each check.
@@ -19,7 +40,7 @@ export default ({
 }) => {
     let mixinArray = [/*commonMethod*/]
     let self = 
-        @prototypeChainDebug
+        @conditional({ decorator: prototypeChainDebug, condition: process.env.SZN_DEBUG })
         @add({ to: 'static'}, { 
             createInstance,
             populateInstancePropertyFromJson,
@@ -28,112 +49,34 @@ export default ({
         @add({ to: 'prototype'}, {
             populateInstancePropertyFromJson_this
         })
-        @execute({ staticMethod: 'initializeStaticClass' })
-        @applyMixin({ mixin })
+        @conditional({ condition: mixin, decorator: applyMixin({ mixin }) })
+        @extendedSubclassPattern.Superclass()
+        @superclassInstanceContextPattern()
+        @conditional({ decorator: extendedSubclassPattern.Subclass(), condition: (methodInstanceName && Superclass) })
         class ReusableController extends mix(Superclass).with(...mixinArray) {
 
-            static eventEmitter = new EventEmitter() // i.e. new EventEmitter()
-            static extendedSubclass = {
-                static: {}
-            }
-
-            static initializeStaticClass(self) {
-                // Mutation observer on array for debugging purposes.
-                // self.extendedSubclass.static = new Proxy(self.extendedSubclass.static, {
-                //     set: function(target, property, value, receiver) {      
-                //         target[property] = value;
-                //         console.log(self.extendedSubclass.static)
-                //       return true;
-                //     }
-                // })
-        
-                if(methodInstanceName && Superclass && Superclass.eventEmitter) {
-                    super.eventEmitter.on('initializationEnd', () => {
-                        let ClassObject = {}
-                        ClassObject[`${methodInstanceName}`] = self
-                        super.addStaticSubclassToClassArray(ClassObject)
-                    })
-                }
-            }
-
-            static initializeStaticClassControllerLevel() {
-                let Class = this
-                Class.eventEmitter.on('initializationEnd', () => {
-                    let ClassObject = {}
-                    ClassObject[`${Class.name}`] = Class
-                    Class.addStaticSubclassToClassArray(ClassObject)
-                })
-            }
-
-            static createContext(...args) {
-                let self = this // specific Controller that is a subclass of 'self' (ReusableController)
-                let contextInstance = new self(false, ...args)
-
-                // create a new list object for proxied refrence of subclasses
-                contextInstance.instanceExtendedSubclass = Object.keys(self.extendedSubclass.static)
-                    .reduce((object, key) => {
-                        // add proxied subclass to the list
-                        object[key] = MultiplePrototypeChain.newChainOnInstanceCreation({
-                            Class: self.extendedSubclass.static[key],
-                            contextInstance
-                        })
-                        return object
-                    }, {})
-                return contextInstance
-            }
-
-            static callSubclass(name, args) {
-                return Reflect.construct(self.extendedSubclass.static[name], args)
-            }
-
-            /**
-             * Properties on instnace object (not on the prototype)
-             */
-            AppInstance; // calling instance that contains the context
-            instance = {
-                nestedUnit: [],
-                unit: [],
-            } 
-            // conditionTreeKey -> { Json data, properties } 
-
-            constructor(skipConstructor = false, {portAppInstance}) {
-                super(true)
-                if(skipConstructor) return;
-                if(portAppInstance) this.AppInstance = portAppInstance
-            }
-
-            callSubclass(name, args) {
-                let contextInstance = this
-                return Reflect.construct(contextInstance.instanceExtendedSubclass[name], args)
-            }
-
+            @cacheInstance({ 
+                cacheArrayName: 'nestedUnit',
+                keyArgumentName: 'nestedUnitKey'
+            })
             async getNestedUnit({ nestedUnitKey, additionalChildNestedUnit = [], pathPointerKey = null}) {
-                let nestedUnitInstance;
-                if(!(nestedUnitKey in this.instance.nestedUnit)) {
-                    nestedUnitInstance = await this.callSubclass('NestedUnit', [nestedUnitKey])
-                    await nestedUnitInstance.initializeInstance()
-                    // add children trees: 
-                    nestedUnitInstance.additionalChildNestedUnit = additionalChildNestedUnit
-                    // add pathPointerKey to allow applying additional corresponding additional children.
-                    nestedUnitInstance.pathPointerKey = pathPointerKey
-                    // add to class cache
-                    this.instance.nestedUnit[nestedUnitKey] = nestedUnitInstance
-                } else {
-                    nestedUnitInstance = this.instance.nestedUnit[nestedUnitKey]
-                }
-                return nestedUnitInstance
+                let instance = await this.callSubclass('NestedUnit', [nestedUnitKey])
+                await instance.initializeInstance()
+                // add children trees: 
+                instance.additionalChildNestedUnit = additionalChildNestedUnit
+                // add pathPointerKey to allow applying additional corresponding additional children.
+                instance.pathPointerKey = pathPointerKey
+                return instance
             }
 
-            async getUnit({unitKey}) {
-                let unitInstance;
-                if(!(unitKey in this.instance.unit)) {
-                    unitInstance = await this.callSubclass('Unit', [unitKey])
-                    await unitInstance.initializeInstance()
-                    this.instance.unit[unitKey] = unitInstance
-                } else {
-                    unitInstance = this.instance.unit[unitKey]
-                }
-                return unitInstance
+            @cacheInstance({ 
+                cacheArrayName: 'unit',
+                keyArgumentName: 'unitKey'
+            })
+            async getUnit({ unitKey }) {
+                let instance = await this.callSubclass('Unit', [unitKey])
+                await instance.initializeInstance()
+                return instance
             }
 
         }

module/reusableNestedUnit/NestedUnit.class.js

@@ -1,18 +1,19 @@
 import { classDecorator as prototypeChainDebug} from 'appscript/module/prototypeChainDebug'
+import { add, execute, applyMixin, conditional } from 'appscript/utilityFunction/decoratorUtility.js'
 
 export default ({ Superclass }) => {
-    let self = @prototypeChainDebug
+    let self = 
+    @conditional({ decorator: prototypeChainDebug, condition: process.env.SZN_DEBUG })
     class RNestedUnit extends Superclass {
 
         static getDocumentQuery;
 
         static initializeStaticClass(self, getTableDocument) {
-            super.initializeStaticClassControllerLevel()
             self.getDocumentQuery = getTableDocument
         }
 
-        constructor(databaseDocumentKey, AppInstance) {
-            super(false, {portAppInstance: AppInstance})
+        constructor(databaseDocumentKey) {
+            super()
             this.key = databaseDocumentKey
             return this
         }

module/reusableNestedUnit/Unit.class.js

@@ -1,18 +1,19 @@
 import { classDecorator as prototypeChainDebug} from 'appscript/module/prototypeChainDebug'
+import { add, execute, applyMixin, conditional } from 'appscript/utilityFunction/decoratorUtility.js'
 
 export default ({ Superclass }) => {
-    let self = @prototypeChainDebug 
+    let self =
+    @conditional({ decorator: prototypeChainDebug, condition: process.env.SZN_DEBUG })
     class RUnit extends Superclass {
 
         static getDocumentQuery;
 
         static initializeStaticClass(self, getTableDocument) {
             self.getDocumentQuery = getTableDocument
-            super.initializeStaticClassControllerLevel()
         }
 
-        constructor(databaseDocumentKey, AppInstance) {
-            super(false, {portAppInstance: AppInstance})
+        constructor(databaseDocumentKey) {
+            super()
             this.key = databaseDocumentKey
             return this
         }

module/reusableNestedUnit/entrypoint.js

@@ -91,7 +91,7 @@ function createStaticInstanceClasses({
     let Unit = UnitFunc({ Superclass: Controller })
     SpecificNestedUnitFunc({ Superclass: NestedUnit })
     SpecificUnitFunc({ Superclass: Unit })
-    Controller.eventEmitter.emit('initializationEnd') // register subclasses that are listening for the event to register themselves in extendedSubclass.static array.
+    Controller.eventEmitter.emit('addSubclass') // register subclasses that are listening for the event to register themselves in extendedSubclass.static array.
 
     // return Controller in which it holds the tree structure.
     return Controller

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

@@ -1,6 +1,7 @@
 import r from 'rethinkdb'
 import { classDecorator as prototypeChainDebug} from 'appscript/module/prototypeChainDebug'
-import { add, execute } from 'appscript/utilityFunction/decoratorUtility.js'
+import { add, execute, applyMixin, conditional } from 'appscript/utilityFunction/decoratorUtility.js'
+import { extendedSubclassPattern } from 'appscript/utilityFunction/extendedSubclassPattern.js'
 
 let getTableDocument = {
     generate: require('appscript/utilityFunction/database/query/getTableDocument.query.js'),
@@ -11,11 +12,12 @@ import promiseProperRace from 'appscript/utilityFunction/promiseProperRace.js'
 
 export default ({ Superclass }) => {
     let self = 
-        @prototypeChainDebug
+        @conditional({ decorator: prototypeChainDebug, condition: process.env.SZN_DEBUG })
         @execute({
             staticMethod: 'initializeStaticClass', 
             args: [ getTableDocument.instance['condition_conditionTree'] ] 
         })
+        @extendedSubclassPattern.Subclass()
         class NestedUnit extends Superclass {
             // static getDocumentQuery(connection, conditionTreeKey) {
             //     getConditionTreeQuery(connection, conditionTreeKey)
@@ -89,7 +91,7 @@ export default ({ Superclass }) => {
                 let callback;
                 await promiseProperRace(promiseArray).then((promiseReturnValueArray) => {
                     callback = promiseReturnValueArray[0] // as only one promise is return in the array.
-                }).catch(reason => { if(process.env.SZN_DEBUG == 'true' && this.AppInstance.context.headers.debug == 'true') console.log(`🔀⚠️ promiseProperRace rejected because: ${reason}`) })
+                }).catch(reason => { if(process.env.SZN_DEBUG == 'true' && this.portAppInstance.context.headers.debug == 'true') console.log(`🔀⚠️ promiseProperRace rejected because: ${reason}`) })
                 return callback ? callback : false;
             }
 

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

@@ -1,5 +1,6 @@
 import { classDecorator as prototypeChainDebug} from 'appscript/module/prototypeChainDebug'
-import { add, execute } from 'appscript/utilityFunction/decoratorUtility.js'
+import { add, execute, applyMixin, conditional } from 'appscript/utilityFunction/decoratorUtility.js'
+import { extendedSubclassPattern } from 'appscript/utilityFunction/extendedSubclassPattern.js'
 
 let getTableDocument = {
     generate: require('appscript/utilityFunction/database/query/getTableDocument.query.js'),
@@ -10,11 +11,12 @@ getTableDocument.instance['condition_conditionImplementation'] = getTableDocumen
 
 export default ({ Superclass }) => {
     let self = 
-        @prototypeChainDebug
+        @conditional({ decorator: prototypeChainDebug, condition: process.env.SZN_DEBUG })
         @execute({
             staticMethod: 'initializeStaticClass', 
             args: [ getTableDocument.instance['condition_conditionImplementation'] ] 
         })
+        @extendedSubclassPattern.Subclass()
         class Unit extends Superclass {
             async checkCondition() {
                 // [1] get valueReturningFile
@@ -26,8 +28,8 @@ export default ({ Superclass }) => {
                 if(!this.conditionResult) {
                     let expectedReturn = this.expectedReturn
                     let filePath = this.valueReturningFile.filePath
-                    let returnedValue = await require(filePath)(this.AppInstance)
-                    if(process.env.SZN_DEBUG == 'true' && this.AppInstance.context.headers.debug == 'true') console.log(`🔀 Comparing conditionKey: ${this.key} ${filePath}. \n • expected: ${expectedReturn} == ${returnedValue}. \n • compare result: ${(returnedValue == expectedReturn)} \n \n`)
+                    let returnedValue = await require(filePath)(this.portAppInstance)
+                    if(process.env.SZN_DEBUG == 'true' && this.portAppInstance.context.headers.debug == 'true') console.log(`🔀 Comparing conditionKey: ${this.key} ${filePath}. \n • expected: ${expectedReturn} == ${returnedValue}. \n • compare result: ${(returnedValue == expectedReturn)} \n \n`)
                     this.conditionResult = (returnedValue == expectedReturn) ? true : false;            
                 }
                 return  this.conditionResult

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

@@ -1,12 +1,13 @@
 import { Mixin } from 'mixwith'
 import { classDecorator as prototypeChainDebug} from 'appscript/module/prototypeChainDebug'
+import { add, execute, applyMixin, conditional } from 'appscript/utilityFunction/decoratorUtility.js'
 
 /**
  * @description Extends a class by super class and adds some common functionality.
  */
 export default Mixin(({ Superclass }) => {
     let self = 
-    @prototypeChainDebug
+    @conditional({ decorator: prototypeChainDebug, condition: process.env.SZN_DEBUG })    
     class ConditionMixin extends Superclass {
 
         /**