not-node 6.3.52 → 6.3.53

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "not-node",
-	"version": "6.3.52",
+	"version": "6.3.53",
 	"description": "node complimentary part for client side notFramework.",
 	"main": "index.js",
 	"scripts": {

package/src/logic/action.runner.js

@@ -3,7 +3,7 @@ const { ActionExceptionWrongType } = require("../exceptions/action.js");
 class ActionRunner {
     static async run(action, params) {
         //any static class with static run method
-        if (typeof action === "function" && typeof action.run === "function") {
+        if (action && typeof action.run === "function") {
             return await action.run(...params);
         } else if (typeof action === "function") {
             return await action(...params);

package/src/logic/actions.before/index.js

@@ -3,5 +3,6 @@ const ActionsSetsLibrary = require("../actions.lib.js");
 const ActionsBefore = new ActionsSetsLibrary();
 
 ActionsBefore.add("ownage", require("./ownage"));
+ActionsBefore.add("standartQueries", require("./standart.queries.js"));
 
 module.exports = ActionsBefore;

package/src/logic/actions.before/standart.queries.js

@@ -0,0 +1,28 @@
+const ModelRoutine = require("../../model/routine.js");
+
+//adds to args object few basic queries
+module.exports = class StandartQueriesBeforeAction {
+    static async run(logic, actionName, args) {
+        try {
+            const { targetId, targetID } = args;
+            args.defaultQueryById = {
+                _id: targetId,
+            };
+            const Model = logic.getModel();
+            const incFieldName = ModelRoutine.incremental(Model);
+            if (
+                incFieldName &&
+                typeof targetID === "number" &&
+                !isNaN(targetID) &&
+                targetID
+            ) {
+                args.defaultQueryByID = {
+                    [incFieldName]: targetID,
+                };
+            }
+            args.defaultQueryMany = {};
+        } catch (e) {
+            logic.log.error(e);
+        }
+    }
+};

package/src/logic/actions.lib.js

@@ -13,6 +13,10 @@ class ActionsSetsLibrary {
         }
         return {};
     }
+
+    has(name){
+        return this.#lib.has(name);
+    }
 }
 
 module.exports = ActionsSetsLibrary;

package/src/logic/generic.js

@@ -11,7 +11,7 @@ module.exports = ({
     actionsSets = ["standart"],
     actions = {},
     beforeActions = {},
-    beforeActionsAll = [],
+    beforeActionsAll = [require('./actions.before/standart.queries.js')],
     afterActions = {},
     afterActionsAll = [],
 }) => {
@@ -19,8 +19,8 @@ module.exports = ({
     const ACTIONS = {};
     //add all from actions sets library
     actionsSets.forEach((setName) => {
-        actionsSetsLibrary[setName] &&
-            Object.assign(ACTIONS, actionsSetsLibrary[setName]);
+        actionsSetsLibrary.has(setName) &&
+            Object.assign(ACTIONS, actionsSetsLibrary.get(setName));
     });
     //add user defined
     Object.assign(ACTIONS, actions);
@@ -32,7 +32,9 @@ module.exports = ({
         USER_MODEL_NAME,
     });
 
-    beforeActionsAll.forEach((action) => Logic.onBefore(undefined, action));
+    beforeActionsAll.forEach((action) => {
+        Logic.onBefore(undefined, action);
+    });
     afterActionsAll.forEach((action) => Logic.onAfter(undefined, action));
 
     Object.keys(beforeActions).forEach((actionName) =>

package/src/logic/logic.js

@@ -11,48 +11,28 @@ const {
 } = require("../exceptions/logic.js");
 
 class LogicProxied {
-    #afterPipes;
-    #beforePipes;
+    afterPipes;
+    beforePipes;
 
-    #actions = new Map();
-    #actionRunner = ActionRunner;
+    actions = new Map();
+    actionRunner = ActionRunner;
 
-    #populateBuilders = {};
-    #defaultPopulate = [];
+    populateBuilders = {};
+    defaultPopulate = [];
 
-    #MODEL_NAME;
-    #MODULE_NAME;
-    #USER_MODEL_NAME = "";
+    MODEL_NAME;
+    MODULE_NAME;
+    USER_MODEL_NAME = "";
 
-    #log;
-    #say;
-    #phrase;
-    #config;
-    #logAction;
-    #logDebugAction;
-
-    get log() {
-        return this.#log;
-    }
-    get say() {
-        return this.#say;
-    }
-    get phrase() {
-        return this.#phrase;
-    }
-
-    get config() {
-        return this.#config;
-    }
-
-    get logAction() {
-        return this.#logAction;
-    }
-
-    get logDebugAction() {
-        return this.#logDebugAction;
-    }
+    #proxy;
+    log;
+    say;
+    phrase;
+    config;
+    logAction;
+    logDebugAction;
 
+    
     constructor(
         actions = {},
         actionRunner = ActionRunner,
@@ -65,34 +45,34 @@ class LogicProxied {
             USER_MODEL_NAME = "not-user//User",
         }
     ) {
-        this.#MODEL_NAME = MODEL_NAME;
-        this.#MODULE_NAME = MODULE_NAME;
-        this.#USER_MODEL_NAME = USER_MODEL_NAME;
+        this.MODEL_NAME = MODEL_NAME;
+        this.MODULE_NAME = MODULE_NAME;
+        this.USER_MODEL_NAME = USER_MODEL_NAME;
 
-        defaultPopulate && (this.#defaultPopulate = defaultPopulate);
-        populateBuilders && (this.#populateBuilders = populateBuilders);
+        defaultPopulate && (this.defaultPopulate = defaultPopulate);
+        populateBuilders && (this.populateBuilders = populateBuilders);
 
-        actionRunner && (this.#actionRunner = actionRunner);
-        this.#afterPipes = new NamedActionPipes(
+        actionRunner && (this.actionRunner = actionRunner);
+        this.afterPipes = new NamedActionPipes(
             NamedActionPipes.PIPE_TYPES.CONSECUTIVE,
-            this.#actionRunner
+            this.actionRunner
         );
-        this.#beforePipes = new NamedActionPipes(
+        this.beforePipes = new NamedActionPipes(
             NamedActionPipes.PIPE_TYPES.CONSECUTIVE,
-            this.#actionRunner
+            this.actionRunner
         );
 
         Object.keys(actions).forEach((actionName) => {
-            this.#actions.set(actionName, actions[actionName]);
+            this.actions.set(actionName, actions[actionName]);
         });
 
         this.#initTools(target);
 
         // proxy logic, do something before each call of all methods inside class
         // like if arg passed is 3, print something additionally
-        return new Proxy(this, {
+        return  this.#proxy = new Proxy(this, {
             get(target, prop) {
-                if (target.#actions.has(prop)) {
+                if (target.actions.has(prop)) {
                     return target.#getActionRunner(prop);
                 } else {
                     return target[prop];
@@ -102,31 +82,31 @@ class LogicProxied {
     }
 
     #initTools(target) {
-        this.#log = LogInit(
+        this.log = LogInit(
             target,
-            `${this.#MODULE_NAME}//Logic//${this.#MODEL_NAME}`
+            `${this.MODULE_NAME}//Logic//${this.MODEL_NAME}`
         );
-        this.#say = sayForModule(this.#MODULE_NAME);
-        this.#phrase = modulePhrase(this.#MODULE_NAME);
-        this.#config = configInit.readerForModule(this.#MODULE_NAME);
+        this.say = sayForModule(this.MODULE_NAME);
+        this.phrase = modulePhrase(this.MODULE_NAME);
+        this.config = configInit.readerForModule(this.MODULE_NAME);
 
-        this.#logAction = (actionName, identity, params = {}) => {
-            this.#log &&
-                this.#log.log({
+        this.logAction = (actionName, identity, params = {}) => {
+            this.log &&
+                this.log.log({
                     time: new Date(),
-                    module: this.#MODULE_NAME,
-                    logic: this.#MODEL_NAME,
+                    module: this.MODULE_NAME,
+                    logic: this.MODEL_NAME,
                     action: actionName,
                     ...identity,
                     params,
                 });
         };
-        this.#logDebugAction = (action, identity) => {
-            this.#log &&
-                this.#log.debug(
+        this.logDebugAction = (action, identity) => {
+            this.log &&
+                this.log.debug(
                     new Date(),
-                    `${this.#MODULE_NAME}//Logic//${
-                        this.#MODEL_NAME
+                    `${this.MODULE_NAME}//Logic//${
+                        this.MODEL_NAME
                     }//${action}`,
                     identity?.ip,
                     identity?.root
@@ -135,51 +115,51 @@ class LogicProxied {
     }
 
     getModel() {
-        return getApp().getModel(`${this.#MODULE_NAME}//${this.#MODEL_NAME}`);
+        return getApp().getModel(`${this.MODULE_NAME}//${this.MODEL_NAME}`);
     }
 
     getModelSchema() {
         return getApp().getModelSchema(
-            `${this.#MODULE_NAME}//${this.#MODEL_NAME}`
+            `${this.MODULE_NAME}//${this.MODEL_NAME}`
         );
     }
 
     getModelUser() {
-        return this.#USER_MODEL_NAME
-            ? getApp().getModel(this.#USER_MODEL_NAME)
+        return this.USER_MODEL_NAME
+            ? getApp().getModel(this.USER_MODEL_NAME)
             : undefined;
     }
 
     async getPopulate(actionName, prepared) {
         if (
-            this.#populateBuilders &&
-            objHas(this.#populateBuilders, actionName) &&
-            isFunc(this.#populateBuilders[actionName])
+            this.populateBuilders &&
+            objHas(this.populateBuilders, actionName) &&
+            isFunc(this.populateBuilders[actionName])
         ) {
             return await executeFunctionAsAsync(
-                this.#populateBuilders[actionName],
+                this.populateBuilders[actionName],
                 [prepared]
             );
         }
-        return this.#defaultPopulate;
+        return this.defaultPopulate;
     }
 
     #getActionRunner(actionName) {
         return async (...args) => {
             try {
-                const action = this.#actions.get(actionName);
-                await this.#beforeAction(actionName, [
-                    this,
+                const action = this.actions.get(actionName);
+                await this.beforeAction(actionName, [
+                    this.#proxy,
                     actionName,
                     ...args,
                 ]);
-                const actionResult = await this.#actionRunner.run(action, [
-                    this,
+                const actionResult = await this.actionRunner.run(action, [
+                    this.#proxy,
                     actionName,
                     ...args,
                 ]);
-                await this.#afterAction(actionName, [
-                    this,
+                await this.afterAction(actionName, [
+                    this.#proxy,
                     actionName,
                     actionResult,
                     ...args,
@@ -187,8 +167,8 @@ class LogicProxied {
                 return actionResult;
             } catch (e) {
                 throw new LogicExceptionActionExecutionError(
-                    this.#MODULE_NAME,
-                    this.#MODEL_NAME,
+                    this.MODULE_NAME,
+                    this.MODEL_NAME,
                     actionName,
                     e
                 );
@@ -196,28 +176,28 @@ class LogicProxied {
         };
     }
 
-    async #beforeAction(actionName, args) {
-        await this.#beforePipes.execute(actionName, args);
+    async beforeAction(actionName, args) {
+        await this.beforePipes.execute(actionName, args);
     }
 
-    async #afterAction(actionName, args) {
-        await this.#afterPipes.execute(actionName, args);
+    async afterAction(actionName, args) {
+        await this.afterPipes.execute(actionName, args);
     }
 
     onAfter(name, action) {
-        this.#afterPipes.add(name, action);
+        this.afterPipes.add(name, action);
     }
 
     offAfter(name, action) {
-        this.#afterPipes.remove(name, action);
+        this.afterPipes.remove(name, action);
     }
 
     onBefore(name, action) {
-        this.#beforePipes.add(name, action);
+        this.beforePipes.add(name, action);
     }
 
     offBefore(name, action) {
-        this.#beforePipes.remove(name, action);
+        this.beforePipes.remove(name, action);
     }
 }
 

package/src/logic/named.actions.pipes.js

@@ -16,36 +16,40 @@ class NamedActionPipes {
     #type = CONSECUTIVE;
     #all = [];
     #named = {};
-    #actionRunner = ActionRunner;
+    actionRunner = ActionRunner;
 
     constructor(type = CONSECUTIVE, actionRunner = ActionRunner) {
         this.#type = type;
-        actionRunner && (this.#actionRunner = actionRunner);
+        actionRunner && (this.actionRunner = actionRunner);
+    }
+
+    get type(){
+        return this.#type;
     }
 
     add(name, action) {
         if (typeof name === "undefined") {
-            this.#addToPipe(this.#all, action);
+            this.addToPipe(this.#all, action);
         } else {
-            this.#initNamedPipe(name);
-            this.#addToPipe(this.#named[name], action);
+            this.initNamedPipe(name);
+            this.addToPipe(this.#named[name], action);
         }
         return this;
     }
 
-    #addToPipe(pipe, action) {
+    addToPipe(pipe, action) {
         if (!pipe.includes(action)) {
             pipe.push(action);
         }
     }
 
-    #removeFromPipe(pipe, action) {
+    removeFromPipe(pipe, action) {
         if (pipe.includes(action)) {
             pipe.splice(pipe.indexOf(action), 1);
         }
     }
 
-    #initNamedPipe(name) {
+    initNamedPipe(name) {
         if (!objHas(this.#named, name) || !Array.isArray(this.#named[name])) {
             this.#named[name] = [];
         }
@@ -53,24 +57,24 @@ class NamedActionPipes {
 
     remove(name, action) {
         if (typeof name === "undefined") {
-            this.#removeFromPipe(this.#all, action);
+            this.removeFromPipe(this.#all, action);
         } else {
-            this.#initNamedPipe(name);
-            this.#removeFromPipe(this.#named[name], action);
+            this.initNamedPipe(name);
+            this.removeFromPipe(this.#named[name], action);
         }
         return this;
     }
 
-    #buildPipe(name) {
+    buildPipe(name) {
         const final = [...this.#all];
-        this.#initNamedPipe(name);
+        this.initNamedPipe(name);
         final.push(...this.#named[name]);
         return final;
     }
 
     async execute(name, params) {
         try {
-            const pipe = this.#buildPipe(name);
+            const pipe = this.buildPipe(name);
             return await this.#execute(pipe, params);
         } catch (e) {
             throw new ActionExceptionPipeExecutionError({ cause: e });
@@ -79,21 +83,21 @@ class NamedActionPipes {
 
     async #execute(pipe, params) {
         const ways = {
-            CONSECUTIVE: this.#executeConsecutive,
-            PARALLEL: this.#executeParallel,
+            [CONSECUTIVE]: this.executeConsecutive.bind(this),
+            [PARALLEL]: this.executeParallel.bind(this),
         };
-        return await ways[this.#type](pipe, params);
+        return await ways[this.type](pipe, params);
     }
 
-    async #executeConsecutive(pipe, params) {
+    async executeConsecutive(pipe, params) {
         for (let action of pipe) {
-            await this.#actionRunner.run(action, params);
+            await this.actionRunner.run(action, params);
         }
     }
 
-    async #executeParallel(pipe, params) {
+    async executeParallel(pipe, params) {
         const promisesOfPipe = pipe.map((action) =>
-            this.#actionRunner.run(action, params)
+            this.actionRunner.run(action, params)
         );
         await Promise.all(promisesOfPipe);
     }

package/src/model/default.js

@@ -357,11 +357,13 @@ async function removeOne(filter) {
         if (!updateResponseSuccess(res, 1)) {
             throw new DBExceptionDeleteWasNotSuccessful(res);
         }
+        return res;
     } else {
         const res = await this.deleteOne(filter);
         if (!deleteResponseSuccess(res, 1)) {
             throw new DBExceptionDeleteWasNotSuccessful(res);
         }
+        return res;
     }
 }
 
@@ -371,11 +373,13 @@ async function removeMany(filter) {
         if (!updateResponseSuccess(res, 0)) {
             throw new DBExceptionDeleteWasNotSuccessful(res);
         }
+        return res;
     } else {
         const res = await this.deleteMany(filter);
         if (!deleteResponseSuccess(res, 0)) {
             throw new DBExceptionDeleteWasNotSuccessful(res);
         }
+        return res;
     }
 }