not-node 5.1.30 → 5.1.33

package/package.json

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

package/src/form/form.js

@@ -243,6 +243,41 @@ class Form {
         }
         return results;
     }
+
+    createInstructionFromRouteActionFields(
+        req,
+        mainInstruction = "fromBody",
+        exceptions = {}
+    ) {
+        const result = {};
+        if (
+            req?.notRouteData?.actionData?.fields &&
+            Array.isArray(req.notRouteData.actionData.fields)
+        ) {
+            const fields = req.notRouteData.actionData.fields.flat(2);
+            fields.forEach((fieldName) => {
+                if (objHas(exceptions, fieldName)) {
+                    result[fieldName] = exceptions[fieldName];
+                } else {
+                    result[fieldName] = mainInstruction;
+                }
+            });
+        }
+        return result;
+    }
+
+    extractByInstructionsFromRouteActionFields(
+        req,
+        mainInstruction = "fromBody",
+        exceptions = {}
+    ) {
+        const instructions = this.createInstructionFromRouteActionFields(
+            req,
+            mainInstruction,
+            exceptions
+        );
+        return this.extractByInstructions(req, instructions);
+    }
 }
 
 module.exports = Form;

package/src/generic/form.getByID.js

@@ -0,0 +1,31 @@
+//DB related validation tools
+const Form = require("../form/form");
+const { firstLetterToUpper, firstLetterToLower } = require("../common");
+//not-node
+const { getIP } = require("../auth");
+//form
+const FIELDS = [
+    ["targetID", { required: true }, "not-node//ID"],
+    ["activeUserId", { required: true }, "not-node//objectId"],
+    ["activeUser", "not-node//requiredObject"],
+    ["ip", "not-node//ip"],
+];
+
+module.exports = ({ MODULE_NAME, MODEL_NAME, actionName }) => {
+    const FORM_NAME = `${MODULE_NAME}:${firstLetterToUpper(actionName)}Form`;
+    return class extends Form {
+        constructor({ app }) {
+            super({ FIELDS, FORM_NAME, app });
+        }
+
+        extract(req) {
+            const incField = `${firstLetterToLower(MODEL_NAME)}ID`;
+            return {
+                targetId: req.params[incField],
+                activeUser: req.user,
+                activeUserId: req.user._id,
+                ip: getIP(req),
+            };
+        }
+    };
+};

package/src/generic/index.js

@@ -1,6 +1,7 @@
 module.exports.GenericLogic = require("./logic.js");
 module.exports.GenericRoute = require("./route.js");
 module.exports.GenericGetByIdForm = require("./form.getById.js");
+module.exports.GenericGetByIDForm = require("./form.getByID.js");
 module.exports.GenericListAndCountForm = require("./form.listAndCount.js");
 
 const FORMS = {};

package/src/generic/logic.js

@@ -307,6 +307,100 @@ module.exports = ({
             });
         }
 
+        /**
+         * get item with populated sub-documents
+         * @param {Object}  prepared
+         * @param {Object}  prepared.targetID       target item ID
+         * @param {Object}  prepared.activeUser     current user info
+         * @param {string}  prepared.ip             current user ip
+         * @param {boolean}  prepared.root          current user is root
+         * @param {boolean}  prepared.shouldOwn     if user should be owner of target
+         * @returns {Promise<Object>}               requested document
+         **/
+        static async _getOneByID({
+            targetID,
+            action,
+            ip,
+            root,
+            activeUser,
+            shouldOwn = true,
+        }) {
+            Log.debug(
+                `${MODULE_NAME}//Logic//${MODEL_NAME}//${action}`,
+                targetID,
+                ip,
+                root
+            );
+            let query = {};
+            if (shouldOwn) {
+                query[ownerFieldName] = activeUser._id;
+            }
+            let populate = getPopulate(action, {
+                targetID,
+                activeUser,
+                ip,
+                root,
+            });
+            const result = await getModel().getOneByID(
+                targetID,
+                query,
+                populate
+            );
+            LogAction(
+                {
+                    action,
+                    by: activeUser._id,
+                    role: activeUser.role,
+                    ip,
+                },
+                {
+                    targetID,
+                    version: result.__version,
+                }
+            );
+            return result;
+        }
+
+        /**
+         * get item with populated sub-documents
+         * @param {Object}  prepared
+         * @param {Object}  prepared.targetID       target item ID
+         * @param {Object}  prepared.activeUser     current user info
+         * @param {string}  prepared.ip             current user ip
+         * @param {boolean}  prepared.root          current user is root
+         * @returns {Promise<Object>}               requested document
+         **/
+        static async getByID({ targetID, activeUser, ip, root = false }) {
+            return await this._getOneByID({
+                targetID,
+                action: "getByID",
+                activeUser,
+                ip,
+                root,
+                shouldOwn: false,
+            });
+        }
+
+        /**
+         * get activeUser own item with populated sub-documents
+         * @param {Object}  prepared
+         * @param {Object}  prepared.targetID       target item ID
+         * @param {Object}  prepared.activeUser     current user info
+         * @param {string}  prepared.ip             current user ip
+         * @param {boolean}  prepared.root          current user is root
+         * @returns {Promise<Object>}               requested document
+         **/
+        static async getByIDOwn({ targetID, activeUser, ip, root = false }) {
+            return await this._getOneByID({
+                targetID,
+                action: "getByIDOwn",
+                activeUser,
+                ip,
+                root,
+                shouldOwn: true,
+            });
+        }
+
         /**
          * get item without populated sub-documents
          * @param {Object}  prepared

package/src/generic/route.js

@@ -26,6 +26,15 @@ module.exports = ({ getLogic, before, after }) => {
             return await getLogic().getOwn(prepared);
         }
 
+        static async _getByID(req, res, next, prepared) {
+            prepared.root = true;
+            return await getLogic().getByID(prepared);
+        }
+
+        static async getByID(req, res, next, prepared) {
+            return await getLogic().getByIDOwn(prepared);
+        }
+
         static async _getRaw(req, res, next, prepared) {
             prepared.root = true;
             return await getLogic().getRaw(prepared);

package/src/model/default.js

@@ -111,9 +111,10 @@ function getOne(id, population = [], condition = {}) {
  *	@static
  *	@param 	{number}	ID		some unique numeric identificator
  *	@param 	{Object}	condition 	optional if needed additional condition
+ *	@param 	{Array}		population 	optional if needed population of some fields
  *	@return {Promise}	      Promise of document, if increment is OFF - then Promise.resolve(null)
  **/
-function getOneByID(ID, condition = {}) {
+function getOneByID(ID, condition = {}, population = []) {
     if (this.schema.statics.__incField) {
         let by, query;
         if (this.schema.statics.__versioning) {
@@ -129,6 +130,7 @@ function getOneByID(ID, condition = {}) {
         }
         by[this.schema.statics.__incField] = ID;
         query = this.findOne(by);
+        populateQuery(query, population, this.schema.statics.__versioning);
         return query.exec();
     } else {
         return Promise.resolve(null);