file-obj-queue 3.0.0 → 3.0.1

package/.github/workflows/{github-actions.yml → github-actions-demo.yml}

@@ -15,4 +15,4 @@ jobs:
       - name: List files in the repository
         run: |
           ls ${{ github.workspace }}
-      - run: echo "🍏 This job's status is ${{ job.status }}."
+      - run: echo "🍏 This job's status is ${{ job.status }}."

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

@@ -79,4 +79,3 @@ jobs:
 
     - run: npm run build --if-present
     - run: npm run test_files
-    - run: npm run test_all

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2021 jman717
+Copyright (c) 2023 jman717
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -1,30 +1,11 @@
-[![npm Package](https://img.shields.io/npm/v/queueobj.svg)](https://www.npmjs.org/package/queueobj)
-[![License](https://img.shields.io/npm/l/queueobj.svg)](https://github.com/jman717/queueobj/blob/master/LICENSE)
-[![CodeQL](https://github.com/jman717/QueueObj/actions/workflows/github-actions.yml/badge.svg)](https://github.com/jman717/QueueObj/blob/main/.github/workflows/github-actions.yml)
-[![Node.js CI](https://github.com/jman717/QueueObj/actions/workflows/node.js.yml/badge.svg)](https://github.com/jman717/QueueObj/actions/workflows/node.js.yml)
+[![npm Package](https://img.shields.io/npm/v/file-obj-queue.svg)](https://www.npmjs.org/package/file-obj-queue)
+[![License](https://img.shields.io/npm/l/file-obj-queue.svg)](https://github.com/jman717/file-obj-queue/blob/master/LICENSE)
+[![CodeQL](https://github.com/jman717/file-obj-queue/actions/workflows/github-actions-demo.yml/badge.svg)](https://github.com/jman717/file-obj-queue/actions/workflows/github-actions-demo.yml)
+[![Node.js CI](https://github.com/jman717/file-obj-queue/actions/workflows/node.js.yml/badge.svg)](https://github.com/jman717/file-obj-queue/actions/workflows/node.js.yml)
 
-[![NPM](https://nodei.co/npm/queueobj.png?downloads=true&downloadRank=true&stars=true)](https://nodei.co/npm/queueobj/)
+[![NPM](https://nodei.co/npm/file-obj-queue.png?downloads=true&downloadRank=true&stars=true)](https://nodei.co/npm/file-obj-queue/)
 
-Queue javascript objects dynamically then process the queue according to the appender. All appenders are handled synchronously.
-
-Included tag appenders:
-
-* 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.
+An array of objects containing file path information. One use is for dynamically import require modules.
 
 Mocha Test
 ---------
@@ -36,111 +17,5 @@ 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_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
-
-```
-
-Usage
----------
-```js
-
-var queue = require("queueobj");
-
-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` } })
-  }
-}
-
-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)
-  }
-}
-
-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` } })
-  }
-}
-
-var tst4 = class test4 {
-  constructor(props) {
-    let t = this, fname = "test_all.test4.constructor"
-    t.log = props.log
-    t.id = props.id
-
-  }
-
-  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` } })
-  }
-}
-
-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

@@ -3,185 +3,70 @@
 * Main processing app
 */
 
-let base_queue = require("base-queue"),
-    log_queue = require("log-queue"),
-    fs = require('fs'),
-    validPath = require('valid-path')
-
-const { memoryUsage } = require('process')
-
-var log_data = [
-    { props: { id: 100, name: "console_basic", absolute_path: __filename, check: true } }
-]
-
-
-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'
-
-        t.process = t.process.bind(t)
-        t.do_checks = t.do_checks.bind(t)
-
-        if (props.check) {
-            t.do_checks()
-        }
-
-        return t
-    }
-
-    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})`
-        }
-
-        // 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)
-        }
-    }
-
-    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`} })
-        }
-    }
-}
-
-exports = module.exports = class QueueObj {
+let colors = require('colors'),
+    base_queue = require("./base_queue/app")
+
+colors.setTheme({
+    silly: 'rainbow',
+    input: 'grey',
+    verbose: 'cyan',
+    prompt: 'grey',
+    info: 'green',
+    data: 'grey',
+    help: 'cyan',
+    warn: 'yellow',
+    debug: 'blue',
+    error: 'red',
+    success: 'green'
+});
+
+exports = module.exports = class FilesQueue {
     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
+            var t = this
+            t.app_resolve = null
+            t.app_reject = null
             t.successMsg = ''
-            t.log_queue = null
 
             t.logMsg = t.logMsg.bind(t)
-            t.init = t.init.bind(t)
             t.process = t.process.bind(t)
             t.getFileObject = t.getFileObject.bind(t)
 
-            // t.logMsg(`QueueObj.constructor`.debug)
-
-            return t
-        } catch (e) {
-            e.message = `QueueObj app.js constructor error: ${e.message}`.error
-            console.log(e.message)
-        }
-    }
+            t.logMsg(`FilesQueue.constructor`.debug)
 
-    init() {
-        var t = this, fname = `QueueObj.init`
-        try {
-            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) {
-            t.logMsg({ msg: `${fname} error: (${e.message})`.error, type: 'error' })
-            // e.message = `QueueObj app.js constructor error: ${e.message}`.error
-            // console.log(e.message)
+            e.message = `FilesQueue app.js constructor error: ${e.message}`.error
+            throw (e)
         }
     }
 
     process(props = {}) {
-        let t = this, fname = `app.process`
+        let t = this
 
-        // if (typeof props.data_to_process_array == 'undefined')
-        //     t.reject('base_queue no props.data_to_process_array')
+        return new Promise((resolve, reject) => {
+            t.app_resolve = resolve
+            t.app_reject = reject
 
-        if (typeof props.appender == 'undefined')
-            t.reject('base_queue no props.appender')
+            if (typeof props.data_to_process_array == 'undefined')
+                t.app_reject('base_queue no props.data_to_process_array')
 
-        if (typeof props.process_objects == 'undefined')
-            t.reject(`props.process_objects not defined`)
+            if (typeof props.appender == 'undefined')
+                t.app_reject('base_queue no props.appender')
 
-        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) {
-            console.log(`${fname} error: (${e.message})`)
-        }
+            if (typeof props.process_objects == 'undefined')
+                t.app_reject(`props.process_objects not defined`)
+
+            props.parent = t
+            t.base_queue = new base_queue().load(props).process()
+        })
     }
 
     getFileObject() {
         return this.qJson.get_class_obj_array()
     }
 
-    logMsg(props = { msg: '', type: '' }) {   
-        let t = this, fname = "QueueObj.logMsg"
-        try {
-            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 = `${fname} error: ${e.message})`
-            t.reject(e.message)
-        }
+    logMsg(msg, props = {}) {
+        console.log(msg)
     }
 }

package/base_queue/app.js

@@ -0,0 +1,146 @@
+
+/*
+* @author Jim Manton: jrman@risebroadband.net
+* @since 2023-02-02
+* apps.js
+*/
+
+let cc = require("colors"),
+    file_requre_data = [
+        { props: { id: 100, name: "all", path: "./lib/appenders/all.js", absolute_path: __filename, check: true } }
+    ]
+
+cc.setTheme({
+    silly: 'rainbow',
+    input: 'grey',
+    verbose: 'cyan',
+    prompt: 'grey',
+    info: 'green',
+    data: 'grey',
+    help: 'cyan',
+    warn: 'yellow',
+    debug: 'blue',
+    error: 'red'
+});
+
+
+class process_object {
+    constructor(props) {
+        let t = this
+        t.parent = props.parent
+        t.status = 'process'
+        t.objs = t.parent.getParent().getObjs()
+    }
+
+    process() {
+        let t = this
+    }
+
+    continueProcessing() {
+        let t = this
+    }
+
+    getStatus() {
+        return this.status
+    }
+
+    setStatus(v) {
+        this.status = v
+    }
+}
+
+exports = module.exports = class BaseQueue {
+    constructor(props = {}) {
+        let t = this, fname = `BaseQueue app constructor`
+        try {
+            t.parent = null
+            t.appenders_dir = './appenders/'
+            t.appender = null
+
+            t.logMsg = t.logMsg.bind(t)
+            t.init = t.init.bind(t)
+            t.load = t.load.bind(t)
+            t.process = t.process.bind(t)
+            t.set_base_promise = t.set_base_promise.bind(t)
+            t.base_promise = null
+            t.base_resolve = null
+            t.base_reject = null
+
+            t.set_base_promise()
+
+            return t
+        } catch (e) {
+            t.logMsg(`${fname}: ${e.message}`.error)
+        }
+    }
+
+    set_base_promise() {
+        let t = this, fname = `BaseQueue set_base_promise`
+
+        t.base_promise = new Promise((resolve, reject) => {
+            t.base_resolve = resolve
+            t.base_reject = reject
+        })
+
+        t.base_promise.then(function (success) {
+            t.parent.app_resolve(success)
+        }).catch(function (err) {
+            t.parent.app_reject(err)
+        })
+
+    }
+
+    init(props = {}) {
+        let t = this, fname = `BaseQueue init`
+    }
+
+    load(props = {}) {
+        let t = this, fname = `BaseQueue load`, a, app, req
+
+        if (typeof props.parent == 'undefined')
+            t.base_reject(`${fname}: props.parent not defined`)
+
+        t.parent = props.parent
+        props.parent = t
+        app = props.appender
+        a = t.appenders_dir + app + '.js'
+        req = require(a)
+        t.parent.logMsg(`${fname} loading appender(${a})`.debug)
+        t.appender = new req(props)
+        return t
+    }
+
+    process() {
+        let t = this, fname = `BaseQueue process`, res, error_count = 0
+        try {
+            t.logMsg(`${fname}`.debug)
+
+            res = t.appender.init().process().get_results_array()
+            res.map((json, i) => {
+                if (typeof json.success != "undefined")
+                    t.logMsg(`${JSON.stringify(json)}`.success)
+                if (typeof json.error != "undefined") {
+                    t.logMsg(`${JSON.stringify(json)}`.error)
+                    error_count++
+                }
+            })
+            if (error_count) {
+                res.error_count = error_count
+                t.base_reject(res)
+            } else
+                t.base_resolve(res)
+        } catch (e) {
+            t.base_reject(`${fname}: ${e.message}.`)
+        }
+    }
+
+    logMsg(msg, props = {}) {
+        let t = this
+        try {
+            console.log(msg)
+            return t
+        } catch (e) {
+            t.base_reject(`BaseQueue log: ${e.message} for message (${msg})`)
+        }
+    }
+}

package/base_queue/appenders/base.js

@@ -0,0 +1,77 @@
+/*
+* @author Jim Manton: jrman@risebroadband.net
+* @since 2023-02-03
+* base.js
+*/
+
+exports = module.exports = class base {
+    constructor(props) {
+        let t = this, fname = `base appenders constructor`
+        try {
+            t.parent = props.parent
+            t.parent.logMsg(`${fname}`.debug)
+            t.class_obj_array = []
+            t.data_to_process_array = []
+            t.objects_to_process = []
+            t.results_array = []
+            t.base_name_appender = ''
+
+            if (typeof props.data_to_process_array == 'undefined')
+                throw new Error(`props.data_to_process_array not defined`)
+
+            if (typeof props.process_objects == 'undefined')
+                throw new Error(`props.process_objects not defined`)
+
+            if (typeof props.appender == 'undefined')
+                throw new Error(`appender not defined)`)
+
+            t.base_name_appender = props.appender
+            t.data_to_process_array = props.data_to_process_array
+            t.objects_to_process = props.process_objects
+
+            t.init = t.init.bind(t)
+            t.get_objects_to_process = t.get_objects_to_process.bind(t)
+            t.get_data_to_process_array = t.get_data_to_process_array.bind(t)
+            t.process = t.process.bind(t)
+            t.get_results_array = t.get_results_array.bind(t)
+
+            return t
+        } catch (e) {
+            t.parent.base_reject(`${fname} error: ${e.message})`)
+        }
+    }
+	
+	process (props = {}) {
+		var t = this, fname = `base.process`
+		try {
+			t.parent.logMsg(`${fname}`.debug)
+
+			return t
+		} catch (e) {
+            t.parent.base_reject(`${fname} error: ${e.message})`)
+		}
+	}
+
+    get_results_array () {
+        return this.results_array
+    }
+
+    get_data_to_process_array () {
+        return this.data_to_process_array
+    }
+
+    get_objects_to_process () {
+        return this.objects_to_process
+    }
+    
+	init (props = {}) {
+		var t = this, fname = `base.init`
+		try {
+
+			t.parent.logMsg(`${fname}`.debug)
+			return t
+		} catch (e) {
+            t.parent.base_reject(`${fname} error: ${e.message})`)
+		}
+	}
+}

package/base_queue/appenders/json_all.js

@@ -0,0 +1,70 @@
+/*
+* @author Jim Manton: jrman@risebroadband.net
+* @since 2022-12-11
+* all.ts
+*/
+
+var base = require('./base.js')
+
+exports = module.exports = class json_all extends base {
+	constructor(props) {
+		super(props)
+		var t = this, fname = 'json_all.constructor'
+		try {
+			t.aname = 'json_all'
+			t.main_process_objects = []
+			
+            if (t.base_name_appender != t.aname)
+                throw new Error(`(${t.base_name_appender}) does not equal the appender name (${t.aname}))`)
+
+			t.parent.logMsg(`${fname}`.debug)
+			
+            t.init = t.init.bind(t)
+            t.process = t.process.bind(t)
+
+			return t
+		} catch (e) {
+            t.parent.base_reject(`${fname} error: ${e.message})`)
+		}
+	}
+
+	init (props = {}) {
+		var t = this, fname = `json_all.init`, gotp, gdtpa, obj
+		try {
+			t.parent.logMsg(`${fname}`.debug)
+
+			if (typeof t.get_objects_to_process()[0] == "undefined")
+				throw new Error(`get_objects_to_process[0] has no data`)
+
+			t.get_data_to_process_array().map((dat, i)=>{
+				dat.props.log = t.parent.logMsg
+				obj = t.get_objects_to_process()[0]
+				t.main_process_objects.push(new obj(dat.props))
+			})
+
+			super.init(props)
+			return t
+		} catch (e) {
+            t.parent.base_reject(`${fname} error: ${e.message})`)
+		}
+	}
+	
+	process (props = {}) {
+		var t = this, fname = `json_all.process`
+		try {
+			t.parent.logMsg(`${fname} length(${t.main_process_objects.length})`.debug)
+
+			t.main_process_objects.map((obj, i)=>{
+				obj.process((res)=>{
+					// t.parent.logMsg(`${fname}${JSON.stringify(res)})`.debug)
+					t.results_array.push(res)
+				})
+			})
+
+			super.process(props)
+			return t
+		} catch (e) {
+            t.parent.base_reject(`${fname} error: ${e.message})`)
+		}
+	}
+}