not-node 6.3.50 → 6.3.52

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "not-node",
-	"version": "6.3.50",
+	"version": "6.3.52",
 	"description": "node complimentary part for client side notFramework.",
 	"main": "index.js",
 	"scripts": {
@@ -56,8 +56,6 @@
 		"jsonwebtoken": "^9.0.0",
 		"lower-case": "*",
 		"method-override": "^3.0.0",
-		"mock-require": "^3.0.3",
-		"mongoose": "*",
 		"mongoose-validator": "*",
 		"nconf": "*",
 		"not-config": "*",
@@ -91,7 +89,9 @@
 		"jsdoc": "^4.0.0",
 		"mocha": "*",
 		"mocha-suppress-logs": "^0.3.1",
-		"mongodb-memory-server": "^8.11.0",
+		"mock-require": "^3.0.3",
+		"mongodb-memory-server": "^9.1.6",
+		"mongoose": "^8.1.1",
 		"not-error": "^0.2.9",
 		"not-validation": "^0.0.9",
 		"npm-run-all": "^4.1.5",

package/src/common.js

@@ -381,23 +381,26 @@ module.exports.getValueFromEnv = getValueFromEnv;
  * @param {object} sign                 signature object {fieldName: someValueOfTargetType}
  * @param {boolean} [strict=true]       if  you need exact properties as in signature, when false - properties not described in signature are ok
  * @param {boolean} [typeStrict=true]   compares types of properties in obj and signature
+ * @param {boolean} [valueStrict=false] compares values of properties in obj and signature
  * @return {boolean}                    true if object structured as signature
  */
 const compareObjectSignatures = (
     obj,
     sign,
     strict = true,
-    typeStrict = true
+    typeStrict = true,
+    valueStrict = false
 ) => {
     const objKeys = Object.keys(obj);
     const signKeys = Object.keys(sign);
     const checkKey = (key) => {
         if (objKeys.includes(key)) {
-            if (typeStrict) {
-                return typeof obj[key] === typeof sign[key];
-            } else {
-                return true;
+            const isTypeStrict = typeof obj[key] === typeof sign[key];
+            const isValueStrict = obj[key] === sign[key];
+            if (typeStrict && !isTypeStrict) {
+                return false;
             }
+            return valueStrict ? isValueStrict : true;
         } else {
             return false;
         }

package/src/core/fields/createdAt.js

@@ -12,7 +12,7 @@ module.exports = {
         searchable: true,
         sortable: true,
         safe: {
-            update: ["@owner", "root", "admin"],
+            create: ["@system"],
             read: ["@owner", "root", "admin"],
         },
     },

package/src/exceptions/action.js

@@ -0,0 +1,100 @@
+const notRequestError = require("not-error/src/request.error.node.cjs");
+
+//delete wasnt successful, or error, or count of deleted documents dont match requested
+class ActionExceptionWrongType extends notRequestError {
+    constructor({ params = {}, cause = null } = {}) {
+        super("Logic cant run this action", { code: 505, params }, cause);
+    }
+}
+module.exports.ActionExceptionWrongType = ActionExceptionWrongType;
+
+class ActionExceptionPipeExecutionError extends notRequestError {
+    constructor({ params = {}, cause = null } = {}) {
+        super(
+            "Logic cant run this actions sequence",
+            { code: 505, params },
+            cause
+        );
+    }
+}
+module.exports.ActionExceptionPipeExecutionError =
+    ActionExceptionPipeExecutionError;
+
+class OwnageExceptionIdentityUserIdIsNotDefined extends notRequestError {
+    constructor(actionName, identity) {
+        super(
+            "User identity `uid` is not defined, ownage couldnt be determined",
+            { code: 505, params: { actionName, identity } },
+            null
+        );
+    }
+}
+module.exports.OwnageExceptionIdentityUserIdIsNotDefined =
+    OwnageExceptionIdentityUserIdIsNotDefined;
+
+class LogicDeleteActionException extends notRequestError {
+    constructor(params, cause) {
+        super("Logic Delete Action exception", { code: 505, params }, cause);
+    }
+}
+module.exports.LogicDeleteActionException = LogicDeleteActionException;
+
+class LogicCreateActionException extends notRequestError {
+    constructor(params, cause) {
+        super("Logic Create Action exception", { code: 505, params }, cause);
+    }
+}
+module.exports.LogicCreateActionException = LogicCreateActionException;
+class LogicUpdateActionException extends notRequestError {
+    constructor(params, cause) {
+        super("Logic Update Action exception", { code: 505, params }, cause);
+    }
+}
+module.exports.LogicUpdateActionException = LogicUpdateActionException;
+
+class LogicCountActionException extends notRequestError {
+    constructor(params, cause) {
+        super("Logic Count Action exception", { code: 505, params }, cause);
+    }
+}
+module.exports.LogicCountActionException = LogicCountActionException;
+
+class LogicListAndCountActionException extends notRequestError {
+    constructor(params, cause) {
+        super(
+            "Logic ListAndCount Action exception",
+            { code: 505, params },
+            cause
+        );
+    }
+}
+module.exports.LogicListAndCountActionException =
+    LogicListAndCountActionException;
+
+class LogicGetActionException extends notRequestError {
+    constructor(params, cause) {
+        super("Logic Get Action exception", { code: 505, params }, cause);
+    }
+}
+module.exports.LogicGetActionException = LogicGetActionException;
+
+class LogicGetRawActionException extends notRequestError {
+    constructor(params, cause) {
+        super("Logic GetRaw Action exception", { code: 505, params }, cause);
+    }
+}
+module.exports.LogicGetRawActionException = LogicGetRawActionException;
+
+class LogicListActionException extends notRequestError {
+    constructor(params, cause) {
+        super("Logic List Action exception", { code: 505, params }, cause);
+    }
+}
+module.exports.LogicListActionException = LogicListActionException;
+
+class LogicListAllActionException extends notRequestError {
+    constructor(params, cause) {
+        super("Logic ListAll Action exception", { code: 505, params }, cause);
+    }
+}
+module.exports.LogicListAllActionException = LogicListAllActionException;

package/src/exceptions/db.js

@@ -1,11 +1,12 @@
-const { notRequestError } = require("not-error");
+const { notError, notRequestError } = require("not-error/src/index.cjs");
 
 //delete wasnt successful, or error, or count of deleted documents dont match requested
-class DBExceptionDeleteWasNotSuccessful extends notRequestError {
-    constructor({ params = {}, cause = null } = {}) {
-        super("DB Delete Was Not Successful", { code: 505, ...params }, cause);
+class DBExceptionDeleteWasNotSuccessful extends notError {
+    constructor(result) {
+        super("DB Delete Was Not Successful", result);
     }
 }
+
 module.exports.DBExceptionDeleteWasNotSuccessful =
     DBExceptionDeleteWasNotSuccessful;
 

package/src/exceptions/logic.js

@@ -0,0 +1,14 @@
+const notRequestError = require("not-error/src/request.error.node.cjs");
+
+//delete wasnt successful, or error, or count of deleted documents dont match requested
+class LogicExceptionActionExecutionError extends notRequestError {
+    constructor(moduleName, modelName, actionName, cause) {
+        super(
+            "Logic cant run this action",
+            { code: 505, params: { moduleName, modelName, actionName } },
+            cause
+        );
+    }
+}
+module.exports.LogicExceptionActionExecutionError =
+    LogicExceptionActionExecutionError;

package/src/generic/logic.js

@@ -1,6 +1,6 @@
 const { objHas, isFunc, executeFunctionAsAsync } = require("../common");
 const ModelRoutine = require("../model/routine");
-const { deleteResponseSuccess } = require("../model/utils.js");
+
 const {
     DBExceptionDocumentIsNotFound,
     DBExceptionDeleteWasNotSuccessful,
@@ -360,7 +360,7 @@ module.exports = ({
                 let query = { _id: targetId };
                 checkShouldOwn(query, shouldOwn, identity);
                 const result = await model.findOneAndDelete(query).exec();
-                if (!deleteResponseSuccess(result)) {
+                if (!result) {
                     throw new DBExceptionDeleteWasNotSuccessful({
                         params: {
                             result,

package/src/logic/action.runner.js

@@ -0,0 +1,15 @@
+const { ActionExceptionWrongType } = require("../exceptions/action.js");
+
+class ActionRunner {
+    static async run(action, params) {
+        //any static class with static run method
+        if (typeof action === "function" && typeof action.run === "function") {
+            return await action.run(...params);
+        } else if (typeof action === "function") {
+            return await action(...params);
+        }
+        throw new ActionExceptionWrongType();
+    }
+}
+
+module.exports = ActionRunner;

package/src/logic/actions/increment/getByID.js

@@ -0,0 +1,23 @@
+module.exports = class GetByIDAction {
+    static async run(
+        logic,
+        actionName,
+        { targetID, identity, defaultQueryByID }
+    ) {
+        logic.logDebugAction(actionName, identity);
+
+        let populate = await logic.getPopulate(actionName, {
+            targetID,
+            identity,
+        });
+
+        const result = await logic
+            .getModel()
+            .getOneByID(targetID, defaultQueryByID, populate);
+        logic.logAction(actionName, identity, {
+            targetID,
+            version: result?.__version,
+        });
+        return result;
+    }
+};

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

@@ -0,0 +1 @@
+module.exports = { getByID: require("./getByID.js") };

package/src/logic/actions/index.js

@@ -0,0 +1,8 @@
+const ActionsSetsLibrary = require("../actions.lib");
+
+let actionsSetsLibrary = new ActionsSetsLibrary();
+
+actionsSetsLibrary.add("standart", require("./standart"));
+actionsSetsLibrary.add("increment", require("./increment"));
+
+module.exports = actionsSetsLibrary;

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

@@ -0,0 +1,24 @@
+const { LogicCountActionException } = require("../../../exceptions/action");
+
+module.exports = class CountAction {
+    static async run(logic, actionName, { identity, query }) {
+        try {
+            logic.logDebugAction(actionName, identity);
+            const { filter, search } = query;
+            const result = await logic
+                .getModel()
+                .countWithFilter(search || filter);
+            logic.logAction(actionName, identity);
+            return result;
+        } catch (e) {
+            throw new LogicCountActionException(
+                {
+                    query,
+                    activeUserId: identity?.uid,
+                    role: identity?.role,
+                },
+                e
+            );
+        }
+    }
+};

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

@@ -0,0 +1,21 @@
+const { LogicCreateActionException } = require("../../../exceptions/action");
+module.exports = class CreateAction {
+    static async run(logic, actionName, { identity, data }) {
+        try {
+            logic.logDebugAction(actionName, identity);
+            const result = await logic.getModel().add(data);
+            logic.logAction(actionName, identity, {
+                targetId: result?._id,
+            });
+            return result;
+        } catch (e) {
+            throw new LogicCreateActionException(
+                {
+                    activeUserId: identity?.uid,
+                    role: identity?.role,
+                },
+                e
+            );
+        }
+    }
+};

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

@@ -0,0 +1,28 @@
+const { LogicDeleteActionException } = require("../../../exceptions/action.js");
+module.exports = class DeleteAction {
+    static async run(
+        logic,
+        actionName,
+        { identity, defaultQueryById, targetId }
+    ) {
+        logic.logDebugAction(actionName, identity);
+        /** @type {import('../../../types.js').notAppModel } */
+        const model = logic.getModel();
+        try {
+            await model.removeOne(defaultQueryById);
+            logic.logAction(actionName, identity, {
+                query: defaultQueryById,
+            });
+        } catch (e) {
+            throw new LogicDeleteActionException(
+                {
+                    targetId,
+                    query: defaultQueryById,
+                    activeUserId: identity?.uid,
+                    role: identity?.role,
+                },
+                e
+            );
+        }
+    }
+};

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

@@ -0,0 +1,38 @@
+const { LogicGetActionException } = require("../../../exceptions/action");
+
+module.exports = class GetAction {
+    static async run(
+        logic,
+        actionName,
+        { identity, defaultQueryById, targetId }
+    ) {
+        try {
+            logic.logDebugAction(actionName, identity);
+
+            let populate = await logic.getPopulate(actionName, {
+                targetId,
+                identity,
+            });
+
+            const result = await logic
+                .getModel()
+                .getOne(targetId, populate, defaultQueryById);
+
+            logic.logAction(actionName, identity, {
+                targetId,
+                version: result?.__version,
+            });
+            return result;
+        } catch (e) {
+            throw new LogicGetActionException(
+                {
+                    targetId,
+                    query: defaultQueryById,
+                    activeUserId: identity?.uid,
+                    role: identity?.role,
+                },
+                e
+            );
+        }
+    }
+};

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

@@ -0,0 +1,31 @@
+const { LogicGetRawActionException } = require("../../../exceptions/action");
+
+module.exports = class GetRawAction {
+    static async run(
+        logic,
+        actionName,
+        { identity, defaultQueryById, targetId }
+    ) {
+        try {
+            logic.logDebugAction(actionName, identity);
+            const result = await logic
+                .getModel()
+                .getOneRaw(targetId, defaultQueryById);
+            logic.logAction(actionName, identity, {
+                targetId,
+                version: result?.__version,
+            });
+            return result;
+        } catch (e) {
+            throw new LogicGetRawActionException(
+                {
+                    targetId,
+                    query: defaultQueryById,
+                    activeUserId: identity?.uid,
+                    role: identity?.role,
+                },
+                e
+            );
+        }
+    }
+};

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

@@ -0,0 +1,11 @@
+module.exports = {
+    count: require("./count.js"),
+    create: require("./create.js"),
+    delete: require("./delete.js"),
+    get: require("./get.js"),
+    getRaw: require("./getRaw.js"),
+    list: require("./list.js"),
+    listAll: require("./listAll.js"),
+    listAndCount: require("./listAndCount.js"),
+    update: require("./update.js"),
+};

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

@@ -0,0 +1,27 @@
+const { LogicListActionException } = require("../../../exceptions/action");
+
+module.exports = class ListAction {
+    static async run(logic, actionName, { identity, query }) {
+        try {
+            logic.logDebugAction(actionName, identity);
+            const { skip, size, sorter, filter } = query;
+            let populate = await logic.getPopulate(actionName, {
+                identity,
+            });
+            const result = await logic
+                .getModel()
+                .listAndPopulate(skip, size, sorter, filter, populate);
+            logic.logAction(actionName, identity, {});
+            return result;
+        } catch (e) {
+            throw new LogicListActionException(
+                {
+                    query,
+                    activeUserId: identity?.uid,
+                    role: identity?.role,
+                },
+                e
+            );
+        }
+    }
+};

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

@@ -0,0 +1,21 @@
+const { LogicListAllActionException } = require("../../../exceptions/action");
+
+module.exports = class ListAllAction {
+    static async run(logic, actionName, { identity, defaultQueryMany }) {
+        try {
+            logic.logDebugAction(actionName, identity);
+            const result = await logic.getModel().listAll(defaultQueryMany);
+            logic.logAction(actionName, identity, {});
+            return result;
+        } catch (e) {
+            throw new LogicListAllActionException(
+                {
+                    query: defaultQueryMany,
+                    activeUserId: identity?.uid,
+                    role: identity?.role,
+                },
+                e
+            );
+        }
+    }
+};

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

@@ -0,0 +1,29 @@
+const {
+    LogicListAndCountActionException,
+} = require("../../../exceptions/action");
+
+module.exports = class ListAndCountAction {
+    static async run(logic, actionName, { identity, query }) {
+        try {
+            logic.logDebugAction(actionName, identity);
+            const { skip, size, sorter, filter, search } = query;
+            let populate = await logic.getPopulate(actionName, {
+                identity,
+            });
+            const result = await logic
+                .getModel()
+                .listAndCount(skip, size, sorter, filter, search, populate);
+            logic.logAction(actionName, identity, {});
+            return result;
+        } catch (e) {
+            throw new LogicListAndCountActionException(
+                {
+                    query,
+                    activeUserId: identity?.uid,
+                    role: identity?.role,
+                },
+                e
+            );
+        }
+    }
+};

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

@@ -0,0 +1,30 @@
+const { LogicUpdateActionException } = require("../../../exceptions/action");
+module.exports = class UpdateAction {
+    static async run(
+        logic,
+        actionName,
+        { identity, data, targetId, defaultQueryById }
+    ) {
+        try {
+            logic.logDebugAction(actionName, identity);
+            const result = await logic
+                .getModel()
+                .update(defaultQueryById, data);
+            logic.logAction(actionName, identity, {
+                targetId,
+                version: result?.__version,
+            });
+            return result;
+        } catch (e) {
+            throw new LogicUpdateActionException(
+                {
+                    targetId,
+                    query: defaultQueryById,
+                    activeUserId: identity?.uid,
+                    role: identity?.role,
+                },
+                e
+            );
+        }
+    }
+};

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

@@ -0,0 +1,7 @@
+const ActionsSetsLibrary = require("../actions.lib.js");
+
+const ActionsBefore = new ActionsSetsLibrary();
+
+ActionsBefore.add("ownage", require("./ownage"));
+
+module.exports = ActionsBefore;

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

@@ -0,0 +1,3 @@
+module.exports = {
+    ownage: require("./ownage.js"),
+};

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

@@ -0,0 +1,57 @@
+const notFilter = require("not-filter");
+const { DOCUMENT_OWNER_FIELD_NAME } = require("../../../auth/const.js");
+const {
+    OwnageExceptionIdentityUserIdIsNotDefined,
+} = require("../../../exceptions/action.js");
+const ModelRoutine = require("../../../model/routine.js");
+
+//checks that
+module.exports = class OwnageBeforeAction {
+    static #ownerFieldName = DOCUMENT_OWNER_FIELD_NAME;
+
+    static get ownerFieldName() {
+        return this.#ownerFieldName;
+    }
+
+    static async run(logic, actionName, args) {
+        const { identity, data, query, targetId, targetID } = args;
+        if (identity.uid) {
+            //if searching, counting, listing and so on
+            //adding condition of ownership by this excat user
+            const { filter, search } = query;
+            if (filter) {
+                notFilter.filter.modifyRules(filter, {
+                    [OwnageBeforeAction.ownerFieldName]: identity?.uid,
+                });
+                if (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;
+            }
+        } else {
+            throw new OwnageExceptionIdentityUserIdIsNotDefined(
+                actionName,
+                identity
+            );
+        }
+    }
+};

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

@@ -0,0 +1,3 @@
+module.exports = {
+    populate: require("./populate.js"),
+};

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

@@ -0,0 +1,3 @@
+module.exports = class PopulateBeforeAction {
+    static async run(/*logic, actionName, args*/) {}
+};

package/src/logic/actions.lib.js

@@ -0,0 +1,18 @@
+class ActionsSetsLibrary {
+    #lib = new Map();
+
+    add(name, set) {
+        if (!this.#lib.has(name)) {
+            this.#lib.set(name, set);
+        }
+    }
+
+    get(name) {
+        if (this.#lib.has(name)) {
+            return this.#lib.get(name);
+        }
+        return {};
+    }
+}
+
+module.exports = ActionsSetsLibrary;

package/src/logic/generic.action.after.js

@@ -0,0 +1,6 @@
+//reference only
+module.exports = class GenericAfterAction {
+    static async run(logic, actionName, actionResult, ...args) {
+        return [actionResult, ...args];
+    }
+};

package/src/logic/generic.action.before.js

@@ -0,0 +1,6 @@
+//reference only
+module.exports = class GenericBeforeAction {
+    static async run(logic, actionName, ...args) {
+        return [...args];
+    }
+};