not-node 6.5.17 → 6.5.20

package/.husky/pre-commit

@@ -1,4 +1 @@
-#!/usr/bin/env sh
-. "$(dirname -- "$0")/_/husky.sh"
-
 npm test

package/index.js

@@ -37,6 +37,8 @@ module.exports.Enrich = require("./src/model/enrich");
 module.exports.Routine = require("./src/model/routine");
 /** Common functions */
 module.exports.Common = require("./src/common");
+/** Task Runner */
+module.exports.TaskRunner = require("./src/task.runner.js");
 /** Fields library manager */
 module.exports.Fields = require("./src/fields");
 /** Application generic helpers */

package/package.json

@@ -1,10 +1,10 @@
 {
 	"name": "not-node",
-	"version": "6.5.17",
+	"version": "6.5.20",
 	"description": "node complimentary part for client side notFramework.",
 	"main": "index.js",
 	"scripts": {
-		"test": "mocha --require mocha-suppress-logs --reporter spec  --timeout 12000",
+		"test": "mocha --exit --require mocha-suppress-logs --reporter spec  --timeout 12000",
 		"lint": "eslint ./src --fix",
 		"pretest": "eslint ./src",
 		"docs": "jsdoc -c jsdoc.json",

package/src/auth/fields.js

@@ -24,7 +24,7 @@ function getOwnerId(data, ownerFieldName = CONST.DOCUMENT_OWNER_FIELD_NAME) {
 /**
  * Check if data is belongs to user
  * @param {Object}   data      object
- * @param {import('mongoose').Schema.Types.ObjectId} user_id   possible owner
+ * @param {import('mongoose').Schema.Types.ObjectId|string} user_id   possible owner
  * @return {boolean}           true - belongs, false - not belongs
  **/
 

package/src/domain.js

@@ -59,7 +59,6 @@ class notDomain extends EventEmitter {
     constructor(options) {
         super();
         this.#options = options;
-
         return this;
     }
 
@@ -138,8 +137,8 @@ class notDomain extends EventEmitter {
 
     /**
      *  Returns route
-     *  @param   {string}  name   'moduleName//routeName//functionName' ('not-user//user//add')
-     *  @return {function}      route
+     *  @param      {string}  name   'moduleName//routeName//functionName' ('not-user//user//add')
+     *  @return     {function}      route
      **/
     getRoute(name) {
         if (name.indexOf("//") > 0) {

package/src/generic/route.js

@@ -25,14 +25,14 @@ module.exports = ({ getLogic, before, after }) => {
                 );
             }
             if (this.rootAsUser) {
-                return await getLogic().createOwn(prepared);
+                return await getLogic(prepared).createOwn(prepared);
             } else {
-                return await getLogic().create(prepared);
+                return await getLogic(prepared).create(prepared);
             }
         }
 
         static async create(req, res, next, prepared) {
-            return await getLogic().createOwn(prepared);
+            return await getLogic(prepared).createOwn(prepared);
         }
 
         static async _get(req, res, next, prepared) {
@@ -42,14 +42,14 @@ module.exports = ({ getLogic, before, after }) => {
                 );
             }
             if (this.rootAsUser) {
-                return await getLogic().getOwn(prepared);
+                return await getLogic(prepared).getOwn(prepared);
             } else {
-                return await getLogic().get(prepared);
+                return await getLogic(prepared).get(prepared);
             }
         }
 
         static async get(req, res, next, prepared) {
-            return await getLogic().getOwn(prepared);
+            return await getLogic(prepared).getOwn(prepared);
         }
 
         static async _getByID(req, res, next, prepared) {
@@ -59,14 +59,14 @@ module.exports = ({ getLogic, before, after }) => {
                 );
             }
             if (this.rootAsUser) {
-                return await getLogic().getByIDOwn(prepared);
+                return await getLogic(prepared).getByIDOwn(prepared);
             } else {
-                return await getLogic().getByID(prepared);
+                return await getLogic(prepared).getByID(prepared);
             }
         }
 
         static async getByID(req, res, next, prepared) {
-            return await getLogic().getByIDOwn(prepared);
+            return await getLogic(prepared).getByIDOwn(prepared);
         }
 
         static async _getRaw(req, res, next, prepared) {
@@ -76,14 +76,14 @@ module.exports = ({ getLogic, before, after }) => {
                 );
             }
             if (this.rootAsUser) {
-                return await getLogic().getOwnRaw(prepared);
+                return await getLogic(prepared).getOwnRaw(prepared);
             } else {
-                return await getLogic().getRaw(prepared);
+                return await getLogic(prepared).getRaw(prepared);
             }
         }
 
         static async getRaw(req, res, next, prepared) {
-            return await getLogic().getOwnRaw(prepared);
+            return await getLogic(prepared).getOwnRaw(prepared);
         }
 
         static async _update(req, res, next, prepared) {
@@ -93,14 +93,14 @@ module.exports = ({ getLogic, before, after }) => {
                 );
             }
             if (this.rootAsUser) {
-                return await getLogic().updateOwn(prepared);
+                return await getLogic(prepared).updateOwn(prepared);
             } else {
-                return await getLogic().update(prepared);
+                return await getLogic(prepared).update(prepared);
             }
         }
 
         static async update(req, res, next, prepared) {
-            return await getLogic().updateOwn(prepared);
+            return await getLogic(prepared).updateOwn(prepared);
         }
 
         static async _listAll(req, res, next, prepared) {
@@ -110,14 +110,14 @@ module.exports = ({ getLogic, before, after }) => {
                 );
             }
             if (this.rootAsUser) {
-                return await getLogic().listAllOwn(prepared);
+                return await getLogic(prepared).listAllOwn(prepared);
             } else {
-                return await getLogic().listAll(prepared);
+                return await getLogic(prepared).listAll(prepared);
             }
         }
 
         static async listAll(req, res, next, prepared) {
-            return await getLogic().listAllOwn(prepared);
+            return await getLogic(prepared).listAllOwn(prepared);
         }
 
         static async _listAndCount(req, res, next, prepared) {
@@ -127,14 +127,14 @@ module.exports = ({ getLogic, before, after }) => {
                 );
             }
             if (this.rootAsUser) {
-                return await getLogic().listAndCountOwn(prepared);
+                return await getLogic(prepared).listAndCountOwn(prepared);
             } else {
-                return await getLogic().listAndCount(prepared);
+                return await getLogic(prepared).listAndCount(prepared);
             }
         }
 
         static async listAndCount(req, res, next, prepared) {
-            return await getLogic().listAndCountOwn(prepared);
+            return await getLogic(prepared).listAndCountOwn(prepared);
         }
 
         static async _list(req, res, next, prepared) {
@@ -144,14 +144,14 @@ module.exports = ({ getLogic, before, after }) => {
                 );
             }
             if (this.rootAsUser) {
-                return await getLogic().listOwn(prepared);
+                return await getLogic(prepared).listOwn(prepared);
             } else {
-                return await getLogic().list(prepared);
+                return await getLogic(prepared).list(prepared);
             }
         }
 
         static async list(req, res, next, prepared) {
-            return await getLogic().listOwn(prepared);
+            return await getLogic(prepared).listOwn(prepared);
         }
 
         static async _count(req, res, next, prepared) {
@@ -161,14 +161,14 @@ module.exports = ({ getLogic, before, after }) => {
                 );
             }
             if (this.rootAsUser) {
-                return await getLogic().countOwn(prepared);
+                return await getLogic(prepared).countOwn(prepared);
             } else {
-                return await getLogic().count(prepared);
+                return await getLogic(prepared).count(prepared);
             }
         }
 
         static async count(req, res, next, prepared) {
-            return await getLogic().countOwn(prepared);
+            return await getLogic(prepared).countOwn(prepared);
         }
 
         static async _delete(req, res, next, prepared) {
@@ -178,14 +178,14 @@ module.exports = ({ getLogic, before, after }) => {
                 );
             }
             if (this.rootAsUser) {
-                return await getLogic().deleteOwn(prepared);
+                return await getLogic(prepared).deleteOwn(prepared);
             } else {
-                return await getLogic().delete(prepared);
+                return await getLogic(prepared).delete(prepared);
             }
         }
 
         static async delete(req, res, next, prepared) {
-            return await getLogic().deleteOwn(prepared);
+            return await getLogic(prepared).deleteOwn(prepared);
         }
     }
 

