not-node 5.1.42 → 5.1.45

package/.eslintrc.json

@@ -1,42 +1,36 @@
 {
-  "parserOptions": {
-    "requireConfigFile": false,
-    "sourceType": "module",
-    "allowImportExportEverywhere": false,
-    "ecmaFeatures": {
-      "globalReturn": false
+    "parserOptions": {
+        "requireConfigFile": false,
+        "sourceType": "module",
+        "allowImportExportEverywhere": false,
+        "ecmaFeatures": {
+            "globalReturn": false
+        },
+        "ecmaVersion": "latest"
     },
-    "ecmaVersion": "latest"
-  },
-  "env": {
-    "es6": true,
-    "node": true,
-    "mongo": true,
-    "mocha": true
-  },
-  "extends": [
-    "eslint:recommended",
-    "plugin:node/recommended",
-		"plugin:sonarjs/recommended"
-  ],
-  "rules": {
-    "node/exports-style": ["error", "module.exports"],
-    "node/file-extension-in-import": ["error", "always"],
-    "node/prefer-global/buffer": ["error", "always"],
-    "node/prefer-global/console": ["error", "always"],
-    "node/prefer-global/process": ["error", "always"],
-    "node/prefer-global/url-search-params": ["error", "always"],
-    "node/prefer-global/url": ["error", "always"],
-    "node/no-unpublished-require": "warn",
-    "indent": ["error", 4],
-    "linebreak-style": [
-      "error",
-      "unix"
-    ],
-    "semi": [
-      "error",
-      "always"
+    "env": {
+        "es6": true,
+        "node": true,
+        "mongo": true,
+        "mocha": true
+    },
+    "extends": [
+        "eslint:recommended",
+        "plugin:node/recommended",
+        "plugin:sonarjs/recommended"
     ],
-    "no-useless-escape": [0]
-  }
+    "rules": {
+        "node/exports-style": ["error", "module.exports"],
+        "node/file-extension-in-import": ["error", "always"],
+        "node/prefer-global/buffer": ["error", "always"],
+        "node/prefer-global/console": ["error", "always"],
+        "node/prefer-global/process": ["error", "always"],
+        "node/prefer-global/url-search-params": ["error", "always"],
+        "node/prefer-global/url": ["error", "always"],
+        "node/no-unpublished-require": "warn",
+        "indent": ["error", 4, { "SwitchCase": 1 }],
+        "linebreak-style": ["error", "unix"],
+        "semi": ["error", "always"],
+        "no-useless-escape": [0]
+    }
 }

package/index.js

@@ -11,6 +11,8 @@ module.exports.Error = require("./src/error.js");
 module.exports.Auth = require("./src/auth");
 /** Manifest infrastructure */
 module.exports.Manifest = require("./src/manifest/manifest");
+/** Request result properties filtering */
+module.exports.notManifestRouteResultFilter = require("./src/manifest/result.filter");
 /** Web Application */
 module.exports.notApp = require("./src/app");
 /** General Application */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "not-node",
-  "version": "5.1.42",
+  "version": "5.1.45",
   "description": "node complimentary part for client side notFramework.",
   "main": "index.js",
   "scripts": {
@@ -46,7 +46,7 @@
     "express-fileupload": "^1.4.0",
     "express-session": "^1.17.3",
     "fs-extra": "*",
-    "helmet": "^5.1.0",
+    "helmet": "^6.0.0",
     "lower-case": "*",
     "method-override": "^3.0.0",
     "mock-require": "^3.0.3",
@@ -60,10 +60,10 @@
     "not-locale": "*",
     "not-log": "^0.0.20",
     "not-monitor": "^0.0.13",
-    "not-path": "*",
+    "not-path": "^1.0.4",
     "not-validation": "^0.0.8",
-    "rate-limiter-flexible": "^2.3.7",
-    "redis": "^4.1.1",
+    "rate-limiter-flexible": "^2.3.9",
+    "redis": "^4.3.1",
     "redlock": "^5.0.0-beta.2",
     "rfdc": "^1.3.0",
     "rmdir": "^1.2.0",
@@ -76,15 +76,15 @@
     "babel-eslint": "^10.1.0",
     "chai": "*",
     "chai-as-promised": "*",
-    "eslint": "^8.18.0",
+    "eslint": "^8.23.0",
     "eslint-plugin-node": "^11.1.0",
-    "eslint-plugin-sonarjs": "^0.13.0",
+    "eslint-plugin-sonarjs": "^0.15.0",
     "ink-docstrap": "^1.3.2",
-    "ioredis": "^5.1.0",
-    "jsdoc": "^3.6.10",
+    "ioredis": "^5.2.3",
+    "jsdoc": "^3.6.11",
     "mocha": "*",
     "mocha-suppress-logs": "^0.3.1",
-    "mongodb-memory-server": "^8.7.2",
+    "mongodb-memory-server": "^8.9.1",
     "npm-run-all": "^4.1.5",
     "nyc": "^15.1.0",
     "retire": "^3.0.7"
@@ -126,4 +126,4 @@
       ]
     }
   }
