base-queue 0.0.1

package/.github/workflows/actions.yml

@@ -0,0 +1,18 @@
+name: GitHub Actions
+run-name: ${{ github.actor }} is testing out GitHub Actions 🚀
+on: [push]
+jobs:
+  Explore-GitHub-Actions:
+    runs-on: ubuntu-latest
+    steps:
+      - run: echo "🎉 The job was automatically triggered by a ${{ github.event_name }} event."
+      - run: echo "🐧 This job is now running on a ${{ runner.os }} server hosted by GitHub!"
+      - run: echo "🔎 The name of your branch is ${{ github.ref }} and your repository is ${{ github.repository }}."
+      - name: Check out repository code
+        uses: actions/checkout@v3
+      - run: echo "💡 The ${{ github.repository }} repository has been cloned to the runner."
+      - run: echo "🖥️ The workflow is now ready to test your code on the runner."
+      - name: List files in the repository
+        run: |
+          ls ${{ github.workspace }}
+      - run: echo "🍏 This job's status is ${{ job.status }}."

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

@@ -0,0 +1,80 @@
+# This workflow will do a clean installation of node dependencies, cache/restore them, build the source code and run tests across different versions of node
+# For more information see: https://help.github.com/actions/language-and-framework-guides/using-nodejs-with-github-actions
+
+name: Node.js CI
+
+on:
+  push:
+    branches: [ "master" ]
+  pull_request:
+    branches: [ "master" ]
+  workflow_dispatch: {}
+
+jobs:
+  build:
+
+    runs-on: ${{ matrix.os }}
+
+    defaults:
+      run:
+        shell: bash
+
+    strategy:
+      matrix:
+        os: [ubuntu-latest, windows-latest]
+        node-version: [8.x, 10.x, 12.x, 14.x, 16.x, 18.x]
+        # See supported Node.js release schedule at https://nodejs.org/en/about/releases/
+        include:
+          - node-version: 8.x
+            npm-i: "eslint@6.x eslint-config-airbnb-base@14.x eslint-config-prettier@6.x eslint-plugin-prettier@3.x fs-extra@8.x nyc@14.x tap@14.x"
+
+          - node-version: 10.x
+            npm-i: "eslint@7.x fs-extra@9.x nyc@14.x tap@14.x"
+
+          - node-version: 12.x
+            npm-i: "nyc@14.x tap@14.x"
+
+          - node-version: 14.x
+            npm-i: "nyc@14.x tap@14.x"
+
+    steps:
+    - uses: actions/checkout@v3
+    - name: Use Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v3
+      with:
+        node-version: ${{ matrix.node-version }}
+        cache: 'npm'
+
+    - name: Configure npm
+      run: npm config set loglevel error
+
+    - name: Get npm version
+      id: npm-version
+      run: |
+        npm -v
+        npmMajorVer=$(npm -v | cut -d. -f1)
+        echo "major=$npmMajorVer" >> $GITHUB_OUTPUT
+    - name: Disable prettier on older Node.js (8.x, 10.x, 12.x)
+      run: |
+        sed -i '/"prettier": "prettier/d' package.json
+      if: contains(fromJson('["8.x", "10.x", "12.x"]'), matrix.node-version)
+
+    - name: Install downgraded modules ${{ matrix.npm-i }}
+      run: |
+        npm install --save-dev ${{ matrix.npm-i }}
+        if [ ${{ steps.npm-version.outputs.major }} -le 5 ]; then
+          npm install
+        fi
+      if: matrix.npm-i != ''
+
+    - run: npm install
+      if: matrix.npm-i == '' && steps.npm-version.outputs.major <= 5
+
+    - run: npm ci
+      if: matrix.npm-i == '' && steps.npm-version.outputs.major > 5
+
+    - name: List dependencies
+      run: npm ls --depth=0 --dev && npm ls --depth=0 --prod
+
+    - run: npm run build --if-present
+    - run: npm run test_base

package/README.md

