queueobj 8.0.2 → 9.0.2

package/README.md

@@ -3,11 +3,11 @@ Queue javascript objects dynamically then process the queue according to the app
 
 Included tag appenders:
 
-* all - asynchronous - process all added objects.
-* func_all - asynchronous - process custom functions to added objects.
-* top_one - asynchronous - process only the object in the 0(zero) position of the process array.
-* bottom_one - asynchronous - process only the object in the last position of the process array.
-* sync_all - synchronous - queue and process all objects by items as well as custom functions.
+* all - synchronous - process all added objects.
+* func_all - synchronous - process custom functions to added objects.
+* top_one - synchronous - process only the object in the 0(zero) position of the process array.
+* bottom_one - synchronous - process only the object in the last position of the process array.
+* sync_all - synchronous - All appenders are synchronous now. Sync_all is no different than all .
 * status - synchronous - queue and process all objects by status.
 * version - synchronous - queue and process all objects by version.
 
@@ -46,24 +46,28 @@ var queue = require("queueobj");
 class test1 {
     constructor() {
         this.id = 100
+        this.process = this.process.bind(this)
     }
 
     process(callback) {
-        console.log(`processing test1`.cyan)
-        callback()
+        setTimeout(() => {
+            console.log(`processing test1`.cyan)
+            console.log(`some async process`)
+            callback({success: {msg: `processing all (${this.id})`}})
+        }, 3000)
     }
 }
 
 class test2 {
     constructor() {
         this.id = 200
+        this.process = this.process.bind(this)
     }
 
     process(callback) {
-        let msg = `some kinda problem here`
-        console.log(`processing test2`.cyan)
-        //callback({error: {msg: msg}})  //this will show errors
-        callback()  //this will show no errors
+        let msg = `some kinda problem here in id(${this.id})`
+        // callback({error: {msg: msg}})  //this will show errors
+        callback({success: {msg: `processing all (${this.id})}`}})   //this will show no errors
     }
 
     ping() {
@@ -74,14 +78,11 @@ class test2 {
 class test3 {
     constructor() {
         this.id = 300
+        this.process = this.process.bind(this)
     }
 
     process(callback) {
-        setTimeout(()=>{
-            console.log(`processing test3`.cyan)
-            console.log(`some async process`)
-            callback()
-        }, 2000)
+        callback({success: {msg: `processing all (${this.id})}`}})   
     }
 }
 
@@ -94,64 +95,21 @@ class test4 {
 
     custom_function(callback) {
         let msg = `custom func problem here id(${this.id})`
-        console.log(`processing test4`.cyan)
-        //callback({error: {msg: msg}})  //this will show errors
-        callback()  //this will show no errors
+        setTimeout(() => {
+            // callback({error: {msg: msg}})  //this will show errors
+            callback({success: {msg: `processing all (${this.id})}`}})   //this will show no errors
+        }, 3000)
     }
 }
 let tst4 = new test4()
-let qObj = new queue(), props = { appender: 'sync', stats: true }
+let qObj = new queue(), props = { appender: 'sync_all' }
 
 qObj.load(props).add(new test1()).add(new test2()).add(new test3()).add(tst4.custom_function)
 
-qObj.await({ items: [0, 1] }).then(res => {
-    console.log(`1) done with items[0,1]: (${res})`.green)
-}, err => {
-    console.log(`1) error[0, 1]: (${err})`.red)
-})
-
-qObj.await({ items: [1, 2] }).then(res => {
-    console.log(`2) done with items[1,2]: (${res})`.green)
-}, err => {
-    console.log(`2) error[1,2]: (${err})`.red)
-})
-
-qObj.await({ items: [2, 1, 2] }).then(res => {
-    console.log(`3) done with items[2,1,2]: (${res})`.green)
-}, err => {
-    console.log(`3) error[2, 1, 2]: (${err})`.red)
-})
-
-qObj.await({ items: [2, 3] }).then(res => {
-    console.log(`4) done with item[2, 3]: (${res})`.green)
-}, err => {
-    console.log(`4) error[2, 3]: (${err})`.red)
-})
-
-qObj.await({ items: [0] }).then(res => {
-    console.log(`5) done with item[0]: (${res})`.green)
-}, err => {
-    console.log(err.red)
-})
-
-qObj.getObjectById(200).ping()
-
-qObj.await({ byIds: [300, 200, 100] }).then(res => {
-    console.log(`6) done with byId: [300, 200, 100] (${res})`.bold.italic.underline.yellow)
-}, err => {
-    console.log(`6) error[300, 200, 100]: (${err})`.red)
-})
-
-qObj.await({ byIds: [100, 300] }).then(res => {
-    console.log(`7) done with byId: [100, 300] (${res})`.bold.italic.underline.yellow)
-}, err => {
-    console.log(`7) error[100, 300]: (${err})`.red)
-})
-
 qObj.process().then(res => {
-    console.log(`8) done with all sync processing: (${res})`.bold.italic.white)
+    console.log(`success with all sync processing: (${JSON.stringify(res)})`.bold.italic.green)
 }, err => {
-    console.log(`8) errors with all sync processing: (${err})`.red)
+    console.log(`errors with all sync processing: (${JSON.stringify(err)})`.red)
 })
 
 ```

package/app.js

@@ -35,7 +35,6 @@ class QueueObj {
 
             t.load = t.load.bind(this)
             t.process = t.process.bind(this)
-            t.await = t.await.bind(this)
             t.getParent = t.getParent.bind(this)
             t.getObjectToProcess = t.getObjectToProcess.bind(this)
             t.getObjectById = t.getObjectById.bind(this)
@@ -159,38 +158,39 @@ class QueueObj {
         var t = this
         try {
             if (t.all != null) {
-                obj.getType = (o) => {
+                obj._getProperty = (o) => {
                     return 'all'
                 }
             }
             if (t.top_one != null) {
-                obj.getType = (o) => {
+                obj._getProperty = (o) => {
                     return 'top_one'
                 }
             }
             if (t.bottom_one != null) {
                 t.objs = []
-                obj.getType = (o) => {
+                obj._getProperty = (o) => {
                     return 'bottom_one'
                 }
             }
             if (t.func_all != null) {
-                obj.getType = (o) => {
+                obj._getProperty = (o) => {
                     return 'func_all'
                 }
             }
             if (t.sync_all != null) {
-                obj.getType = (o) => {
+                obj._getProperty = (o) => {
                     return 'sync_all'
                 }
             }
             if (typeof obj.status != 'undefined') {
-                obj.getType = (o) => {
+                obj._getProperty = (o) => {
                     return o.status
                 }
+
             }
             if (typeof obj.version != 'undefined') {
-                obj.getType = (o) => {
+                obj._getProperty = (o) => {
                     return o.version
                 }
             }
@@ -217,45 +217,25 @@ class QueueObj {
         return this.objs
     }
 
-    process() {
+    process(props = {}) {
         try {
-            var t = this, pro = { dat_array: [] }
-            switch (t.props.appender) {  
+            var t = this
+            switch (t.props.appender) {
                 case 'all':
-                    pro.dat_array.push('all')
-                    t.all.await(pro)
-                    return t.all.process()
+                    return t.all.process(props)
                 case 'top_one':
-                    pro.dat_array.push('top_one')
-                    t.top_one.await(pro)
-                    return t.top_one.process()
+                    return t.top_one.process(props)
                 case 'bottom_one':
-                    pro.dat_array.push('bottom_one')
-                    t.bottom_one.await(pro)
-                    return t.bottom_one.process()
+                    return t.bottom_one.process(props)
                 case 'func_all':
-                    pro.dat_array.push('func_all')
-                    t.func_all.await(pro)
-                    return t.func_all.process()
+                    return t.func_all.process(props)
                 case 'sync':
                 case 'sync_all':
-                    pro.dat_array.push('sync_all')
-                    t.sync_all.await(pro)
-                    return t.sync_all.process()
+                    return t.sync_all.process(props)
                 case 'status':
-                    return t.status.process()
+                    return t.status.process(props)
                 case 'version':
-                    return t.version.process()
-                // case 'sync_all':
-                //     t.objs.map((item, i) => {
-                //         pro.items.push(i)
-                //     })
-                //     t.sync.await(pro).then(res => {
-                //         console.log(`done with ${JSON.stringify(pro)}: (${res})`.green)
-                //     }, err => {
-                //         console.log(`error ${JSON.stringify(pro)}: (${err})`.red)
-                //     })
-                //     return t.sync.process()
+                    return t.version.process(props)
                 default:
                     throw new Error(`nothing to process`)
             }
@@ -265,28 +245,6 @@ class QueueObj {
             throw (e)
         }
     }
-
-    await(props) {
-        var t = this, pro
-        try {
-            if (t.sync != null) {
-                pro = { dat_array: props.items }
-                return t.sync.await(props)
-            }
-            if (t.status != null) {
-                pro = { dat_array: props.status }
-                return t.status.await(pro)
-            }
-            if (t.version != null) {
-                pro = { dat_array: props.version }
-                return t.version.await(pro)
-            }
-        } catch (e) {
-            e.message = "queueObj app.js load error: " + e.message
-            console.log(e.message)
-            throw (e)
-        }
-    }
 }
 
 exports = module.exports = function (props) {

package/lib/appenders/base.js

@@ -2,47 +2,140 @@
 * @author Jim Manton: jrman@risebroadband.net
 * @since 2017-10-01
 * lib/appenders/base.js
+* jrm debug 8/4 https://www.npmjs.com/package/temporary-stamp
 */
 
 var colors = require('colors')
 
+class process_all_obj {
+    constructor(props) {
+        let t = this
+        t.parent = props.parent
+        t.objs = t.parent.getParent().getObjs()
+        t.status = 'process'
+        t.process_objs_item = 0
+        t.process_props_item = 0
+        t.await_item = 0
+        t.any_errors = false
+
+
+        t.continueProcessing = t.continueProcessing.bind(t)
+    }
+
+    process = () => {
+        let t = this
+        try {
+            if (t.process_objs_item >= t.objs.length) {
+                if (t.any_errors)
+                    t.setStatus('finish with errors')
+                else
+                    t.setStatus('finish')
+                return
+            }
+            try {
+                let obj, pro, itm
+                try {
+                    obj = t.parent.getParent().getItemToProcess(t.process_objs_item)
+                } catch (e) {
+                    e.message = `base error: (${e.message})`
+                    throw e
+                }
+                try {
+                    pro = (typeof obj == 'function') ? obj : obj.process;
+                } catch (e) {
+                    console.log(`pro error: (${e.message})`.red)
+                    throw e
+                }
+                if (typeof t.parent.pro_props != 'undefined' &&
+                    typeof t.parent.pro_props.property != 'undefined' &&
+                    typeof t.parent.pro_props.items != 'undefined' &&
+                    typeof obj._getProperty == 'function') {
+                    let skip = true
+                    for (let q = 0; q < t.parent.pro_props.items.length; q++) {
+                        itm = t.parent.pro_props.items[q]
+                        if (itm == obj._getProperty(obj)) {
+                            skip = false
+                            break
+                        }
+                    }
+                    if (skip) {
+                        t.continueProcessing()
+                        return
+                    }
+                }
+                t.setStatus('wait')
+                pro((obj_props) => {
+                    try {
+                        if (typeof obj_props != 'undefined' && typeof obj_props.error != 'undefined') {
+                            t.any_errors = true
+                            console.log(`${JSON.stringify(obj_props)}`.red)
+                        } else {
+                            console.log(`${JSON.stringify(obj_props)}`.green)
+                        }
+                        t.parent.results_array.push(obj_props)
+                        t.continueProcessing()
+                    } catch (e) {
+                        console.log(`pro obj error: (${e.message})`.red)
+                        throw e
+                    }
+                })
+            } catch (e) {
+                e.message = `10.01 error: ${e.message} `
+                throw e
+            }
+        } catch (e) {
+            e.message = `process_all_obj error: ${e.message} `
+            throw e
+        }
+    }
+
+    continueProcessing = () => {
+        let t = this
+        t.process_objs_item++
+        t.setStatus('process')
+        t.parent.process_all()
+    }
+
+    getStatus = () => {
+        return this.status
+    }
+
+    setStatus = (v) => {
+        this.status = v
+    }
+}
+
 exports = module.exports = class base {
     constructor(props) {
         let t = this
         t.await_array = []
         t.resolve_array = []
         t.reject_array = []
-        t.process_objs_item = 0
-        t.process_props_item = 0
-        t.any_errors = false
+        t.results_array = []
         t.getParent = props.getParent
         t.dt_start = null
         t.dt_end = null
+        t.process_all_obj = null
+        t.pro_props = []
 
         t.process = t.process.bind(this)
         t.process_all = t.process_all.bind(this)
     }
 
+    // await(props) {
+    //     let t = this
+    //     t.await_array.push(props)
+    //     return new Promise((resolve, reject) => {
+    //         t.resolve_array.push(resolve)
+    //         t.reject_array.push(reject)
+    //     });
+    // }
 
-    await(props) {
-        let t = this
-        t.await_array.push(props)
-        return new Promise((resolve, reject) => {
-            t.resolve_array.push(resolve)
-            t.reject_array.push(reject)
-        });
-    }
-
-    process() {
+    process(props) {
         let t = this
-        t.process_objs_item = 0
-        t.process_props_item = 0
-        t.await_item = 0
         t.dt_start = new Date(); // start measuring time
-        // t.await_array = []
-        // t.resolve_array = []
-        // t.reject_array = []
-        // t.status_props_array = []
+
+        t.pro_props = props
 
         return new Promise((resolve, reject) => {
             t.resolve_array.push(resolve)
@@ -52,115 +145,45 @@ exports = module.exports = class base {
     }
 
     getStats() {
-        let t = this, msg, st = `${t.dt_start}`.green, ed = `${t.dt_end}`.green, ml = `${t.dt_end - t.dt_start}`.green
-        msg = `success`.green
-        if (t.getParent().getStats())
-            msg += `\nstart(${st}) end(${ed}) milliseconds(${ml})`
-        return msg
+        let t = this, json_ret = { execution_time: 'status is set to false' }, st = `${t.dt_start} `.green, ed = `${t.dt_end} `.green, ml = `${t.dt_end - t.dt_start} `.green
+        json_ret.responses = t.results_array
+        if (t.getParent().getStats()) {
+            json_ret.execution_time = `start`.green
+            json_ret.execution_time += `(${st}) end(${ed}) milliseconds(${ml})`
+        }
+        return json_ret
     }
 
-    process_all() {
-        let t = this, obj, pro, itm, msg, itm_type, props_type, datA
+    process_all = () => {
+        let t = this, _continue
+        if (t.process_all_obj == null) {
+            t.process_all_obj = new process_all_obj({ parent: t })
+        }
+
+        _continue = false
         try {
-            try {
-                if (t.process_objs_item >= t.getParent().getObjs().length) {
-                    t.await_item++
+            switch (t.process_all_obj.getStatus()) {
+                case 'process':
+                    t.process_all_obj.process()
+                    _continue = true
+                    break
+                case 'finish with errors':
+                    t.reject_array[t.reject_array.length - 1](t.getStats())
+                    break
+                case 'finish':
                     t.resolve_array[t.resolve_array.length - 1](t.getStats())
+                    break
+                case 'wait':
                     return
-                }
-            } catch (e) {
-                return
+                default:
+                    throw new Error(`status(${t.process_all_obj.getStatus()}) does not exist`)
             }
-            try {
-                datA = t.await_array[t.await_item].dat_array
-            } catch (e) {
-                return
-            }
-            try {
 
-                datA.map((dat_item, i) => {
-                    if (i == t.process_props_item) {
-                        if (t.process_props_item < datA.length) {
-                            if ((t.await_item) >= t.await_array.length) {
-                                t.resolve_array[t.resolve_array.length - 1](t.getStats())
-                                return
-                            }
-                            t.getParent().getObjs().map((pItem, x) => {
-                                if (x == t.process_objs_item) {
-                                    try {
-                                        obj = t.getParent().getItemToProcess(x)
-                                    } catch (e) {
-                                        e.message = `base error: (${e.message})`
-                                        throw e
-                                    }
-                                    if (typeof obj != 'undefined' && typeof obj.getType != 'function') {
-                                        obj.getType = (o) => { return t.aname }
-                                    }
-                                    if (obj.getType(obj) == dat_item) {
-                                        try {
-                                            pro = (typeof obj == 'function') ? obj : obj.process;
-                                        } catch (e) {
-                                            console.log(`pro error: (${e.message})`.red)
-                                            throw e
-                                        }
-
-                                        pro((obj_props) => {
-                                            try {
-
-                                                if (typeof obj_props != 'undefined') {
-                                                    if (typeof obj_props.error != 'undefined' &&
-                                                        typeof obj_props.error.msg != 'undefined' &&
-                                                        typeof obj_props.error.msg == 'string') {
-                                                        msg = `error: ${obj_props.error.msg}`
-                                                        msg += (typeof obj.id != 'undefined') ? ` id(${obj.id})` : ``;
-                                                        t.any_errors = true
-                                                        t.reject_array[t.reject_array.length - 1](msg)
-                                                    } else {
-                                                        console.log(`${JSON.stringify(obj_props)}`.green)
-                                                    }
-                                                }
-                                                t.process_objs_item++
-                                                if (t.process_props_item < datA.length) {
-                                                    t.process_all()
-                                                } else {
-                                                    t.dt_end = new Date();
-                                                    t.resolve_array[t.process_props_item - 1](t.getStats())
-                                                    t.process_props_item = 0
-                                                    t.process_objs_item = 0
-                                                }
-                                            } catch (e) {
-                                                console.log(`proessing error: (${e.message})`.red)
-                                                throw e
-                                            }
-                                        })
-                                    } else {
-                                        t.process_objs_item++
-                                        if (t.process_objs_item >= t.getParent().getObjs().length) {
-                                            t.resolve_array[t.resolve_array.length - 1](t.getStats())
-                                        }
-                                    }
-                                } else {
-                                    if (t.process_objs_item >= t.getParent().getObjs().length) {
-                                        t.process_objs_item = 0
-                                        t.process_props_item++
-                                        if (t.process_props_item >= datA.length) {
-                                            t.await_item++
-                                            t.process_props_item = 0
-                                            if (t.await_item <= t.await_array.length)
-                                                t.process_all()
-                                        }
-                                    }
-                                }
-                            })
-                        }
-                    }
-                })
-            } catch (e) {
-                e.message = `await error: ${e.message}`
-                throw e
-            }
+            if (_continue)
+                t.process_all()
         } catch (e) {
-            console.log(`process_all error: ${e.message}`.red)
+            e.message = `process_all error: ${e.message} `
+            throw e
         }
     }
 }

package/package.json

@@ -2,13 +2,13 @@
   "author": {
     "name": "Jim Manton"
   },
-  "version": "8.0.2",
+  "version": "9.0.2",
   "bundleDependencies": false,
   "dependencies": {
     "chai": "^4.3.3",
     "colors": "^1.4.0",
     "compare-json-difference": "^0.1.3",
-    "mocha": "^9.1.3"
+    "mocha": "^10.0"
   },
   "scripts": {
     "start": "node app.ts",
@@ -19,9 +19,7 @@
     "processing",
     "appenders",
     "javascript",
-    "asynchronous",
     "synchronous",
-    "await",
     "objects",
     "promises",
     "mocha"

package/test/package.js

@@ -6,13 +6,13 @@ const packageMock = {
   "author": {
     "name": "Jim Manton"
   },
-  "version": "8.0.2",
+  "version": "9.0.2",
   "bundleDependencies": false,
   "dependencies": {
     "chai": "^4.3.3",
     "colors": "^1.4.0",
     "compare-json-difference": "^0.1.3",
-    "mocha": "^9.1.3"
+    "mocha": "^10.0"
   },
   "scripts": {
     "start": "node app.ts",
@@ -23,9 +23,7 @@ const packageMock = {
     "processing",
     "appenders",
     "javascript",
-    "asynchronous",
     "synchronous",
-    "await",
     "objects",
     "promises",
     "mocha"

package/test_all.js

@@ -3,38 +3,41 @@ var colors = require('colors')
 var queue = require("./app.js");
 
 class test1 {
-  process(callback){
-    callback({success: `processing all test1`})
+  process(callback) {
+    callback({ success: { msg: `processing all test1` } })
   }
 }
 
 class test2 {
-  constructor(obj){
-    obj.add(new test4())
-  }
 
-  process(callback){
-    callback({success: `processing all test2`})
+  process(callback) {
+    callback({ success: { msg: `processing all test2` } })
   }
 }
 
 class test3 {
-  process(callback){
-    // callback({success: `processing all test3`})
-    callback({error: {msg: `error test3`}})
+  process(callback) {
+    callback({success: { msg: `processing all test3` }})
+    // callback({ error: { msg: `there is some problem thrown here on test3` } })
   }
 }
 
 class test4 {
-  process(callback){
-    callback({success: `processing all test4`})
+  process(callback) {
+    callback({ success: { msg: `processing all test4` } })
   }
 }
 
-let qObj = new queue(), props = { appender: 'all', stats: true}
+let qObj = new queue(), props = { appender: 'all', stats: true }
 
-qObj.load(props).add(new test1()).add(new test2(qObj)).add(new test3()).process({}).then(res => {
-  console.log(res)
+qObj.load(props).add(new test1()).add(new test2()).add(new test3()).add(new test4()).process({}).then(res => {
+  console.log(`success with all processing: (${JSON.stringify(res)})`.bold.italic.green)
 }, err => {
-  console.log(`errors with all processing: (${err})`.red)
+  // console.log(`error with all processing: (${JSON.stringify(err)})`.red)  //show all results
+  console.log(`error with all processing: (${err.execution_time})`.red)  //show the execution time
+  err.responses.map((jItem, i) => {
+    if (typeof jItem.error != 'undefined' && typeof jItem.error.msg != 'undefined') {
+      console.log(`error: ${jItem.error.msg}`.red)  //show the error
+    }
+  })
 })

package/test_bottom_one.js

@@ -4,29 +4,26 @@ var queue = require("./app.js");
 
 class test1 {
     process(callback) {
-        console.log(`processing test1`.cyan)
-        callback()
+        callback({success: {msg: `processing test1`}})
     }
 }
 
 class test2 {
     process(callback) {
-        console.log(`processing test2`.cyan)
-        callback()
+        callback({success: {msg: `processing test2`}})
     }
 }
 
 class test3 {
     process(callback) {
-        console.log(`processing test3`.cyan)
-        callback()
+        callback({success: {msg: `processing test3`}})
     }
 }
 
-let qObj = new queue(), props = { appender: 'bottom_one', stats: true}
+let qObj = new queue(), props = { appender: 'bottom_one', stats: false}
 
 qObj.load(props).add(new test1()).add(new test2(qObj)).add(new test3()).process({}).then(res => {
-  console.log(res)
+    console.log(`success with all sync processing: (${JSON.stringify(res)})`.bold.italic.green)
 }, err => {
-  console.log(`errors with bottom item processing: (${err})`.red)
+    console.log(`errors with all sync processing: (${JSON.stringify(err)})`.red)
 })

package/test_func_all.js

@@ -4,15 +4,13 @@ var queue = require("./app.js");
 
 class test1 {
     some_function(callback) {
-        console.log(`some_function test1`.cyan)
-        callback()
+        callback({success: {msg: `some_function test1`}})
     }
 }
 
 class test2 {
     a_func(callback) {
-        console.log(`a_func test2`.cyan)
-        callback()
+        callback({success: {msg: `a_func test2`}})
     }
 }
 
@@ -21,15 +19,13 @@ class test3 {
         obj.add(run_func.some_new_func)
     }
     cool(callback) {
-        console.log(`cool test3`.cyan)
-        callback()
+        callback({success: {msg: `cool test3`}})
     }
 }
 
 class test4 {
     some_new_func(callback) {
-        console.log(`some_new_func test4`.cyan)
-        callback()
+        callback({success: {msg: `some_new_func test4`}})
     }
 }
 
@@ -41,6 +37,8 @@ let tst1 = new test1(),
     tst3 = new test3(qObj, tst4)
 
 qObj.load(props).add(tst1.some_function).add(tst2.a_func).add(tst3.cool).process().then(res => {
-    console.log(`success processing`.green)
+    console.log(`success with func_all processing: (${JSON.stringify(res)})`.bold.italic.green)
+}, err => {
+    console.log(`errors with func_all processing: (${JSON.stringify(err)})`.red)
 })
 

package/test_status.js

@@ -17,9 +17,7 @@ class test1 {
     }
 
     process(callback) {
-        console.log(`processing test1`.cyan)
-        this.status = "done"
-        callback()
+        callback({success: {msg: `processing test1 id(${this.id}) status(${this.status})`}})
     }
 }
 
@@ -27,18 +25,15 @@ class test2 {
     constructor() {
         let t = this
         t.id = 200
-        t.status = "new"
+        t.status = "error"
 
         t.process = t.process.bind(t)
     }
 
     process(callback) {
         let t = this, msg = `some kinda problem here`
-        console.log(`processing test2`.cyan)
-        t.status = "error"
         // callback({error: {msg: msg}})  //this will show errors
-        t.status = "done"
-        callback()  //this will show no errors
+        callback({success: {msg: `processing test2 id(${this.id}) status(${this.status})`}})  //this will show no errors
     }
 
     ping() {
@@ -56,10 +51,7 @@ class test3 {
     }
 
     process(callback) {
-        console.log(`processing test3`.cyan)
-        console.log(`some async process`)
-        this.status = "done"
-        callback()
+        callback({success: {msg: `processing test3 id(${this.id}) status(${this.status})`}})  //this will show no errors
     }
 }
 
@@ -73,30 +65,22 @@ class test4 {
     }
 
     process(callback) {
-        console.log(`processing test4`.cyan)
-        this.status = "done"
-        callback()
+        callback({success: {msg: `processing test4 id(${this.id}) status(${this.status})`}})  //this will show no errors
     }
 }
 
-let qObj = new queue(), props = { appender: 'status' }
+let qObj = new queue(), props = { appender: 'status', stats: true }
 
 qObj.load(props).add(new test1()).add(new test2()).add(new test3()).add(new test4())
 
-qObj.await({ status: ['new', 'secondary'] }).then(res => {
-    console.log(`1) done with status'[new', 'secondary']: (${res})`.green)
+qObj.process({ property: 'status', items: ['init'] }).then(res => {
+    console.log(`success with status processing: (${JSON.stringify(res)})`.bold.italic.green)
 }, err => {
-    console.log(`1) error['new', 'secondary']: (${err})`.red)
+    console.log(`errors with status processing: (${JSON.stringify(err)})`.red)
 })
 
-qObj.await({ status: ['third'] }).then(res => {
-    console.log(`2) done with status['third']: (${res})`.green)
-}, err => {
-    console.log(`2) error['third']: (${err})`.red)
-})
-
-qObj.process().then(res => {
-    console.log(`3) done with status processing: (${res})`.bold.italic.blue)
-}, err => {
-    console.log(`3) errors with status processing: (${err})`.red)
-})
+// qObj.process({ property: 'status', items: ['error'] }).then(res => {
+//     console.log(`success with status error processing: (${JSON.stringify(res)})`.bold.italic.green)
+// }, err => {
+//     console.log(`errors with status error processing: (${JSON.stringify(err)})`.red)
+// })

package/test_sync_all.js

@@ -10,13 +10,14 @@ var queue = require("./app.js");
 class test1 {
     constructor() {
         this.id = 100
+        this.process = this.process.bind(this)
     }
 
     process(callback) {
-        setTimeout(()=>{
+        setTimeout(() => {
             console.log(`processing test1`.cyan)
             console.log(`some async process`)
-            callback()
+            callback({success: {msg: `processing all (${this.id})`}})
         }, 3000)
     }
 }
@@ -24,13 +25,13 @@ class test1 {
 class test2 {
     constructor() {
         this.id = 200
+        this.process = this.process.bind(this)
     }
 
     process(callback) {
-        let msg = `some kinda problem here`
-        console.log(`processing test2`.cyan)
-        //callback({error: {msg: msg}})  //this will show errors
-        callback()  //this will show no errors
+        let msg = `some kinda problem here in id(${this.id})`
+        // callback({error: {msg: msg}})  //this will show errors
+        callback({success: {msg: `processing all (${this.id})}`}})   //this will show no errors
     }
 
     ping() {
@@ -41,11 +42,11 @@ class test2 {
 class test3 {
     constructor() {
         this.id = 300
+        this.process = this.process.bind(this)
     }
 
     process(callback) {
-        console.log(`processing test3`.cyan)
-        callback()
+        callback({success: {msg: `processing all (${this.id})}`}})   
     }
 }
 
@@ -58,9 +59,10 @@ class test4 {
 
     custom_function(callback) {
         let msg = `custom func problem here id(${this.id})`
-        console.log(`processing test4`.cyan)
-        //callback({error: {msg: msg}})  //this will show errors
-        callback()  //this will show no errors
+        setTimeout(() => {
+            // callback({error: {msg: msg}})  //this will show errors
+            callback({success: {msg: `processing all (${this.id})}`}})   //this will show no errors
+        }, 3000)
     }
 }
 let tst4 = new test4()
@@ -69,9 +71,9 @@ let qObj = new queue(), props = { appender: 'sync_all' }
 qObj.load(props).add(new test1()).add(new test2()).add(new test3()).add(tst4.custom_function)
 
 qObj.process().then(res => {
-    console.log(`done with all sync processing: (${res})`.bold.italic.blue)
+    console.log(`success with all sync processing: (${JSON.stringify(res)})`.bold.italic.green)
 }, err => {
-    console.log(`errors with all sync processing: (${err})`.red)
+    console.log(`errors with all sync processing: (${JSON.stringify(err)})`.red)
 })
 
 

package/test_top_one.js

@@ -4,29 +4,27 @@ var queue = require("./app.js");
 
 class test1 {
   process(callback){
-    console.log(`processing test1`.cyan)
-    callback()
+    callback({success: {msg: `processing test1`}})
   }
 }
 
 class test2 {
   process(callback){
-    console.log(`processing test2`.cyan)
-    callback()
+    callback({success: {msg: `processing test2`}})
   }
 }
 
 class test3 {
   process(callback){
-    console.log(`processing test3`.cyan)
-    callback()
+    callback({success: {msg: `processing test3`}})
   }
 }
 
 let qObj = new queue(), props = { appender: 'top_one', stats: true}
 
 qObj.load(props).add(new test1()).add(new test2(qObj)).add(new test3()).process({}).then(res => {
-  console.log(res)
+  console.log(`success with all sync processing: (${JSON.stringify(res)})`.bold.italic.green)
 }, err => {
-  console.log(`errors with top item processing: (${err})`.red)
+    console.log(`errors with all sync processing: (${JSON.stringify(err)})`.red)
 })
+

package/test_version.js

@@ -17,10 +17,7 @@ class test1 {
     }
 
     process(callback) {
-        let t = this
-        console.log(`processing test1 version(${t.version})`.cyan)
-        this.status = "done"
-        callback()
+        callback({success: {msg: `processing test1 id(${this.id}) version(${this.version})`}})
     }
 }
 
@@ -34,10 +31,7 @@ class test2 {
     }
 
     process(callback) {
-        let t = this, msg = `some kinda error is detected here`
-        console.log(`processing test2 version(${t.version})`.cyan)
-        // callback({error: {msg: msg}})  //this will show errors
-        callback()  //this will have no errors
+        callback({success: {msg: `processing test2 id(${this.id}) version(${this.version})`}})
     }
 
     ping() {
@@ -55,10 +49,7 @@ class test3 {
     }
 
     process(callback) {
-        let t = this
-        console.log(`processing test3 version(${t.version})`.cyan)
-        console.log(`some async process`)
-        callback()
+        callback({success: {msg: `processing test3 id(${this.id}) version(${this.version})`}})
     }
 }
 
@@ -72,9 +63,7 @@ class test4 {
     }
 
     process(callback) {
-        let t = this
-        console.log(`processing test4 version(${t.version})`.cyan)
-        callback()
+        callback({success: {msg: `processing test4 id(${this.id}) version(${this.version})`}})
     }
 }
 
@@ -88,35 +77,21 @@ class test5 {
     }
 
     process(callback) {
-        let t = this
-        console.log(`processing test5 version(${t.version})`.cyan)
-        callback()
+        callback({success: {msg: `processing test5 id(${this.id}) version(${this.version})`}})
     }
 }
 let qObj = new queue(), props = { appender: 'version' }
 
 qObj.load(props).add(new test1()).add(new test2()).add(new test3()).add(new test4()).add(new test5())
 
-qObj.await({ version: ['dev', 'test'] }).then(res => {
-    console.log(`1) done with version['dev', 'test']: (${res})`.green)
+qObj.process({ property: 'version', items: ['dev', 'test'] }).then(res => {
+    console.log(`success with status processing: (${JSON.stringify(res)})`.bold.italic.green)
 }, err => {
-    console.log(`1) error['dev', 'test']: (${err})`.red)
+    console.log(`errors with status processing: (${JSON.stringify(err)})`.red)
 })
 
-qObj.await({ version: ['prod'] }).then(res => {
-    console.log(`2) done with version['prod']: (${res})`.green)
-}, err => {
-    console.log(`2) error['prod']: (${err})`.red)
-})
-
-qObj.await({ version: ['v1234'] }).then(res => {
-    console.log(`3) done with version['v1234']: (${res})`.green)
-}, err => {
-    console.log(`3) error['v1234']: (${err})`.red)
-})
-
-qObj.process().then(res => {
-    console.log(`4) done with version synchronous processing: (${res})`.bold.italic.blue)
-}, err => {
-    console.log(`4) errors with version synchronous processing: (${err})`.red)
-})
+// qObj.process({ property: 'version', items: ['v1234'] }).then(res => {
+//     console.log(`4) done with version synchronous processing: (${res})`.bold.italic.green)
+// }, err => {
+//     console.log(`4) errors with version synchronous processing: (${err})`.red)
+// })