-}
+}

package/src/init/lib/app.js

@@ -35,7 +35,7 @@ module.exports = class InitApp {
 
     static async initCore({ config, options, master, emit }) {
         await emit("app.initCore.pre", { config, options, master });
-        master.getApp().importModuleFrom(path.join(__dirname, "../core"));
+        master.getApp().importModuleFrom(path.join(__dirname, "../../core"));
         await emit("app.initCore.post", { config, options, master });
     }
 

package/src/manifest/result.filter.js

@@ -0,0 +1,268 @@
+const notPath = require("not-path");
+const { objHas, copyObj } = require("../common");
+
+const PROP_NAME_RETURN_ROOT = "returnRoot"; //path to object to filter
+const PROP_NAME_RETURN_RULE = "return"; //filtering rule
+const PROP_NAME_RETURN_STRICT = "returnStrict"; //if filtering should be strict
+
+/**
+ * @const {boolean} DEFAULT_STRICT_MODE
+ * active only in complex rules presented as objects
+ * defines if filtering should exclude any not mentioned property and sub property in map object
+ * Example:
+ * target structure =
+ *  {
+ *      id,
+ *      user:{
+ *          id,
+ *          username,
+ *          aliases: [
+ *              {id, title, createdAt},
+ *              {id, title, createdAt, banned}
+ *          ],
+ *          createdAt
+ *      },
+ *      clean
+ *  }
+ * rule object =
+ *  {
+ *      id,
+ *      'user.aliases': ['id', 'title', 'banned']
+ *  }
+ * in strict==true
+ * filtered target structure =
+ *  {
+ *      id,
+ *      user:{
+ *          aliases: [
+ *              {id, title},
+ *              {id, title, banned}
+ *          ]
+ *      }
+ *  }
+ * in strict==false
+ * filtered target structure = {
+ *      id,
+ *      user:{
+ *          id,
+ *          username,
+ *          aliases: [
+ *              {id, title},
+ *              {id, title, banned}
+ *          ],
+ *          createdAt
+ *      }
+ *  }
+ */
+const DEFAULT_STRICT_MODE = false;
+
+module.exports = class notManifestRouteResultFilter {
+    /**
+     * Removes fields from result object acctoding to actionData.return array
+     * if presented
+     * @param {object} notRouteData request rules and preferencies
+     * @param {object} result result returned by main action processor
+     */
+    static filter(notRouteData, result) {
+        if (!(result && typeof result === "object")) return;
+        const filteringRule = this.getFilteringRule(notRouteData);
+        if (!filteringRule) return;
+        const filteringTarget = this.getFilteringTarget(result, notRouteData);
+        if (!filteringTarget) {
+            return;
+        }
+        this.filterByRule(
+            filteringTarget,
+            filteringRule,
+            this.getFilteringStrictMode(notRouteData)
+        );
+        return result;
+    }
+
+    /**
+     * modifies target according to rule
+     * @param {object}  target      object which properties should be filtered
+     * @param {array}   rule        filtering rule
+     * @param {boolean} strict      filtering mode
+     */
+
+    static filterByRule(target, rule, strict = DEFAULT_STRICT_MODE) {
+        if (!rule || !target) {
+            return;
+        }
+        if (Array.isArray(rule)) {
+            this.filterByArrayRule(target, rule); //flat map always strict==true
+        } else if (typeof rule === "object") {
+            this.filterByMapRule(target, rule, strict); //object map strict could vary
+        }
+    }
+
+    /**
+     * filters target by rule.
+     * Rule form: {pathToProperty: filteringRuleArray, pathToProperty: filteringRuleMap }
+     * pathToProperty should be in notPath notation except starting symbol (default: ':')
+     * if pathToProperty targets array in target, each item of array will be filtered by
+     * @param {object} target
+     * @param {object} rule         map of properties.
+     * @param {boolean} strict      filtering mode
+     * example:
+     * {
+     *      'user': ['username', 'id', 'email'], //filtering properties of object target.user
+     *      'posts': ['id', 'title'],            //filtering properties of array of objects target.posts
+     *      'friends.list': ['id', 'username']   //filtering props of array of objects target.friends.list by path.
+     *                                           //if strict==false: will not drop any from friends.*, only friends.list cotent will be processed
+     *                                           //if strict==true: will drop all properties of friends except list
+     *      'friends': {                         //this will clear friends sub-object from any properties except 'list' in any strict mode
+     *          'list': ['id', 'username']       //and filter 'list' items
+     *      },
+     *      'storage': {                         //filtering complex sub object by map
+     *          'files':{
+     *              'cloud': ['id','title'],
+     *              'local': ['id', 'title', 'size']
+     *          }
+     *      }
+     * }
+     */
+    static filterByMapRule(target, rule, strict = DEFAULT_STRICT_MODE) {
+        //to form ['id', 'user.username', 'files']
+        const filteringArray = Object.keys(rule);
+        //filtering direct chilren if in strict mode
+        if (strict) {
+            this.filterStrict(target, filteringArray);
+        }
+        //filter properties
+        for (let filteringTargetName of filteringArray) {
+            const subTarget = notPath.get(
+                `${notPath.PATH_START_OBJECT}${filteringTargetName}`,
+                target
+            );
+            //if sub target Array filtering each item individualy
+            if (Array.isArray(subTarget)) {
+                subTarget.forEach((subTargetItem) => {
+                    this.filterByRule(
+                        subTargetItem,
+                        rule[filteringTargetName],
+                        strict
+                    );
+                });
+            } else if (typeof subTarget == "object") {
+                this.filterByRule(subTarget, rule[filteringTargetName], strict);
+            }
+        }
+    }
+
+    static filterStrict(target, filteringArray) {
+        console.log(target, filteringArray);
+        //to form ['id', 'user', 'files']
+        const filteringArrayDirectChildren = filteringArray.map(
+            (propName) => propName.split(notPath.PATH_SPLIT)[0]
+        );
+        //filter strict direct children
+        this.filterByArrayRule(target, filteringArrayDirectChildren);
+        //filter strict each level in props paths in filteringArray
+        for (let path of filteringArray) {
+            let pathParts = path.split(notPath.PATH_SPLIT);
+            if (pathParts.length === 1) {
+                continue;
+            }
+            //property name in which we will clean content except pathParts[1]
+            const directPropName = pathParts.shift();
+            //
+            const subTarget = target[directPropName];
+            if (Array.isArray(subTarget)) continue;
+            const subFilteringArray = [pathParts.join(notPath.PATH_SPLIT)];
+            this.filterStrict(subTarget, subFilteringArray);
+        }
+    }
+
+    /**
+     * filters target properties by rule, all properties which names are not presented in rule
+     * array will be removed from target
+     * @param {object} target object to filter
+     * @param {Array} rule list of enabled properties. example: ['id', 'title', 'createdAt']
+     */
+    static filterByArrayRule(target, rule) {
+        const presented = Object.keys(target);
+        presented.forEach((fieldName) => {
+            if (!rule.includes(fieldName)) {
+                delete target[fieldName];
+            }
+        });
+    }
+
+    /**
+     * returns filtering rule object or undefined
+     * @param {object} notRouteData
+     * @returns {object|Array|undefined}  rule to filter result object properties
+     */
+    static getFilteringRule(notRouteData) {
+        if (objHas(notRouteData.rule, PROP_NAME_RETURN_RULE)) {
+            return copyObj(notRouteData.rule[PROP_NAME_RETURN_RULE]);
+        } else if (objHas(notRouteData.actionData, PROP_NAME_RETURN_RULE)) {
+            return copyObj(notRouteData.actionData[PROP_NAME_RETURN_RULE]);
+        } else {
+            return undefined;
+        }
+    }
+
+    /**
+     * Returns path to sub object which properties should be filtered
+     * @param {object} notRouteData
+     * @returns {string}  path of sub object in notPath notation
+     */
+    static getFilteringTargetPath(notRouteData) {
+        let path = notPath.PATH_START_OBJECT;
+        if (notRouteData) {
+            if (objHas(notRouteData.rule, PROP_NAME_RETURN_ROOT)) {
+                path += notRouteData.rule[PROP_NAME_RETURN_ROOT];
+            } else if (objHas(notRouteData.actionData, PROP_NAME_RETURN_ROOT)) {
+                path += notRouteData.actionData[PROP_NAME_RETURN_ROOT];
+            }
+        }
+        return path;
+    }
+
+    /**
+     * Returns object which properties should be filtered
+     * @param {object}  result  request result
+     * @param {object}  notRouteData  request route rules and prefs
+     * @returns {object} object to filter
+     */
+    static getFilteringTarget(result, notRouteData) {
+        if (result && typeof result == "object") {
+            const returnListRoot = this.getFilteringTargetPath(notRouteData);
+            return notPath.get(returnListRoot, result);
+        } else {
+            return result;
+        }
+    }
+
+    static getFilteringStrictMode(notRouteData) {
+        if (notRouteData) {
+            if (objHas(notRouteData.rule, PROP_NAME_RETURN_STRICT)) {
+                return !!notRouteData.rule[PROP_NAME_RETURN_STRICT];
+            } else if (
+                objHas(notRouteData.actionData, PROP_NAME_RETURN_STRICT)
+            ) {
+                return !!notRouteData.actionData[PROP_NAME_RETURN_STRICT];
+            }
+        }
+        return this.DEFAULT_STRICT_MODE;
+    }
+
+    static get PROP_NAME_RETURN_ROOT() {
+        return PROP_NAME_RETURN_ROOT;
+    }
+
+    static get PROP_NAME_RETURN_RULE() {
+        return PROP_NAME_RETURN_RULE;
+    }
+
+    static get PROP_NAME_RETURN_STRICT() {
+        return PROP_NAME_RETURN_STRICT;
+    }
+
+    static get DEFAULT_STRICT_MODE() {
+        return DEFAULT_STRICT_MODE;
+    }
+};

package/src/manifest/route.js

@@ -2,10 +2,12 @@ const CONST_BEFORE_ACTION = "before";
 const CONST_AFTER_ACTION = "after";
 
 const obsoleteWarning = require("../obsolete");
+
 const Auth = require("../auth"),
     HttpError = require("../error").Http;
 
-const { objHas, copyObj, executeObjectFunction } = require("../common");
+const notManifestRouteResultFilter = require("./result.filter");
+const { copyObj, executeObjectFunction } = require("../common");
 
 /**
  *	Route representation
@@ -171,39 +173,6 @@ class notRoute {
         );
     }
 
-    extractReturn(notRouteData) {
-        if (objHas(notRouteData.rule, "return")) {
-            return [...notRouteData.rule.return];
-        } else if (objHas(notRouteData.actionData, "return")) {
-            return [...notRouteData.actionData.return];
-        } else {
-            return undefined;
-        }
-    }
-
-    /**
-     * Removes fields from result object acctoding to actionData.return array
-     * if presented
-     * @param {ExpressRequest} req request object
-     * @param {object} result result returned by main action processor
-     */
-    filterResultByReturnRule(req, result) {
-        const returnList = this.extractReturn(req.notRouteData);
-        if (
-            result &&
-            typeof result === "object" &&
-            returnList &&
-            Array.isArray(returnList)
-        ) {
-            let presented = Object.keys(result);
-            presented.forEach((fieldName) => {
-                if (!returnList.includes(fieldName)) {
-                    delete result[fieldName];
-                }
-            });
-        }
-    }
-
     async executeRoute(modRoute, actionName, { req, res, next }) {
         try {
             //waiting preparation
@@ -220,7 +189,7 @@ class notRoute {
                 prepared,
             ]);
             //filter result IF actionData.return specified
-            this.filterResultByReturnRule(req, result);
+            notManifestRouteResultFilter.filter(req.notRouteData, result);
             //run after with results, continue without waiting when it finished
             return this.executeFunction(modRoute, CONST_AFTER_ACTION, [
                 req,

package/src/model/routine.js

@@ -112,7 +112,6 @@ class ModelRoutine {
                 );
                 if (updateResult) {
                     result = await ModelConstructor.saveVersion(
-                        ModelConstructor,
                         updateResult._id
                     );
                 } else {