package/src/task.runner.js

@@ -0,0 +1,95 @@
+const MIN_TASK_CHECK_INTERVAL = 3600;
+
+class TaskRunner {
+    static #logger = console;
+    static #runEvery = 3600;
+    static #checkEvery = 3500; //every hour
+    static #int = setInterval(TaskRunner.#check, TaskRunner.#checkEvery * 1000);
+    static #tasks = [];
+
+    static setLogger(logger) {
+        TaskRunner.#logger = logger;
+    }
+
+    static #create(id, task, tag) {
+        return {
+            id,
+            task,
+            tag,
+            count: 0,
+            lastRunnedAt: -1,
+        };
+    }
+
+    static add(task, tag) {
+        const id = Math.random();
+        if (!tag) {
+            tag = `task#${TaskRunner.#tasks.length + 1}`;
+        }
+        TaskRunner.#tasks.push(TaskRunner.#create(id, task, tag));
+    }
+
+    static remove(id) {
+        const task = TaskRunner.#tasks.find((item) => item.id === id);
+        if (task) {
+            TaskRunner.#tasks.splice(TaskRunner.#tasks.indexOf(task), 1);
+            return true;
+        }
+        return false;
+    }
+
+    static clear() {
+        this.#tasks = [];
+    }
+
+    static async #check() {
+        try {
+            const runners = TaskRunner.#tasks
+                .filter(TaskRunner.#taskShouldBeRunned)
+                .map(TaskRunner.#taskToPromise);
+            await Promise.allSettled(runners);
+        } catch (e) {
+            TaskRunner.#logger.error("Task Set Failed", new Date(), e);
+        }
+    }
+
+    static async #taskToPromise(taskItem) {
+        const { tag } = taskItem;
+        try {
+            await taskItem.task();
+            taskItem.lastRunnedAt = Date.now();
+            taskItem.count += 1;
+        } catch (e) {
+            TaskRunner.#logger.error("Task Failed", tag, new Date(), e);
+        }
+    }
+
+    static #taskShouldBeRunned(taskItem) {
+        if (taskItem.count === 0) {
+            return true;
+        }
+        return taskItem.lastRunnedAt < Date.now() - TaskRunner.#runEvery;
+    }
+
+    static stop() {
+        clearInterval(TaskRunner.#int);
+    }
+
+    static start() {
+        TaskRunner.#int = setInterval(
+            TaskRunner.#check,
+            TaskRunner.#checkEvery * 1000
+        );
+    }
+
+    static setInterval(int = MIN_TASK_CHECK_INTERVAL) {
+        if (isNaN(int) || int < MIN_TASK_CHECK_INTERVAL) {
+            return false;
+        }
+        TaskRunner.#checkEvery = int;
+        TaskRunner.stop();
+        TaskRunner.start();
+    }
+}
+
+module.exports = TaskRunner;

package/.eslintignore

@@ -1,4 +0,0 @@
-/node_modules/**
-src/rollup.js
-src/repos.js
-src/lib.js