@@ -0,0 +1,22 @@
+
+[![npm Package](https://img.shields.io/npm/v/base-queue.svg)](https://www.npmjs.org/package/base-queue)
+[![License](https://img.shields.io/npm/l/log.svg)](https://github.com/jman717/log/blob/master/LICENSE)
+[![CodeQL](https://github.com/jman717/log/actions/workflows/actions.yml/badge.svg)](https://github.com/jman717/log/actions/workflows/actions.yml)
+[![Node.js CI](https://github.com/jman717/log/actions/workflows/node.js.yml/badge.svg)](https://github.com/jman717/log/actions/workflows/node.js.yml)
+
+[![NPM](https://nodei.co/npm/base-queue.png?downloads=true&downloadRank=true&stars=true)](https://nodei.co/npm/base-queue/)
+
+Base appenders for various queueing processes.
+
+Mocha Test
+---------
+```
+npm test
+```
+
+General Setup Test
+---------
+```
+npm run test_base
+
+```

package/app.js

@@ -0,0 +1,109 @@
+
+/*
+* @author Jim Manton: jrman@risebroadband.net
+* @since 2023-02-02
+* apps.js
+*/
+
+exports = module.exports = class BaseQueue {
+    constructor(props = {}) {
+        let t = this, fname = `BaseQueue.constructor`
+        try {
+            t.appender = null
+            t.relative_path = props.relative_path
+
+            t.init = t.init.bind(t)
+            t.load = t.load.bind(t)
+            t.process = t.process.bind(t)
+            t.process_count = 0
+            t.reported = false
+
+            if (typeof props.parent == 'undefined') {
+                console.log(`${fname}: props.parent not defined`)
+            }
+            t.parent = props.parent
+            t.logMsg = props.logMsg
+            t.resolve = props.resolve
+            t.reject = props.reject
+
+            return t
+        } catch (e) {
+            e.message = `${fname} error: ${e.message}`
+            console.log(`${e.message}`.error)
+            throw (e)
+        }
+    }
+
+    init(props = {}) {
+        let t = this, fname = `BaseQueue.init`
+        t.logMsg({ msg: `${fname}`.debug, type: 'debug' })
+    }
+
+    load(props = {}) {
+        let t = this, fname = `BaseQueue.load`, a, app, req, msg
+        try {
+            props.parent = t
+            app = props.appender
+            a = t.relative_path + app + '.js'
+            try {
+                req = require(a)
+            } catch (e) {
+                msg = { "msg": `${fname} error: (${e.message})`.error, "type": "error" }
+                // t.logMsg(msg)
+                throw e
+            }
+            t.logMsg({ "msg": `${fname} loading appender(${a})`.debug, "type": "debug" })
+            props.relative_path = t.relative_path
+            t.appender = new req(props)
+            return t
+        } catch (e) {
+            e.message = `${fname} error: (${e.message})`
+            console.log(`${e.message}`.error)
+            throw e
+        }
+    }
+
+    process() {
+        let t = this, fname = `BaseQueue.process`, app, res, error_count = 0
+        try {
+            if (t.process_count > t.appender.main_process_objects.length)
+                t.appender.status = "done"
+            t.logMsg({ msg: `${fname} status(${t.appender.status}) process_count(${t.process_count}) process array size(${t.appender.main_process_objects.length})`.debug, type: 'debug' })
+            switch (t.appender.status) {
+                case "init":
+                    t.appender.init()
+                    break
+                case "process":
+                    t.appender.process()
+                    break
+                case "wait":
+                    setTimeout(() => {
+                        t.process()
+                    }, 2000)
+                    break
+                case "done":
+                    if (!t.reported) {
+                        t.reported = true
+                        res = t.appender.get_results_array()
+                        res.map((json, i) => {
+                            if (typeof json.success != "undefined")
+                                t.logMsg({ msg: `${JSON.stringify(json.success)}`.success, type: 'success' })
+                            if (typeof json.error != "undefined") {
+                                t.logMsg({ msg: `${JSON.stringify(json.error)}`.error, type: 'error' })
+                                error_count++
+                            }
+                        })
+                        if (error_count) {
+                            res.error_count = error_count
+                            t.reject(res)
+                        } else {
+                            t.resolve(res)
+                        }
+                    }
+                    return t
+            }
+        } catch (e) {
+            t.reject(`${fname}: ${e.message}.`)
+        }
+    }
+}

package/appenders/all.js

@@ -0,0 +1,69 @@
+/*
+* @author Jim Manton: jrman@risebroadband.net
+* @since 2023-2-5
+* all.js
+*/
+
+var base = require('./base.js')
+
+exports = module.exports = class all extends base {
+	constructor(props) {
+		super(props)
+		var t = this, fname = 'all.constructor'
+		try {
+			t.aname = 'all'
+			t.main_process_objects = []
+
+			if (t.appender != t.aname)
+				throw new Error(`(${t.appender}) does not equal the appender name (${t.aname}))`)
+
+			t.parent.logMsg({msg: `${fname} objects to process count(${t.get_objects_to_process().length})`.debug, type: "debug"})
+
+			t.init = t.init.bind(t)
+			t.process = t.process.bind(t)
+
+			return t
+		} catch (e) {
+            e.message = `${fname} error: ${e.message})`
+            throw e
+			// t.parent.app_reject(`${fname} error: ${e.message})`)
+		}
+	}
+
+	init(props = {}) {
+		var t = this, fname = `all.init`, obj
+		try {
+			t.parent.logMsg({msg: `${fname}`.debug, type: "debug"})
+
+			if (typeof t.get_objects_to_process()[0] == "undefined")
+				throw new Error(`get_objects_to_process[0] has no data`)
+
+			t.get_objects_to_process().map((dat, i) => {
+				dat = {props: {id: (i+1), log: t.parent.logMsg}}
+				obj = t.get_objects_to_process()[i]
+				t.main_process_objects.push(new obj(dat.props))
+			})
+
+			super.init(props)
+			return t
+		} catch (e) {
+            e.message = `${fname} error: ${e.message})`
+            throw e
+			// t.parent.app_reject(`${fname} error: ${e.message})`)
+		}
+	}
+
+	process(props = {}) {
+		var t = this, fname = `all.process`
+		try {
+			t.parent.logMsg({msg: `${fname}`.debug, type: "debug"})
+
+			super.process(props)
+			return t
+		} catch (e) {
+            e.message = `${fname} error: ${e.message})`
+            throw e
+			// t.parent.app_reject(`${fname} error: ${e.message})`)
+		}
+	}
+}

package/appenders/base.js

@@ -0,0 +1,149 @@
+/*
+* @author Jim Manton: jrman@risebroadband.net
+* @since 2023-02-03
+* base.js
+*/
+
+exports = module.exports = class base {
+    constructor(props) {
+        let t = this, fname = `base.constructor`
+        try {
+            t.parent = props.parent
+            t.parent.logMsg({ msg: `${fname}`.debug, type: "debug" })
+            t.status = "init"
+            t.relative_path = ''
+            t.class_obj_array = []
+            t.data_to_process_array = []
+            t.objects_to_process = []
+            t.results_array = []
+            t.appender = ''
+
+            if (typeof props.relative_path == 'undefined')
+                throw new Error(`props.relative_path 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.appender = props.appender
+            t.data_to_process_array = props.data_to_process_array
+            t.objects_to_process = props.process_objects
+            t.include_status = props.include_status
+            t.exclude_status = props.exclude_status
+            t.include_version = props.include_version
+            t.exclude_version = props.exclude_version
+            t.include_names = props.include_names
+            t.exclude_names = props.exclude_names
+            t.relative_path = props.relative_path
+
+            t.init = t.init.bind(t)
+            t.get_objects_to_process = t.get_objects_to_process.bind(t)
+            t.get_include_status = t.get_include_status.bind(t)
+            t.get_exclude_status = t.get_exclude_status.bind(t)
+            t.get_include_names = t.get_include_names.bind(t)
+            t.get_exclude_names = t.get_exclude_names.bind(t)
+            t.get_include_version = t.get_include_version.bind(t)
+            t.get_exclude_version = t.get_exclude_version.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) {
+            e.message = `${fname} error: ${e.message})`
+            throw e
+            // t.parent.app_reject(`${fname} error: ${e.message})`)
+        }
+    }
+
+    process() {
+        var t = this, fname = `base.process`, pro, pro_process
+        try {
+            t.parent.logMsg({ msg: `${fname}`.debug, type: "debug" })
+
+            if (t.parent.process_count > t.main_process_objects.length) {
+                t.status = "done"
+                t.parent.process()
+                return
+            }
+            if (t.status == "process") {
+                pro = t.main_process_objects[t.parent.process_count++]
+                if (typeof pro != "undefined") {
+                    if (typeof pro.base_queue_process_function == "function")
+                        pro_process = pro.base_queue_process_function
+                    else
+                        if (typeof pro.process == "function")
+                            pro_process = pro.process
+
+                    t.parent.logMsg({ msg: `${fname} status(${t.status}) count(${t.parent.process_count}) main objects(${t.main_process_objects.length})`.debug, type: "debug" })
+
+                    pro_process((res) => {
+                        t.results_array.push(res)
+                        t.status = "process"
+                        t.parent.process()
+                        return
+                    })
+                } else
+                    t.status = "done"
+            }
+            if (t.status != "done")
+                t.status = "wait"
+            t.parent.process()
+        } catch (e) {
+            e.message = `${fname} error: ${e.message})`
+            t.parent.logMsg({ msg: `${fname} error: (${e.message})`.error, type: "error" })
+            throw e
+            // t.parent.app_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
+    }
+
+    get_include_status() {
+        return this.include_status
+    }
+
+    get_exclude_status() {
+        return this.exclude_status
+    }
+
+    get_include_version() {
+        return this.include_version
+    }
+
+    get_exclude_version() {
+        return this.exclude_version
+    }
+
+    get_include_names() {
+        return this.include_names
+    }
+
+    get_exclude_names() {
+        return this.exclude_status
+    }
+
+    init(props = {}) {
+        var t = this, fname = `base.init`, pr
+        try {
+            t.parent.logMsg({ msg: `${fname}`.debug, type: "debug" })
+            t.status = "process"
+            t.parent.process()
+        } catch (e) {
+            e.message = `${fname} error: ${e.message})`
+            throw e
+        }
+    }
+}

package/appenders/bottom_one.js

@@ -0,0 +1,68 @@
+/*
+* @author Jim Manton: jrman@risebroadband.net
+* @since 2023-2-5
+* bottom_one.js
+*/
+
+var base = require('./base.js')
+
+exports = module.exports = class bottom_one extends base {
+	constructor(props) {
+		super(props)
+		var t = this, fname = 'bottom_one.constructor'
+		try {
+			t.aname = 'bottom_one'
+			t.main_process_objects = []
+
+			if (t.appender != t.aname)
+				throw new Error(`(${t.appender}) does not equal the appender name (${t.aname}))`)
+
+			t.parent.logMsg({ msg: `${fname} objects to process count(${t.get_objects_to_process().length})`.debug, type: "debug" })
+
+			t.init = t.init.bind(t)
+			t.process = t.process.bind(t)
+
+			return t
+		} catch (e) {
+			e.message = `${fname} error: ${e.message})`
+			throw e
+			// t.parent.app_reject(`${fname} error: ${e.message})`)
+		}
+	}
+
+	init(props = {}) {
+		var t = this, fname = `bottom_one.init`, obj, dat, gotp
+		try {
+			t.parent.logMsg({ msg: `${fname}`.debug, type: "debug" })
+
+			if (typeof t.get_objects_to_process()[0] == "undefined")
+				throw new Error(`get_objects_to_process[0] has no data`)
+
+			gotp = t.get_objects_to_process()
+			obj = gotp[gotp.length - 1]
+			dat = { props: { id: gotp.length, log: t.parent.logMsg } }
+			t.main_process_objects.push(new obj(dat.props))
+
+			super.init(props)
+			return t
+		} catch (e) {
+			e.message = `${fname} error: ${e.message})`
+			throw e
+			// t.parent.app_reject(`${fname} error: ${e.message})`)
+		}
+	}
+
+	process(props = {}) {
+		var t = this, fname = `bottom_one.process`
+		try {
+			t.parent.logMsg({ msg: `${fname}`.debug, type: "debug" })
+
+			super.process(props)
+			return t
+		} catch (e) {
+			e.message = `${fname} error: ${e.message})`
+			throw e
+			// t.parent.app_reject(`${fname} error: ${e.message})`)
+		}
+	}
+}

package/appenders/common_code.js

@@ -0,0 +1,56 @@
+/*
+* @author Jim Manton: jrman@risebroadband.net
+* @since 2023-02-03
+* common_code.js
+*/
+
+exports = module.exports = class common_code {
+    constructor(props) {
+        let t = this, fname = `common_code.constructor`
+        try {
+            t.parent = props.parent
+            t.log = props.log
+            t.log({ msg: `${fname}`.debug, type: "debug" })
+            t.include_func = props.include_func
+            t.exclude_func = props.exclude_func
+            t.by_what = props.by_what
+            return t
+        } catch (e) {
+            e.message = `${fname} error: ${e.message})`
+            t.log({ msg: `${fname}: ${e.message}`.error, type: "error" })
+            throw e
+            // t.parent.app_reject(`${fname} error: ${e.message})`)
+        }
+    }
+
+    init(props) {
+        let t = this, fname = `common_code.init`, obj_a, is, xis, obj, dat
+        try {
+            obj = props.obj
+            dat = props.dat
+            is = t.include_func()
+            xis = t.exclude_func()
+            t.log({ msg: `${fname} is(${JSON.stringify(is)}  xis(${JSON.stringify(xis)})`.debug, type: "debug" })
+            obj_a = new obj(dat.props)
+            if (typeof is != "undefined") {
+                if (typeof obj_a != "undefined" &&
+                    typeof eval(`obj_a.${t.by_what}`) != "undefined" &&
+                    is.indexOf(eval(`obj_a.${t.by_what}`)) > -1) {
+                    t.parent.main_process_objects.push(new obj(dat.props))
+                }
+            }
+            if (typeof xis != "undefined") {
+                if (typeof obj_a != "undefined" &&
+                    typeof eval(`obj_a.${t.by_what}`) != "undefined" &&
+                    xis.indexOf(eval(`obj_a.${t.by_what}`)) < 0) {
+                    t.parent.main_process_objects.push(new obj(dat.props))
+                }
+            }
+            return t
+        } catch (e) {
+            e.message = `${fname} error: ${e.message})`
+            t.log({ msg: `${fname}: ${e.message}`.error, type: "error" })
+            throw e
+        }
+    }
+}

package/appenders/func_all.js

@@ -0,0 +1,83 @@
+/*
+* @author Jim Manton: jrman@risebroadband.net
+* @since 2023-2-5
+* func_all.js
+*/
+
+var base = require('./base.js')
+
+exports = module.exports = class func_all extends base {
+	constructor(props) {
+		super(props)
+		var t = this, fname = 'func_all.constructor'
+		try {
+			t.aname = 'func_all'
+			t.main_process_objects = []
+
+			if (t.appender != t.aname)
+				throw new Error(`(${t.appender}) does not equal the appender name (${t.aname}))`)
+
+			t.parent.logMsg({msg: `${fname} objects to process count(${t.get_objects_to_process().length})`.debug, type: "debug"})
+
+			t.init = t.init.bind(t)
+			t.process = t.process.bind(t)
+			t.custom_function = t.custom_function.bind(t)
+
+			return t
+		} catch (e) {
+            e.message = `${fname} error: ${e.message})`
+            throw e
+			// t.parent.app_reject(`${fname} error: ${e.message})`)
+		}
+	}
+
+	init(props = {}) {
+		var t = this, fname = `func_all.init`, obj
+		try {
+			t.parent.logMsg({msg: `${fname}`.debug, type: "debug"})
+
+			if (typeof t.get_objects_to_process()[0] == "undefined")
+				throw new Error(`get_objects_to_process[0] has no data`)
+
+			t.get_objects_to_process().map((dat, i) => {
+				dat = {props: {id: (i+1), log: t.parent.logMsg}}
+				obj = t.get_objects_to_process()[i]
+				t.main_process_objects.push(new obj(dat.props))
+			})
+
+			super.init(props)
+			return t
+		} catch (e) {
+            e.message = `${fname} error: ${e.message})`
+			t.parent.logMsg({msg: `${fname} error: ${e.message}`.error, type: "error"})
+            throw e
+			// t.parent.app_reject(`${fname} error: ${e.message})`)
+		}
+	}
+
+	custom_function(func){
+		var t = this, fname = `func_all.custom_function`
+		try {
+			t.parent.logMsg({msg: `${fname} typeof func(${typeof func}) WORK HERE`.bgBrightMagenta, type: "debug"})
+			return t
+		} catch (e) {
+            e.message = `${fname} error: ${e.message})`
+			t.parent.logMsg({msg: `${fname}`.error, type: "error"})
+            throw e
+		}
+	}
+
+	process(props = {}) {
+		var t = this, fname = `func_all.process`
+		try {
+			t.parent.logMsg({msg: `${fname}`.debug, type: "debug"})
+
+			super.process(props)
+			return t
+		} catch (e) {
+            e.message = `${fname} error: ${e.message})`
+            throw e
+			// t.parent.app_reject(`${fname} error: ${e.message})`)
+		}
+	}
+}