not-node 5.1.26 → 5.1.29

package/package.json

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

package/src/exceptions/db.js

@@ -28,3 +28,15 @@ class DBExceptionDocumentIsNotFound extends notRequestError {
     }
 }
 module.exports.DBExceptionDocumentIsNotFound = DBExceptionDocumentIsNotFound;
+
+class DBExceptionUpdateOneWasNotSuccessful extends notRequestError {
+    constructor({ params = {}, cause = null } = {}) {
+        super(
+            "DB Update One Was Not Successful",
+            { code: 505, ...params },
+            cause
+        );
+    }
+}
+module.exports.DBExceptionUpdateOneWasNotSuccessful =
+    DBExceptionUpdateOneWasNotSuccessful;

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/logic.js

@@ -619,5 +619,124 @@ module.exports = ({
                 shouldOwn: true,
             });
         }
+
+        static async _list({
+            query,
+            activeUser,
+            ip,
+            action,
+            root,
+            shouldOwn = false,
+        }) {
+            Log.debug(
+                `${MODULE_NAME}//Logic//${MODEL_NAME}//${action}`,
+                ip,
+                root
+            );
+            const { skip, size, sorter, filter } = query;
+            let populate = getPopulate(action, {
+                activeUser,
+                ip,
+            });
+            if (shouldOwn) {
+                notFilter.filter.modifyRules(filter, {
+                    [ownerFieldName]: activeUser._id,
+                });
+            }
+            const result = await getModel().listAndPopulate(
+                skip,
+                size,
+                sorter,
+                filter,
+                populate
+            );
+            LogAction({
+                action,
+                by: activeUser._id,
+                role: activeUser.role,
+                ip,
+                root,
+                shouldOwn,
+            });
+            return result;
+        }
+
+        static async list({ query, activeUser, ip, root }) {
+            return await this._list({
+                query,
+                activeUser,
+                ip,
+                root,
+                action: "list",
+                shouldOwn: false,
+            });
+        }
+
+        static async listOwn({ query, activeUser, ip, root }) {
+            return await this._list({
+                query,
+                activeUser,
+                ip,
+                root,
+                action: "listOwn",
+                shouldOwn: true,
+            });
+        }
+
+        static async _count({
+            query,
+            activeUser,
+            ip,
+            action,
+            root,
+            shouldOwn = false,
+        }) {
+            Log.debug(
+                `${MODULE_NAME}//Logic//${MODEL_NAME}//${action}`,
+                ip,
+                root
+            );
+            const { filter, search } = query;
+            if (shouldOwn) {
+                notFilter.filter.modifyRules(filter, {
+                    [ownerFieldName]: activeUser._id,
+                });
+            }
+            if (search) {
+                notFilter.filter.modifyRules(search, filter);
+            }
+            const result = await getModel().countWithFilter(search || filter);
+            LogAction({
+                action,
+                by: activeUser._id,
+                role: activeUser.role,
+                ip,
+                root,
+                shouldOwn,
+            });
+            return result;
+        }
+
+        static async count({ query, activeUser, ip, root }) {
+            return await this._count({
+                query,
+                activeUser,
+                ip,
+                root,
+                action: "count",
+                shouldOwn: false,
+            });
+        }
+
+        static async countOwn({ query, activeUser, ip, root }) {
+            return await this._count({
+                query,
+                activeUser,
+                ip,
+                root,
+                action: "countOwn",
+                shouldOwn: true,
+            });
+        }
     };
 };

package/src/generic/route.js

@@ -62,6 +62,24 @@ module.exports = ({ getLogic, before, after }) => {
             return await getLogic().listAndCountOwn(prepared);
         }
 
+        static async _list(req, res, next, prepared) {
+            prepared.root = true;
+            return await getLogic().list(prepared);
+        }
+
+        static async list(req, res, next, prepared) {
+            return await getLogic().listOwn(prepared);
+        }
+
+        static async _count(req, res, next, prepared) {
+            prepared.root = true;
+            return await getLogic().count(prepared);
+        }
+
+        static async count(req, res, next, prepared) {
+            return await getLogic().countOwn(prepared);
+        }
+
         static async _delete(req, res, next, prepared) {
             prepared.root = true;
             return await getLogic().delete(prepared);

package/src/model/increment.js

@@ -59,9 +59,9 @@ module.exports.formId = formId;
  **/
 function secureUpdate(thisModel, which, cmd, opts) {
     if (typeof thisModel.updateOne === "function") {
-        return thisModel.updateOne(which, cmd, opts).exec();
+        return thisModel.updateOne(which, cmd, opts);
     } else {
-        return thisModel.update(which, cmd, opts).exec();
+        return thisModel.update(which, cmd, opts);
     }
 }
 

package/src/model/routine.js

@@ -1,7 +1,8 @@
 /** @module Model/Routine */
 
 const incrementNext = require("./increment");
-
+const { DBExceptionUpdateOneWasNotSuccessful } = require("../exceptions/db");
+const { updateResponseSuccess } = require("./utils");
 class ModelRoutine {
     static incremental(model) {
         return model.schema.statics.__incField;
@@ -44,6 +45,7 @@ class ModelRoutine {
     }
 
     static async update(model, filter, data) {
+        if ("_id" in data) delete data._id;
         if (ModelRoutine.versioning(model)) {
             return ModelRoutine.updateWithVersion(model, filter, data);
         } else {
@@ -63,13 +65,18 @@ class ModelRoutine {
     static async updateWithVersion(model, filter, data) {
         filter.__latest = true;
         filter.__closed = false;
-        const item = await model
-            .updateOne(filter, data, { returnOriginal: false })
-            .exec();
-        return model.saveVersion(item._id);
+        const result = await model.updateOne(filter, data, {
+            returnOriginal: false,
+        });
+        if (updateResponseSuccess(result, 1)) {
+            return model.saveVersion(filter._id);
+        } else {
+            throw new DBExceptionUpdateOneWasNotSuccessful();
+        }
     }
 
     static async updateMany(model, filter, data) {
+        if ("_id" in data) delete data._id;
         if (ModelRoutine.versioning(model)) {
             return ModelRoutine.updateManyWithVersion(model, filter, data);
         } else {
@@ -82,13 +89,11 @@ class ModelRoutine {
     }
 
     static async updateManyWithVersion(model, filter, data) {
-        const list = await model
-            .find({
-                __closed: false,
-                __latest: true,
-                ...filter,
-            })
-            .exec();
+        const list = await model.find({
+            __closed: false,
+            __latest: true,
+            ...filter,
+        });
         return await Promise.allSettled(
             list.map((item) => {
                 return ModelRoutine.updateWithVersion(

package/src/model/utils.js

@@ -7,7 +7,7 @@ function updateResponseSuccess(res, count = 1) {
         if (responseList.includes("ok")) {
             return res.ok === 1 && res.n === count;
         } else {
-            return res.matchedCount === count && res.modifiedCount === count;
+            return res.matchedCount === count && res.acknowledged;
         }
     } else {
         return false;