Merge branch 'shellScript_nestedUnitImplementation'

Author: Dr. Safi

module/prototypeChainDebug/entrypoint.js

@@ -3,6 +3,7 @@
  * Returns a proxy with traps to add meta information.
  */
 function prototypeChainDebug(Class) {
+
     // Static class
     Class.meta = {
         Class: `${Class.name}`,

module/reusableNestedUnit/Controller.class.js

@@ -1,3 +1,4 @@
+const EventEmitter = require('events');
 import commonMethod from './commonMethod.mixin'
 import createInstance from 'appscript/module/createInstance.staticMethod'
 import { usingGenericInstance as populateInstancePropertyFromJson, usingThis as populateInstancePropertyFromJson_this } from 'appscript/module/populateInstancePropertyFromJson.method'
@@ -14,12 +15,12 @@ import { mix } from 'mixwith'
  */
 export default ({
     methodInstanceName,
-    Superclass = Object,
-    mixin
+    Superclass = EventEmitter, // defaulting to EventEmitter and not Object / Function because extending Object/Function manipulates this prototype in new calls for some reason.
+    mixin, 
+    rethinkdbConnection = Superclass.rethinkdbConnection
 }) => {
     let mixinArray = [/*commonMethod*/]
     let self = 
-        @conditional({ decorator: prototypeChainDebug, condition: process.env.SZN_DEBUG })
         @add({ to: 'static'}, { 
             createInstance,
             populateInstancePropertyFromJson,
@@ -28,11 +29,14 @@ export default ({
         @add({ to: 'prototype'}, {
             populateInstancePropertyFromJson_this
         })
-        @conditional({ condition: mixin, decorator: applyMixin({ mixin }) })
+        @conditional({ decorator: prototypeChainDebug, condition: process.env.SZN_DEBUG })
         @extendedSubclassPattern.Superclass()
-        @superclassInstanceContextPattern()
-        @conditional({ decorator: extendedSubclassPattern.Subclass(), condition: (methodInstanceName && Superclass) })
+        @conditional({ decorator: extendedSubclassPattern.Subclass(), condition: (methodInstanceName && Superclass && Superclass.addSubclass != undefined ) })
+        @conditional({ condition: mixin, decorator: applyMixin({ mixin }) })
+        @superclassInstanceContextPattern() // applied on the mixin i.e. specific controller.
         class ReusableController extends mix(Superclass).with(...mixinArray) {
+            
+            static rethinkdbConnection = rethinkdbConnection
 
             @cacheInstance({ 
                 cacheArrayName: 'nestedUnit',

module/reusableNestedUnit/entrypoint.js

@@ -23,10 +23,11 @@ let counter = [] // allows to have a unique set of relations among different nes
  * @return {Object} Related Classes 
  */
 function createStaticInstanceClasses({
-    Superclass = Object, /* Usually the higher Application class */
+    Superclass, /* Usually the higher Application class */
     implementationType,
-    cacheName = false /* {Boolean || String} */
-}) {
+    cacheName = false, /* {Boolean || String} */
+    rethinkdbConnection
+} = {}) {
     // Used as caching key.
     let automaticCacheNaming;
     if(cacheName && typeof cacheName == 'boolean') {
@@ -88,7 +89,8 @@ function createStaticInstanceClasses({
     let Controller = ControllerFunc({
         methodInstanceName: cacheName,
         Superclass,
-        mixin: implementationConfig.ControllerMixin
+        mixin: implementationConfig.ControllerMixin, 
+        rethinkdbConnection
     })
     let NestedUnit = NestedUnitFunc({ Superclass: Controller })
     let Unit = UnitFunc({ Superclass: Controller })

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

@@ -2,6 +2,7 @@ import { classDecorator as prototypeChainDebug} from 'appscript/module/prototype
 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";
+import { exec, spawn, spawnSync } from 'child_process'
 
 let getDocument = {
     'Unit': getTableDocumentCurried({ documentId: 'shellscript_unit' })
@@ -17,7 +18,25 @@ export default ({ Superclass }) => {
         @extendedSubclassPattern.Subclass()
         class Unit extends Superclass {
             async executeScript() {
-                console.log(this)
+                let message = ` _____                          _        
+| ____|__  __ ___   ___  _   _ | |_  ___ 
+|  _|  \\ \\/ // _ \\ / __|| | | || __|/ _ \\
+| |___  >  <|  __/| (__ | |_| || |_|  __/    
+|_____|/_/\\_\\\\___| \\___| \\__,_| \\__|\\___|
+${this.command} ${this.argument}`;
+                switch (this.implementation) {
+                    case 'spawn':
+                        console.log(message)
+                        spawnSync(this.command, this.argument, this.option)
+                    break;
+                    case 'spawnAsynchronous':
+                        console.log(message)
+                        spawn(this.command, this.argument, this.option)
+                    break;
+                    default:
+                        console.log('shellscriptUnit.implementation does not match any option.')
+                    break;
+                }
             }
         }
     return self

utilityFunction/database/initializeDatabase.query.js

@@ -0,0 +1,35 @@
+import rethinkDB from 'rethinkdb' 
+
+export async function createDatabase(databaseName, connection) {
+    let databaseExists = await rethinkDB.dbList().contains(databaseName).run(connection);
+    if(!databaseExists) {
+        let dbCreationResponse = await rethinkDB.dbCreate(databaseName).run(connection)
+        
+        // .do(function(databaseExists) {
+        //   return rethinkDB.branch(
+        //     databaseExists,
+        //     { dbs_created: 0 },
+        //     rethinkDB.dbCreate('webapp')
+        //   );
+        // })
+
+        if(dbCreationResponse.dbs_created > 0)  console.log(`📢 ${databaseName} database created !`)
+    } else {
+        console.log(`📢📁 ${databaseName} database already exists !`)            
+    }
+}
+
+export async function createTableAndInsertData(databaseName, databaseData, connection) {
+    for (let tableData of databaseData) {
+        await rethinkDB.db(databaseName).tableCreate(tableData.databaseTableName).run(connection)
+            .then(async tableCreationResponse => {
+                if(tableCreationResponse.tables_created > 0) console.log(`📢 ${tableData.databaseTableName} table created.`)
+                await rethinkDB.db(databaseName).table(tableData.databaseTableName).insert(tableData.data).run(connection)
+                    .then(response => {
+                        console.log(`📢📥 ${response.inserted} documents inserted to ${tableData.databaseTableName}.`)
+                    })
+                    .catch(error => console.log(error))
+            })
+            .catch(error => console.log(`📢 ${tableData.databaseTableName} table already exists.`))
+    }
+}

utilityFunction/superclassInstanceContextPattern.js

@@ -13,7 +13,7 @@ export function superclassInstanceContextPattern() {
 
             // loop over arguments and add properties
             // contextInstance.portAppInstance // calling instance that contains the context
-            Object.entries(argsObject).forEach(([key, value]) => {
+            if(argsObject) Object.entries(argsObject).forEach(([key, value]) => {
                 contextInstance[key] = value
             })
             // Add cache list