not-node 5.1.28 → 5.1.31

package/package.json

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

package/src/fields/index.js

@@ -7,6 +7,7 @@ const { objHas } = require("../common");
 const DEFAULT_TYPE = "ui";
 const DEFAULT_FROM = ":FIELDS";
 const DEFAULT_TO = ":thisSchema";
+const DEFAULT_SPLITER = "//";
 
 module.exports.initFileSchemaFromFields = ({
     app,
@@ -79,6 +80,7 @@ module.exports.initSchemaField = (
  * ['destFieldName', {full: true, field: 'content'}] - form 2
  * ['destFieldName', 'srcFieldName'] //field alias, form 3
  * ['destFieldName', {mutation: 'content'}, 'srcFieldName']// - form 4
+ * 'module-name//field-name' - form 5, equal to ['field-name', 'module-name//field-name']
  **/
 const parseFieldDescription = (field) => {
     let srcName,
@@ -98,7 +100,13 @@ const parseFieldDescription = (field) => {
             srcName = field[2];
         }
     } else {
-        destName = srcName = field; //form 1
+        if (field.includes(DEFAULT_SPLITER)) {
+            //form 5
+            destName = field.split(DEFAULT_SPLITER)[0];
+            srcName = field;
+        } else {
+            destName = srcName = field; //form 1
+        }
     }
     return {
         srcName,

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

@@ -2,3 +2,30 @@ module.exports.GenericLogic = require("./logic.js");
 module.exports.GenericRoute = require("./route.js");
 module.exports.GenericGetByIdForm = require("./form.getById.js");
 module.exports.GenericListAndCountForm = require("./form.listAndCount.js");
+
+const FORMS = {};
+module.exports.setCustomGenericForm = (name, factory) => {
+    FORMS[name] = factory;
+};
+
+module.exports.getCustomGenericForm = (name) => {
+    return FORMS[name];
+};
+
+const LOGICS = {};
+module.exports.setCustomGenericLogic = (name, factory) => {
+    LOGICS[name] = factory;
+};
+
+module.exports.getCustomGenericLogic = (name) => {
+    return LOGICS[name];
+};
+
+const ROUTES = {};
+module.exports.setCustomGenericRoute = (name, factory) => {
+    ROUTES[name] = factory;
+};
+
+module.exports.getCustomGenericRoute = (name) => {
+    return ROUTES[name];
+};

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);