Working on new implementation for shellscript nestedUnit.

Added controller, nestedUnit, unit implementations and support for related execution methods in nestedUnit module.

Author: Dr. Safi

module/reusableNestedUnit/Controller.class.js

@@ -14,7 +14,7 @@ import { mix } from 'mixwith'
  */
 export default ({
     methodInstanceName,
-    Superclass,
+    Superclass = Object,
     mixin
 }) => {
     let mixinArray = [/*commonMethod*/]

module/reusableNestedUnit/NestedUnit.class.js

@@ -81,6 +81,15 @@ export default ({ Superclass }) => {
                         if (returned) break
                     }
                     return returned;
+                break;
+                case 'executeScript':
+                    for (let insertionPoint of this.insertionPoint) {
+                        // [1] get children immediate & relating to this insertion position.
+                        let children = await this.filterAndOrderChildren({ insertionPointKey: insertionPoint.key })                
+                        // let children = await this.filterChildrenOfCurrentInsertionPoint({ insertionPointKey: insertionPoint.key })
+                        await this.initializeInsertionPoint({ insertionPoint, children })
+                    }
+                break;
                 default:
                     console.log(`"${type}" type doesn\'t match any kind.`)
                 break;
@@ -190,6 +199,9 @@ export default ({ Superclass }) => {
             // [2] check type of subtrees execution: race first, all ... .
             let callback;
             switch(insertionPoint.executionType) { // execution type callback name
+                case 'allPromise': 
+                    callback = 'initializeNestedUnitInAllPromiseExecutionType'
+                break;
                 case 'raceFirstPromise': 
                     callback = 'initializeNestedUnitInRaceExecutionType'
                 break;
@@ -259,6 +271,36 @@ export default ({ Superclass }) => {
             return callback ? callback : false;
         }
 
+        async initializeNestedUnitInAllPromiseExecutionType(children) {
+            let promiseArray = []
+            promiseArray = children.map(conditionTreeChild => {
+                return new Promise(async (resolve, reject) => {
+                    // 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)
+                    } else {
+                        this.children = await this.additionalChildNestedUnit.slice()
+                    }
+
+                    await this.initializeNestedUnit({
+                        nestedUnitKey: conditionTreeChild.nestedUnit, 
+                        additionalChildNestedUnit: this.children,
+                        pathPointerKey: conditionTreeChild.pathPointerKey
+                    })
+                    resolve()
+                })
+            })
+
+            await Promise.all(promiseArray).then(() => {
+            }).catch(reason => { 
+                if(process.env.SZN_DEBUG == 'true') console.log(`🔀⚠️ promiseProperRace rejected because: ${reason}`) 
+                process.exit(1)
+            })
+            return;
+        }
+
+        
     }
 
     return self

module/reusableNestedUnit/entrypoint.js

@@ -23,7 +23,7 @@ let counter = [] // allows to have a unique set of relations among different nes
  * @return {Object} Related Classes 
  */
 function createStaticInstanceClasses({
-    Superclass, /* Usually the higher Application class */
+    Superclass = Object, /* Usually the higher Application class */
     implementationType,
     cacheName = false /* {Boolean || String} */
 }) {
@@ -46,6 +46,9 @@ function createStaticInstanceClasses({
         case 'Template':
             implementationConfig = require('./implementation/template')
         break;
+        case 'Shellscript':
+            implementationConfig = require('./implementation/shellscript')
+        break;
 
         default:
             console.log('⚠️ No implementation chosen for building class tree in ReusableNestedUnit.')

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

@@ -0,0 +1,24 @@
+import r from 'rethinkdb'
+import { classDecorator as prototypeChainDebug} from 'appscript/module/prototypeChainDebug'
+import { add, execute, applyMixin, conditional } from 'appscript/utilityFunction/decoratorUtility.js'
+import promiseProperRace from 'appscript/utilityFunction/promiseProperRace.js'
+import { extendedSubclassPattern } from 'appscript/utilityFunction/extendedSubclassPattern.js'
+import { curried as getTableDocumentCurried } from "appscript/utilityFunction/database/query/getTableDocument.query.js";
+
+let getDocument = {
+    NestedUnit: getTableDocumentCurried({ documentId: 'shellscript_nestedUnit'})
+}
+
+export default ({ Superclass }) => {
+    let self = 
+        @conditional({ decorator: prototypeChainDebug, condition: process.env.SZN_DEBUG })
+        @execute({
+            staticMethod: 'initializeStaticClass', 
+            args: [ getDocument['NestedUnit'] ] 
+        })
+        @extendedSubclassPattern.Subclass()            
+        class NestedUnit extends Superclass {
+        }
+    
+    return self
+}

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

@@ -0,0 +1,24 @@
+import { classDecorator as prototypeChainDebug} from 'appscript/module/prototypeChainDebug'
+import { add, execute, applyMixin, conditional } from 'appscript/utilityFunction/decoratorUtility.js'
+import { extendedSubclassPattern } from 'appscript/utilityFunction/extendedSubclassPattern.js'
+import { curried as getTableDocumentCurried } from "appscript/utilityFunction/database/query/getTableDocument.query.js";
+
+let getDocument = {
+    'Unit': getTableDocumentCurried({ documentId: 'shellscript_unit' })
+}
+
+export default ({ Superclass }) => {
+    let self = 
+        @conditional({ decorator: prototypeChainDebug, condition: process.env.SZN_DEBUG })
+        @execute({
+            staticMethod: 'initializeStaticClass', 
+            args: [ getDocument['Unit'] ]
+        })
+        @extendedSubclassPattern.Subclass()
+        class Unit extends Superclass {
+            async executeScript() {
+                console.log(this)
+            }
+        }
+    return self
+}

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

@@ -0,0 +1,36 @@
+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 = 
+    @conditional({ decorator: prototypeChainDebug, condition: process.env.SZN_DEBUG })    
+    class ShellscriptMixin extends 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} 
+         * @returns { Object || False } Object containing instruction settings to be used through an implementing module.
+         */
+        async initializeNestedUnit({ nestedUnitKey, additionalChildNestedUnit = [], pathPointerKey = null}) { // Entrypoint Instance           
+            // [1] get nestedUnit
+            let nestedUnitInstance = await this.getNestedUnit({ nestedUnitKey, additionalChildNestedUnit, pathPointerKey })
+            
+            if(nestedUnitInstance.unit) {
+                let { unit: unitKey} = nestedUnitInstance
+                let unitInstance = await this.getUnit({ unitKey })
+                // execute command
+                await unitInstance.executeScript()
+            }
+            
+            // [3] Iterate over insertion points
+            await nestedUnitInstance.loopInsertionPoint({ type: 'executeScript' })
+        }        
+    }
+    
+    return self
+})

module/reusableNestedUnit/implementation/shellscript/entrypoint.js

@@ -0,0 +1,9 @@
+import ControllerMixin from './controllerMixin.mixin'
+import NestedUnitFunction from './NestedUnit.class.js'
+import UnitFunction from './Unit.class.js'
+
+export default {
+    ControllerMixin,
+    NestedUnitFunction,
+    UnitFunction
+}

module/reusableNestedUnit/implementation/shellscript/package.json

@@ -0,0 +1,5 @@
+{
+    "name": "middleware",
+    "version": "0.1.0",
+    "main": "entrypoint.js"
+}