queueobj 12.0.18 → 14.0.0

package/.github/workflows/node.js.yml

@@ -78,8 +78,5 @@ jobs:
       run: npm ls --depth=0 --dev && npm ls --depth=0 --prod
 
     - run: npm run build --if-present
+    - run: npm run test_files
     - run: npm run test_all
-    - run: npm run test_bottom_one
-    - run: npm run test_top_one
-    - run: npm run test_func_all
-    - run: npm run test_sync_all

package/README.md

@@ -5,18 +5,26 @@
 
 [![NPM](https://nodei.co/npm/queueobj.png?downloads=true&downloadRank=true&stars=true)](https://nodei.co/npm/queueobj/)
 
-Queue javascript objects dynamically then process the queue according to the appender.
+Queue javascript objects dynamically then process the queue according to the appender. All appenders are handled synchronously.
 
 Included tag appenders:
 
-* 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.
-* name - synchronous - queue and process all objects by name.
-* version - synchronous - queue and process all objects by version.
+* files - See if inputed files exists.
+* all - process all added objects.
+* top_one - process only the object in the 0(zero) position of the process array.
+* bottom_one - process only the object in the last position of the process array.
+* func_all - process custom function names in created objects. Custom processing names can be used in any appender, this is just one example.
+* status - queue and process all objects by status.
+* name - queue and process all objects by name.
+* version - queue and process all objects by version.
+
+* json_all - process a class object per json input array variables.
+* json_top_one - process a class object per the first json input array variable.
+* json_bottom_one - process a class object per the last json input array variable.
+* json_func_all - process custom function names in created objects. Custom processing names can be used in any json appender, this is just one example.
+* json_status - queue and process all objects by status.
+* json_name - queue and process all objects by name.
+* json_version - queue and process all objects by version.
 
 Mocha Test
 ---------
@@ -27,14 +35,27 @@ npm test
 General Setup Test
 ---------
 ```
+npm run test_files
 npm run test_all
 npm run test_top_one
 npm run test_bottom_one
 npm run test_func_all
-npm run test_sync_all
-npm run test_status
-npm run test_version
-npm run test_name
+npm run test_status_matching
+npm run test_status_non_matching
+npm run test_name_matching
+npm run test_name_non_matching
+npm run test_version_matching
+npm run test_version_non_matching
+npm run test_json_all
+npm run test_json_top_one
+npm run test_json_bottom_one
+npm run test_json_func_all
+npm run test_json_status_matching
+npm run test_json_status_non_matching
+npm run test_json_version_matching
+npm run test_json_version_non_matching
+npm run test_json_name_matching
+npm run test_json_name_non_matching
 
 ```
 
@@ -42,76 +63,83 @@ Usage
 ---------
 ```js
 
-var colors = require('colors')
 var queue = require("queueobj");
 
-class test1 {
-    constructor() {
-        this.id = 100
-        this.process = this.process.bind(this)
-    }
-
-    process(callback) {
-        setTimeout(() => {
-            console.log(`processing test1`.cyan)
-            console.log(`some async process`)
-            callback({success: {msg: `processing all (${this.id})`}})
-        }, 3000)
-    }
+var tst1 = class test1 {
+  constructor(props) {
+    let t = this, fname = "test_all.test1.constructor"
+    t.log = props.log
+    t.id = props.id
+  }
+
+  process(callback) {
+    let t = this, fname = "test_all.test1.process"
+    t.log({ msg: `This object (${fname}) is id (${t.id}). Do stuff here`.bgBrightGreen, type: "info" })
+    callback({ success: { msg: `processing all test1` } })
+  }
 }
 
-class test2 {
-    constructor() {
-        this.id = 200
-        this.process = this.process.bind(this)
-    }
-
-    process(callback) {
-        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() {
-        console.log('hello from test2'.rainbow)
-    }
+var tst2 = class test2 {
+  constructor(props) {
+    let t = this, fname = "test_all.test2.constructor"
+    t.log = props.log
+    t.id = props.id
+  }
+
+  process(callback) {
+    let t = this, fname = "test_all.test2.process"
+    t.log({ msg: `This object (${fname}) is id (${t.id}). Do stuff here`.bgBrightGreen, type: "info" })
+    setTimeout(() => {
+      callback({ success: { msg: `processing all test2` } })
+    }, 4000)
+  }
 }
 
-class test3 {
-    constructor() {
-        this.id = 300
-        this.process = this.process.bind(this)
-    }
-
-    process(callback) {
-        callback({success: {msg: `processing all (${this.id})}`}})   
-    }
+var tst3 = class test3 {
+  constructor(props) {
+    let t = this, fname = "test_all.test3.constructor"
+    t.log = props.log
+    t.id = props.id
+  }
+
+  process(callback) {
+    let t = this, fname = "test_all.test3.process"
+    t.log({ msg: `This object (${fname}) is id (${t.id}). Do stuff here`.bgBrightGreen, type: "info" })
+    // callback({success: { msg: `processing all test3` }})
+    callback({ error: { msg: `there is some problem thrown here on test3` } })
+  }
 }
 
-class test4 {
-    constructor() {
-        let t = this
-        t.id = 400
-        t.custom_function = t.custom_function.bind(this)
-    }
-
-    custom_function(callback) {
-        let msg = `custom func problem here id(${this.id})`
-        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: 'name' }
+var tst4 = class test4 {
+  constructor(props) {
+    let t = this, fname = "test_all.test4.constructor"
+    t.log = props.log
+    t.id = props.id
 
-qObj.load(props).add(new test1()).add(new test2()).add(new test3()).add(tst4.custom_function)
+  }
+
+  process(callback) {
+    let t = this, fname = "test_all.test4.process"
+    t.log({ msg: `This object (${fname}) is id (${t.id}). Do stuff here`.bgBrightGreen, type: "info" })
+    callback({ success: { msg: `processing all test4` } })
+  }
+}
 
-qObj.process().then(res => {
-    console.log(`success with all sync processing: (${JSON.stringify(res)})`.green)
-}, err => {
-    console.log(`errors with all sync processing: (${JSON.stringify(err)})`.red)
+var qObj = new queue()
+
+qObj.init().process({
+  appender: "all",
+  exclude_logMsg: ["debug"],   /* example ["debug", "info"] */
+  process_objects: [tst1, tst2, tst3, tst4]
+}).then((success) => {
+  qObj.logMsg({ msg: `test success: {msg: "all objects processed with no errors"}`.success.italic.bold, type: "success" })
+}, (error) => {
+  if (typeof error == "string") {
+    qObj.logMsg({ msg: `error: ${error}`.error.italic.bold, type: "error" })
+  } else {
+    let add_s = (error.error_count > 1) ? 's' : ''
+    qObj.logMsg({ msg: `${error.error_count} error${add_s} detected`.error.italic.bold, type: "error" })
+  }
 })
 
 ```

package/app.js

@@ -1,276 +1,187 @@
 /* @author Jim Manton: jrman@risebroadband.net
-* @since 2021-03-19
+* @since 2023-01-15
 * Main processing app
 */
 
-var colors = require('colors'),
-    all = require('./lib/appenders/all'),
-    func_all = require('./lib/appenders/func_all'),
-    top_one = require('./lib/appenders/top_one'),
-    bottom_one = require('./lib/appenders/bottom_one'),
-    sync_all = require('./lib/appenders/sync_all'),
-    status = require('./lib/appenders/status'),
-    name = require('./lib/appenders/name'),
-    version = require('./lib/appenders/version')
+let base_queue = require("base-queue"),
+    log_queue = require("log-queue"),
+    fs = require('fs'),
+    validPath = require('valid-path')
 
-class QueueObj {
+const { memoryUsage } = require('process')
 
-    constructor() {
-        try {
-            var t = this
-            t.id = 0
-            t.appenders_dir = './lib/appenders/'
-            t.props = {}
-            t.all = null
-            t.top_one = null
-            t.bottom_one = null
-            t.array = null
-            t.status = null
-            t.version = null
-            t.stats = false
-            t.sync_all = null
-            t.name = null
-            t.func_all = null
-            t.objs = []
-            t.resolve = null
-            t.reject = null
+var log_data = [
+    { props: { id: 100, name: "console_basic", absolute_path: __filename, check: true } }
+]
 
-            t.load = t.load.bind(this)
-            t.process = t.process.bind(this)
-            t.getParent = t.getParent.bind(this)
-            t.getObjectToProcess = t.getObjectToProcess.bind(this)
-            t.getObjectById = t.getObjectById.bind(this)
-            t.getObjs = t.getObjs.bind(this)
-            t.logMsg = t.logMsg.bind(this)
-            return t
-        } catch (e) {
-            e.message = "queueObj app.js constructor error: " + e.message
-            throw (e)
-        }
-    }
 
-    getStats() {
-        return this.stats
-    }
+var log_object = class log_obj {
+    constructor(props) {
+        let t = this
+        t.id = props.id
+        t.log = props.log
+        t.name = props.name
+        t.path = props.relative_path
+        t.absolute_path = props.absolute_path
+        t.status = 'init'
+        t.errors = false
+        t.error_msg = 'none'
 
-    getObjectById(id) {
-        let t = this, i
-        for (i = 0; i < t.objs.length; i++) {
-            if (typeof t.objs[i] != 'undefined' &&
-                typeof t.objs[i].id != 'undefined' &&
-                t.objs[i].id == id) {
-                return t.objs[i]
-            }
+        t.process = t.process.bind(t)
+        t.do_checks = t.do_checks.bind(t)
+
+        if (props.check) {
+            t.do_checks()
         }
-        return null
+
+        return t
     }
 
-    getObjectByStatus(status) {
-        let t = this, i
-        for (i = 0; i < t.objs.length; i++) {
-            if (typeof t.objs[i] != 'undefined' &&
-                typeof t.objs[i].status != 'undefined' &&
-                t.objs[i].status == status) {
-                return t.objs[i]
-            }
+    do_checks() {
+        let t = this, path_to_check,
+            last_item = t.absolute_path.split("\\").pop(),
+            check_file = t.absolute_path.split(last_item)[0], check_path = t.path.split('../')
+
+        check_file = check_file.replace(/\\/g, "/");
+        path_to_check = validPath(t.path);
+
+        if (!path_to_check.valid) {
+            t.errors = true
+            t.error_msg = `id = ${t.id} name(${t.name}) Error in ${path_to_check.data.input}: ${path_to_check.error})`
         }
-        return null
-    }
 
-    getObjectByVersion(version) {
-        let t = this, i
-        for (i = 0; i < t.objs.length; i++) {
-            if (typeof t.objs[i] != 'undefined' &&
-                typeof t.objs[i].version != 'undefined' &&
-                t.objs[i].version == version) {
-                return t.objs[i]
+        // check_path.map((dat, i) => {
+        //     if (/^[a-zA-Z._]+$/.test(dat)) {
+        //         if (dat != '.' || dat != '..')
+        //             check_file += dat + '/'
+        //     }
+        // })
+        // check_file = check_file.slice(0, -1)
+        check_file += check_path[1]
+        check_file += `${t.name}.js`
+        try {
+            if (!fs.existsSync(check_file)) {
+                t.errors = true
+                t.error_msg = `id = ${t.id} name(${t.name}) file (${check_file} does not exist)`
             }
+        } catch (e) {
+            e.message = "file_obj do_checks error: " + e.message
+            throw (e)
         }
-        return null
-    }
-
-    count() {
-        return this.objs.length
     }
 
-    get(num) {
-        if (num < this.objs.length)
-            return this.objs[num]
-        return false
+    process(callback) {
+        let t = this
+        if (t.errors)
+            callback({ error: {msg: t.error_msg} })
+        else {
+            callback({ success: {msg: `id = ${t.id} name(${t.name}) success`} })
+        }
     }
+}
 
-    getObjectToProcess() {
-        return this.objs.shift()
-    }
+exports = module.exports = class QueueObj {
+    constructor() {
+        var t = this, fname = 'QueueObj.constructor'
+        try {
+            t.promise = null
+            t.resolve = null
+            t.reject = null
+            t.promise_2q = null
+            t.resolve_2q = null
+            t.reject_2q = null
+            t.successMsg = ''
+            t.log_queue = null
 
-    getBottomObjectToProcess() {
-        return this.objs.pop()
-    }
+            t.logMsg = t.logMsg.bind(t)
+            t.init = t.init.bind(t)
+            t.process = t.process.bind(t)
+            t.getFileObject = t.getFileObject.bind(t)
 
-    getItemToProcess(itm) {
-        return this.objs[itm]
-    }
+            // t.logMsg(`QueueObj.constructor`.debug)
 
-    logMsg(msg, props = {}) {
-        console.log(msg)
+            return t
+        } catch (e) {
+            e.message = `QueueObj app.js constructor error: ${e.message}`.error
+            console.log(e.message)
+        }
     }
 
-    load(props) {
+    init() {
+        var t = this, fname = `QueueObj.init`
         try {
-            var t = this
-            t.props = props
-            t.stats = (typeof props.stats != 'undefined') ? props.stats : false;
-            if (typeof props != `undefined`) {
-                if (typeof props.appender != `undefined` &&
-                    typeof props.appender == 'string') {
-                    props.getParent = t.getParent
-                    switch (props.appender) {
-                        case 'all':
-                            t.all = new all(props)
-                            break
-                        case 'top_one':
-                            t.top_one = new top_one(props)
-                            break
-                        case 'bottom_one':
-                            t.bottom_one = new bottom_one(props)
-                            break
-                        case 'func_all':
-                            t.func_all = new func_all(props)
-                            break
-                        case 'array':
-                            t.array = new array(props)
-                            break
-                        case 'status':
-                            t.status = new status(props)
-                            break
-                        case 'version':
-                            t.version = new version(props)
-                            break
-                        case 'sync_all':
-                            t.sync_all = new sync_all(props)
-                            break
-                        case 'name':
-                            t.name = new name(props)
-                            break
-                        default:
-                            throw new Error(`appender(${props.appender}) not found`)
-                    }
-                }
-                return t
-            }
+            t.promise = new Promise((resolve, reject) => {
+                t.resolve = resolve
+                t.reject = reject
+            })
+            t.promise_2q= new Promise((resolve, reject) => {
+                t.resolve_2q = resolve
+                t.reject_2q = reject
+            })
+            return t
         } catch (e) {
-            e.message = "queueObj app.js load error: " + e.message
-            t.logMsg(e.message)
-            throw (e)
+            t.logMsg({ msg: `${fname} error: (${e.message})`.error, type: 'error' })
+            // e.message = `QueueObj app.js constructor error: ${e.message}`.error
+            // console.log(e.message)
         }
     }
 
-    add(obj) {
-        var t = this
-        try {
-            if (t.all != null) {
-                obj._getProperty = (o) => {
-                    return 'all'
-                }
-            }
-            if (t.top_one != null) {
-                obj._getProperty = (o) => {
-                    return 'top_one'
-                }
-            }
-            if (t.bottom_one != null) {
-                t.objs = []
-                obj._getProperty = (o) => {
-                    return 'bottom_one'
-                }
-            }
-            if (t.func_all != null) {
-                obj._getProperty = (o) => {
-                    return 'func_all'
-                }
-            }
-            if (t.sync_all != null) {
-                obj._getProperty = (o) => {
-                    return 'sync_all'
-                }
-            }
-            if (t.name != null) {
-                obj._getProperty = (o) => {
-                    return 'name'
-                }
-            }
-            if (typeof obj.status != 'undefined') {
-                obj._getProperty = (o) => {
-                    return o.status
-                }
+    process(props = {}) {
+        let t = this, fname = `app.process`
 
-            }
-            if (typeof obj.name != 'undefined') {
-                obj._getProperty = (o) => {
-                    return o.name
-                }
+        // if (typeof props.data_to_process_array == 'undefined')
+        //     t.reject('base_queue no props.data_to_process_array')
 
-            }
-            if (typeof obj.version != 'undefined') {
-                obj._getProperty = (o) => {
-                    return o.version
-                }
-            }
-            if (t.top_one != null) {
-                if (t.objs.length == 0) {
-                    t.objs.push(obj)
-                }
-                return t
-            }
-            t.objs.push(obj)
-            return t
+        if (typeof props.appender == 'undefined')
+            t.reject('base_queue no props.appender')
+
+        if (typeof props.process_objects == 'undefined')
+            t.reject(`props.process_objects not defined`)
+
+        try {
+            t.log_queue = new log_queue({
+                parent: t,
+                relative_path: "../base_queue/appenders/log/",
+                exclude_logMsg: props.exclude_logMsg,
+                resolve: t.resolve,
+                reject: t.reject
+            }).init({
+                appender: "console_basic",
+                process_objects: [log_object],
+                data_to_process_array: log_data
+            })
+            t.base_queue = new base_queue({   
+                parent: t,
+                relative_path: "./appenders/",
+                logMsg: t.logMsg,
+                resolve: t.resolve_2q,
+                reject: t.reject_2q
+            }).load(props).process()
+            return t.promise_2q
         } catch (e) {
-            e.message = "queueObj app.js add error: " + e.message
-            t.logMsg(e.message.red)
-            throw (e)
+            console.log(`${fname} error: (${e.message})`)
         }
     }
 
-    getParent() {
-        return this
-    }
-
-    getObjs() {
-        return this.objs
+    getFileObject() {
+        return this.qJson.get_class_obj_array()
     }
 
-    process(props = {}) {
+    logMsg(props = { msg: '', type: '' }) {   
+        let t = this, fname = "QueueObj.logMsg"
         try {
-            var t = this
-            switch (t.props.appender) {
-                case 'all':
-                    return t.all.process(props)
-                case 'top_one':
-                    return t.top_one.process(props)
-                case 'bottom_one':
-                    return t.bottom_one.process(props)
-                case 'func_all':
-                    return t.func_all.process(props)
-                case 'sync':
-                case 'sync_all':
-                    return t.sync_all.process(props)
-                case 'name':
-                    return t.name.process(props)
-                case 'status':
-                    return t.status.process(props)
-                case 'version':
-                    return t.version.process(props)
-                default:
-                    throw new Error(`nothing to process`)
+            if (typeof props.msg == "undefined")
+                throw new Error(`no msg property in (${JSON.stringify(props)}) `)
+            if (typeof props.type == "undefined")
+                throw new Error(`no type property in (${JSON.stringify(props)}) `)
+            if (t.log_queue != null && typeof t.log_queue.logMsg != 'undefined') {
+                t.log_queue.logMsg(props)
+            } else {
+                throw new Error(`t.log_queue does not exist`)
             }
         } catch (e) {
-            e.message = "queueObj app.js load error: " + e.message
-            t.logMsg(e.message.red)
-            throw (e)
+            e.message = `${fname} error: ${e.message})`
+            t.reject(e.message)
         }
     }
-}
-
-exports = module.exports = function (props) {
-    return new QueueObj(props)
 }

package/lib/appenders/all.js

@@ -1,6 +1,6 @@
 /*
 * @author Jim Manton: jrman@risebroadband.net
-* @since 2021-03-22l
+* @since 2023-2-5l
 * lib/appenders/all.js
 */