not-node 6.5.21 → 6.5.24

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "not-node",
-	"version": "6.5.21",
+	"version": "6.5.24",
 	"description": "node complimentary part for client side notFramework.",
 	"main": "index.js",
 	"scripts": {
@@ -135,4 +135,4 @@
 			]
 		}
 	}
-}
+}

package/src/common.js

@@ -486,3 +486,13 @@ const findSignature = (obj, signatures, strict = true, typeStrict = true) => {
     });
 };
 module.exports.findSignature = findSignature;
+
+const isAction = (action) =>
+    action &&
+    (typeof action.run === "function" || typeof action === "function");
+
+module.exports.isAction = isAction;
+
+const isArrayOfActions = (list) => list.every(isAction);
+
+module.exports.isArrayOfActions = isArrayOfActions;

package/src/generic/logic.js

@@ -321,12 +321,12 @@ module.exports = ({
          * @param {import('../types').PreparedData}  prepared
          * @returns {Promise<Object>}               requested document
          **/
-        static async getOwnRaw({ targetId, identity }) {
+        static async getRawOwn({ targetId, identity }) {
             return await this._getOneRaw({
                 targetId,
                 identity,
                 shouldOwn: true,
-                action: "getOwnRaw",
+                action: "getRawOwn",
             });
         }
 

package/src/generic/route.js

@@ -76,14 +76,14 @@ module.exports = ({ getLogic, before, after }) => {
                 );
             }
             if (this.rootAsUser) {
-                return await getLogic(prepared).getOwnRaw(prepared);
+                return await getLogic(prepared).getRawOwn(prepared);
             } else {
                 return await getLogic(prepared).getRaw(prepared);
             }
         }
 
         static async getRaw(req, res, next, prepared) {
-            return await getLogic(prepared).getOwnRaw(prepared);
+            return await getLogic(prepared).getRawOwn(prepared);
         }
 
         static async _update(req, res, next, prepared) {

package/src/logic/actions/index.js

@@ -3,6 +3,9 @@ const ActionsSetsLibrary = require("../actions.lib");
 let actionsSetsLibrary = new ActionsSetsLibrary();
 
 actionsSetsLibrary.add("standart", require("./standart"));
+
+actionsSetsLibrary.add("standartOwn", require("./standart.own"));
+
 actionsSetsLibrary.add("increment", require("./increment"));
 
 module.exports = actionsSetsLibrary;

package/src/logic/actions/standart.own.js

@@ -0,0 +1,18 @@
+/**
+ * Duplicates standart set with names postpended with 'Own'
+ * Work with:
+ * beforeActionsOnCondition = [
+ *       require("./actions.before/ownage/ownage.js").ifActionNameEndsWith_Own(),
+ *   ],
+ * It modifies filtering queries before actions with names ended with 'Own'
+ */
+
+const standartSet = require("./standart");
+
+const standartOwnSet = {};
+Object.keys(standartSet).forEach((actionName) => {
+    standartOwnSet[`${actionName}Own`] = standartSet[actionName];
+});
+
+Object.freeze(standartOwnSet);
+module.exports = standartOwnSet;

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

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

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

@@ -1,57 +1,86 @@
-const notFilter = require("not-filter");
-const { DOCUMENT_OWNER_FIELD_NAME } = require("../../../auth/const.js");
+const {
+    DOCUMENT_OWNER_FIELD_NAME,
+    DOCUMENT_SESSION_FIELD_NAME,
+} = require("../../../auth/const.js");
 const {
     OwnageExceptionIdentityUserIdIsNotDefined,
 } = require("../../../exceptions/action.js");
-const ModelRoutine = require("../../../model/routine.js");
+
+const StandartQueriesBeforeAction = require("../standart.queries.js");
 
 //checks that
 module.exports = class OwnageBeforeAction {
     static #ownerFieldName = DOCUMENT_OWNER_FIELD_NAME;
+    static #sessionFieldName = DOCUMENT_SESSION_FIELD_NAME;
 
     static get ownerFieldName() {
         return this.#ownerFieldName;
     }
 
-    static async run(logic, actionName, args) {
-        const { identity, data, query, targetId, targetID } = args;
+    static get sessionFieldName() {
+        return this.#sessionFieldName;
+    }
+
+    static createOwnageFilterForUser(identity) {
+        return Object.freeze({
+            [OwnageBeforeAction.ownerFieldName]: identity.uid,
+        });
+    }
+
+    static createOwnageFilterForSession(identity) {
+        return Object.freeze({
+            [OwnageBeforeAction.sessionFieldName]: identity.sid,
+        });
+    }
+
+    /**
+     * Returns object with filtering conditions to restrict access by owner or session
+     *
+     * @static
+     * @param {import('../../../types.js').notAppIdentityData} identity
+     * @return {object}
+     */
+    static getOwnageFilterForIdentity(identity) {
         if (identity.uid) {
-            //if searching, counting, listing and so on
-            //adding condition of ownership by this excat user
-            let { filter, search } = query;
-            if (filter) {
-                filter = notFilter.filter.modifyRules(filter, {
-                    [OwnageBeforeAction.ownerFieldName]: identity?.uid,
-                });
-                if (search) {
-                    search = notFilter.filter.modifyRules(search, filter);
-                }
-            }
-            args.defaultQueryById = {
-                _id: targetId,
-                [OwnageBeforeAction.ownerFieldName]: identity?.uid,
-            };
-            const Model = logic.getModel();
-            const incFieldName = ModelRoutine.incremental(Model);
-            if (incFieldName) {
-                args.defaultQueryByID = {
-                    [incFieldName]: targetID,
-                    [OwnageBeforeAction.ownerFieldName]: identity?.uid,
-                };
-            }
-
-            args.defaultQueryMany = {
-                [OwnageBeforeAction.ownerFieldName]: identity?.uid,
-            };
-            //mark data as owned by
-            if (data) {
-                data[OwnageBeforeAction.ownerFieldName] = identity.uid;
-            }
+            return OwnageBeforeAction.createOwnageFilterForUser(identity);
+        } else if (identity.sid) {
+            return OwnageBeforeAction.createOwnageFilterForSession(identity);
         } else {
+            return null;
+        }
+    }
+
+    /**
+     *
+     *
+     * @static
+     * @param {import('../../logic.js')} logic
+     * @param {String} actionName
+     * @param {import('../../../types.js').PreparedData} args
+     */
+    static async run(logic, actionName, args) {
+        if (!args.identity) {
             throw new OwnageExceptionIdentityUserIdIsNotDefined(
                 actionName,
-                identity
+                undefined
             );
         }
+        const ownageFilter = OwnageBeforeAction.getOwnageFilterForIdentity(
+            args.identity
+        );
+        if (ownageFilter === null) {
+            throw new OwnageExceptionIdentityUserIdIsNotDefined(
+                actionName,
+                args.identity
+            );
+        }
+        StandartQueriesBeforeAction.modifyQueries(args, ownageFilter);
+    }
+
+    static ifActionNameEndsWith_Own() {
+        return Object.freeze({
+            condition: (actionName) => actionName.endsWith("Own"),
+            action: OwnageBeforeAction,
+        });
     }
 };

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

@@ -1,3 +1,12 @@
 module.exports = class PopulateBeforeAction {
-    static async run(/*logic, actionName, args*/) {}
+    static async run(logic, actionName, args) {
+        try {
+            const { identity } = args;
+            args.populate = await logic.getPopulate(actionName, {
+                identity,
+            });
+        } catch (e) {
+            logic.log.error(e);
+        }
+    }
 };

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

@@ -1,13 +1,49 @@
+const notFilter = require("not-filter");
 const ModelRoutine = require("../../model/routine.js");
 
 //adds to args object few basic queries
 module.exports = class StandartQueriesBeforeAction {
+    static modifyQueries(args, modificationFilter) {
+        const { query } = args;
+        let { filter, search } = query;
+        if (filter) {
+            filter = notFilter.filter.modifyRules(filter, modificationFilter);
+            if (search) {
+                search = notFilter.filter.modifyRules(search, filter);
+            }
+        }
+        if (args.defaultQueryById) {
+            args.defaultQueryById = notFilter.filter.modifyRules(
+                args.defaultQueryById,
+                modificationFilter
+            );
+        }
+        if (args.defaultQueryByID) {
+            args.defaultQueryByID = notFilter.filter.modifyRules(
+                args.defaultQueryByID,
+                modificationFilter
+            );
+        }
+
+        args.defaultQueryMany = notFilter.filter.modifyRules(
+            args.defaultQueryMany,
+            modificationFilter
+        );
+
+        //mark data as owned by
+        if (typeof args.data == "object" && args.data) {
+            Object.assign(args.data, modificationFilter);
+        }
+    }
+
     static async run(logic, actionName, args) {
         try {
             const { targetId, targetID } = args;
-            args.defaultQueryById = {
-                _id: targetId,
-            };
+            if (targetId) {
+                args.defaultQueryById = {
+                    _id: targetId,
+                };
+            }
             const Model = logic.getModel();
             const incFieldName = ModelRoutine.incremental(Model);
             if (

package/src/logic/generic.js

@@ -8,11 +8,18 @@ module.exports = ({
     MODEL_NAME,
     USER_MODEL_NAME = "not-user//User",
     actionRunner = undefined,
-    actionsSets = ["standart"],
+    actionsSets = ["standart", "standartOwn"],
     actions = {},
     beforeActions = {},
-    beforeActionsAll = [require("./actions.before/standart.queries.js")],
+    beforeActionsOnCondition = [
+        require("./actions.before/ownage/ownage.js").ifActionNameEndsWith_Own(),
+    ], //each item = {condition: (actionName)=>boolean, action}
+    beforeActionsAll = [
+        require("./actions.before/standart.queries.js"),
+        require("./actions.before/populate/populate.js"),
+    ],
     afterActions = {},
+    afterActionsOnCondition = [], //each item = {condition: (actionName)=>boolean, action}
     populateBuilders = {},
     afterActionsAll = [],
     defaultPopulate = [],
@@ -36,11 +43,28 @@ module.exports = ({
         defaultPopulate,
     });
 
+    //adds before/after to all
     beforeActionsAll.forEach((action) => {
         Logic.onBefore(undefined, action);
     });
+
     afterActionsAll.forEach((action) => Logic.onAfter(undefined, action));
 
+    //adds before/after to as many as satisfies condition
+    Object.keys(ACTIONS).forEach((actionName) => {
+        beforeActionsOnCondition.forEach(({ condition, action }) => {
+            if (condition(actionName)) {
+                Logic.onBefore(actionName, action);
+            }
+        });
+        afterActionsOnCondition.forEach(({ condition, action }) => {
+            if (condition(actionName)) {
+                Logic.onAfter(actionName, action);
+            }
+        });
+    });
+
+    //adds before/after per actionName
     Object.keys(beforeActions).forEach((actionName) =>
         beforeActions[actionName].forEach((action) =>
             Logic.onBefore(actionName, action)

package/src/logic/logic.js

@@ -17,8 +17,8 @@ class LogicProxied {
     actions = new Map();
     actionRunner = ActionRunner;
 
-    populateBuilders = {};
-    defaultPopulate = [];
+    #populateBuilders = {};
+    #defaultPopulate = [];
 
     MODEL_NAME;
     MODULE_NAME;
@@ -32,7 +32,6 @@ class LogicProxied {
     logAction;
     logDebugAction;
 
-    
     constructor(
         actions = {},
         actionRunner = ActionRunner,
@@ -48,9 +47,15 @@ class LogicProxied {
         this.MODEL_NAME = MODEL_NAME;
         this.MODULE_NAME = MODULE_NAME;
         this.USER_MODEL_NAME = USER_MODEL_NAME;
+        if (defaultPopulate) {
+            this.#defaultPopulate = defaultPopulate;
+        }
+        Object.freeze(this.#defaultPopulate);
 
-        defaultPopulate && (this.defaultPopulate = defaultPopulate);
-        populateBuilders && (this.populateBuilders = populateBuilders);
+        if (populateBuilders) {
+            this.#populateBuilders = populateBuilders;
+        }
+        Object.freeze(this.#populateBuilders);
 
         actionRunner && (this.actionRunner = actionRunner);
         this.afterPipes = new NamedActionPipes(
@@ -70,7 +75,7 @@ class LogicProxied {
 
         // proxy logic, do something before each call of all methods inside class
         // like if arg passed is 3, print something additionally
-        return  this.#proxy = new Proxy(this, {
+        return (this.#proxy = new Proxy(this, {
             get(target, prop) {
                 if (target.actions.has(prop)) {
                     return target.#getActionRunner(prop);
@@ -78,7 +83,7 @@ class LogicProxied {
                     return target[prop];
                 }
             },
-        });
+        }));
     }
 
     #initTools(target) {
@@ -105,9 +110,7 @@ class LogicProxied {
             this.log &&
                 this.log.debug(
                     new Date(),
-                    `${this.MODULE_NAME}//Logic//${
-                        this.MODEL_NAME
-                    }//${action}`,
+                    `${this.MODULE_NAME}//Logic//${this.MODEL_NAME}//${action}`,
                     identity?.ip,
                     identity?.root
                 );
@@ -132,16 +135,16 @@ class LogicProxied {
 
     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) {