not-node 6.3.51 → 6.3.52

package/package.json

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

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/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];
+    }
+};

package/src/logic/generic.js

@@ -0,0 +1,51 @@
+const actionsSetsLibrary = require("./actions/index.js");
+const LogicProxied = require("./logic.js");
+
+module.exports = ({
+    target,
+    LogicConstructor = LogicProxied,
+    MODULE_NAME,
+    MODEL_NAME,
+    USER_MODEL_NAME = "not-user//User",
+    actionRunner = undefined,
+    actionsSets = ["standart"],
+    actions = {},
+    beforeActions = {},
+    beforeActionsAll = [],
+    afterActions = {},
+    afterActionsAll = [],
+}) => {
+    //start with empty set
+    const ACTIONS = {};
+    //add all from actions sets library
+    actionsSets.forEach((setName) => {
+        actionsSetsLibrary[setName] &&
+            Object.assign(ACTIONS, actionsSetsLibrary[setName]);
+    });
+    //add user defined
+    Object.assign(ACTIONS, actions);
+
+    const Logic = new LogicConstructor(ACTIONS, actionRunner, {
+        MODULE_NAME,
+        MODEL_NAME,
+        target,
+        USER_MODEL_NAME,
+    });
+
+    beforeActionsAll.forEach((action) => Logic.onBefore(undefined, action));
+    afterActionsAll.forEach((action) => Logic.onAfter(undefined, action));
+
+    Object.keys(beforeActions).forEach((actionName) =>
+        beforeActions[actionName].forEach((action) =>
+            Logic.onBefore(actionName, action)
+        )
+    );
+
+    Object.keys(afterActions).forEach((actionName) =>
+        afterActions[actionName].forEach((action) =>
+            Logic.onAfter(actionName, action)
+        )
+    );
+
+    return Logic;
+};

package/src/logic/logic.js

@@ -0,0 +1,224 @@
+const getApp = require("../getApp.js"),
+    configInit = require("not-config"),
+    { sayForModule, modulePhrase } = require("not-locale"),
+    LogInit = require("not-log"),
+    { objHas, isFunc, executeFunctionAsAsync } = require("../common.js");
+
+const NamedActionPipes = require("./named.actions.pipes.js");
+const ActionRunner = require("./action.runner.js");
+const {
+    LogicExceptionActionExecutionError,
+} = require("../exceptions/logic.js");
+
+class LogicProxied {
+    #afterPipes;
+    #beforePipes;
+
+    #actions = new Map();
+    #actionRunner = ActionRunner;
+
+    #populateBuilders = {};
+    #defaultPopulate = [];
+
+    #MODEL_NAME;
+    #MODULE_NAME;
+    #USER_MODEL_NAME = "";
+
+    #log;
+    #say;
+    #phrase;
+    #config;
+    #logAction;
+    #logDebugAction;
+
+    get log() {
+        return this.#log;
+    }
+    get say() {
+        return this.#say;
+    }
+    get phrase() {
+        return this.#phrase;
+    }
+
+    get config() {
+        return this.#config;
+    }
+
+    get logAction() {
+        return this.#logAction;
+    }
+
+    get logDebugAction() {
+        return this.#logDebugAction;
+    }
+
+    constructor(
+        actions = {},
+        actionRunner = ActionRunner,
+        {
+            MODULE_NAME,
+            MODEL_NAME,
+            target,
+            defaultPopulate,
+            populateBuilders,
+            USER_MODEL_NAME = "not-user//User",
+        }
+    ) {
+        this.#MODEL_NAME = MODEL_NAME;
+        this.#MODULE_NAME = MODULE_NAME;
+        this.#USER_MODEL_NAME = USER_MODEL_NAME;
+
+        defaultPopulate && (this.#defaultPopulate = defaultPopulate);
+        populateBuilders && (this.#populateBuilders = populateBuilders);
+
+        actionRunner && (this.#actionRunner = actionRunner);
+        this.#afterPipes = new NamedActionPipes(
+            NamedActionPipes.PIPE_TYPES.CONSECUTIVE,
+            this.#actionRunner
+        );
+        this.#beforePipes = new NamedActionPipes(
+            NamedActionPipes.PIPE_TYPES.CONSECUTIVE,
+            this.#actionRunner
+        );
+
+        Object.keys(actions).forEach((actionName) => {
+            this.#actions.set(actionName, actions[actionName]);
+        });
+
+        this.#initTools(target);
+
+        // proxy logic, do something before each call of all methods inside class
+        // like if arg passed is 3, print something additionally
+        return new Proxy(this, {
+            get(target, prop) {
+                if (target.#actions.has(prop)) {
+                    return target.#getActionRunner(prop);
+                } else {
+                    return target[prop];
+                }
+            },
+        });
+    }
+
+    #initTools(target) {
+        this.#log = LogInit(
+            target,
+            `${this.#MODULE_NAME}//Logic//${this.#MODEL_NAME}`
+        );
+        this.#say = sayForModule(this.#MODULE_NAME);
+        this.#phrase = modulePhrase(this.#MODULE_NAME);
+        this.#config = configInit.readerForModule(this.#MODULE_NAME);
+
+        this.#logAction = (actionName, identity, params = {}) => {
+            this.#log &&
+                this.#log.log({
+                    time: new Date(),
+                    module: this.#MODULE_NAME,
+                    logic: this.#MODEL_NAME,
+                    action: actionName,
+                    ...identity,
+                    params,
+                });
+        };
+        this.#logDebugAction = (action, identity) => {
+            this.#log &&
+                this.#log.debug(
+                    new Date(),
+                    `${this.#MODULE_NAME}//Logic//${
+                        this.#MODEL_NAME
+                    }//${action}`,
+                    identity?.ip,
+                    identity?.root
+                );
+        };
+    }
+
+    getModel() {
+        return getApp().getModel(`${this.#MODULE_NAME}//${this.#MODEL_NAME}`);
+    }
+
+    getModelSchema() {
+        return getApp().getModelSchema(
+            `${this.#MODULE_NAME}//${this.#MODEL_NAME}`
+        );
+    }
+
+    getModelUser() {
+        return this.#USER_MODEL_NAME
+            ? getApp().getModel(this.#USER_MODEL_NAME)
+            : undefined;
+    }
+
+    async getPopulate(actionName, prepared) {
+        if (
+            this.#populateBuilders &&
+            objHas(this.#populateBuilders, actionName) &&
+            isFunc(this.#populateBuilders[actionName])
+        ) {
+            return await executeFunctionAsAsync(
+                this.#populateBuilders[actionName],
+                [prepared]
+            );
+        }
+        return this.#defaultPopulate;
+    }
+
+    #getActionRunner(actionName) {
+        return async (...args) => {
+            try {
+                const action = this.#actions.get(actionName);
+                await this.#beforeAction(actionName, [
+                    this,
+                    actionName,
+                    ...args,
+                ]);
+                const actionResult = await this.#actionRunner.run(action, [
+                    this,
+                    actionName,
+                    ...args,
+                ]);
+                await this.#afterAction(actionName, [
+                    this,
+                    actionName,
+                    actionResult,
+                    ...args,
+                ]);
+                return actionResult;
+            } catch (e) {
+                throw new LogicExceptionActionExecutionError(
+                    this.#MODULE_NAME,
+                    this.#MODEL_NAME,
+                    actionName,
+                    e
+                );
+            }
+        };
+    }
+
+    async #beforeAction(actionName, args) {
+        await this.#beforePipes.execute(actionName, args);
+    }
+
+    async #afterAction(actionName, args) {
+        await this.#afterPipes.execute(actionName, args);
+    }
+
+    onAfter(name, action) {
+        this.#afterPipes.add(name, action);
+    }
+
+    offAfter(name, action) {
+        this.#afterPipes.remove(name, action);
+    }
+
+    onBefore(name, action) {
+        this.#beforePipes.add(name, action);
+    }
+
+    offBefore(name, action) {
+        this.#beforePipes.remove(name, action);
+    }
+}
+
+module.exports = LogicProxied;

package/src/logic/named.actions.pipes.js

@@ -0,0 +1,102 @@
+const { objHas } = require("../common.js");
+const {
+    ActionExceptionPipeExecutionError,
+} = require("../exceptions/action.js");
+
+const ActionRunner = require("./action.runner.js");
+
+const CONSECUTIVE = 1;
+const PARALLEL = 2;
+
+const PIPE_TYPES = { CONSECUTIVE, PARALLEL };
+Object.freeze(PIPE_TYPES);
+
+class NamedActionPipes {
+    static PIPE_TYPES = PIPE_TYPES;
+    #type = CONSECUTIVE;
+    #all = [];
+    #named = {};
+    #actionRunner = ActionRunner;
+
+    constructor(type = CONSECUTIVE, actionRunner = ActionRunner) {
+        this.#type = type;
+        actionRunner && (this.#actionRunner = actionRunner);
+    }
+
+    add(name, action) {
+        if (typeof name === "undefined") {
+            this.#addToPipe(this.#all, action);
+        } else {
+            this.#initNamedPipe(name);
+            this.#addToPipe(this.#named[name], action);
+        }
+        return this;
+    }
+
+    #addToPipe(pipe, action) {
+        if (!pipe.includes(action)) {
+            pipe.push(action);
+        }
+    }
+
+    #removeFromPipe(pipe, action) {
+        if (pipe.includes(action)) {
+            pipe.splice(pipe.indexOf(action), 1);
+        }
+    }
+
+    #initNamedPipe(name) {
+        if (!objHas(this.#named, name) || !Array.isArray(this.#named[name])) {
+            this.#named[name] = [];
+        }
+    }
+
+    remove(name, action) {
+        if (typeof name === "undefined") {
+            this.#removeFromPipe(this.#all, action);
+        } else {
+            this.#initNamedPipe(name);
+            this.#removeFromPipe(this.#named[name], action);
+        }
+        return this;
+    }
+
+    #buildPipe(name) {
+        const final = [...this.#all];
+        this.#initNamedPipe(name);
+        final.push(...this.#named[name]);
+        return final;
+    }
+
+    async execute(name, params) {
+        try {
+            const pipe = this.#buildPipe(name);
+            return await this.#execute(pipe, params);
+        } catch (e) {
+            throw new ActionExceptionPipeExecutionError({ cause: e });
+        }
+    }
+
+    async #execute(pipe, params) {
+        const ways = {
+            CONSECUTIVE: this.#executeConsecutive,
+            PARALLEL: this.#executeParallel,
+        };
+        return await ways[this.#type](pipe, params);
+    }
+
+    async #executeConsecutive(pipe, params) {
+        for (let action of pipe) {
+            await this.#actionRunner.run(action, params);
+        }
+    }
+
+    async #executeParallel(pipe, params) {
+        const promisesOfPipe = pipe.map((action) =>
+            this.#actionRunner.run(action, params)
+        );
+        await Promise.all(promisesOfPipe);
+    }
+}
+
+module.exports = NamedActionPipes;

package/src/model/default.js

@@ -1,3 +1,5 @@
+const { deleteResponseSuccess, updateResponseSuccess } = require("./utils.js");
+const { DBExceptionDeleteWasNotSuccessful } = require("../exceptions/db.js");
 /** @module Model/Default */
 const routine = require("./routine");
 const notQuery = require("not-filter");
@@ -158,7 +160,7 @@ function getOneRaw(id, condition = {}) {
  *	@static
  *	@param 	{string}		method 		name of the method
  *	@param 	{object|array}	filter 		filtering rules object
- *	@return {Query}						mongoose query object
+ *	@return {import('mongoose').Query}						mongoose query object
  **/
 function makeQuery(method, filter) {
     let versioningMod = {
@@ -349,6 +351,34 @@ function update(filter, data, many = false) {
     }
 }
 
+async function removeOne(filter) {
+    if (this.schema.statics.__versioning) {
+        const res = await this.updateOne(filter, { __closed: true });
+        if (!updateResponseSuccess(res, 1)) {
+            throw new DBExceptionDeleteWasNotSuccessful(res);
+        }
+    } else {
+        const res = await this.deleteOne(filter);
+        if (!deleteResponseSuccess(res, 1)) {
+            throw new DBExceptionDeleteWasNotSuccessful(res);
+        }
+    }
+}
+
+async function removeMany(filter) {
+    if (this.schema.statics.__versioning) {
+        const res = await this.updateMany(filter, { __closed: true });
+        if (!updateResponseSuccess(res, 0)) {
+            throw new DBExceptionDeleteWasNotSuccessful(res);
+        }
+    } else {
+        const res = await this.deleteMany(filter);
+        if (!deleteResponseSuccess(res, 0)) {
+            throw new DBExceptionDeleteWasNotSuccessful(res);
+        }
+    }
+}
+
 module.exports.thisStatics = {
     sanitizeInput,
     getOne,
@@ -364,6 +394,8 @@ module.exports.thisStatics = {
     listAndCount,
     add,
     update,
+    removeOne,
+    removeMany,
 };
 
 /**
@@ -383,14 +415,18 @@ function getID() {
  *	@return {number}	ID
  */
 function close(data = undefined) {
-    if (data && Object.keys(data)) {
-        Object.keys(data).forEach((fieldName) => {
-            notPath.setValueByPath(this, fieldName, data[fieldName]);
-            this.markModified(fieldName);
-        });
+    if (this?.schema?.statics?.__versioning) {
+        if (data && Object.keys(data)) {
+            Object.keys(data).forEach((fieldName) => {
+                notPath.setValueByPath(this, fieldName, data[fieldName]);
+                this.markModified(fieldName);
+            });
+        }
+        this.__closed = true;
+        return this.save();
+    } else {
+        return this.deleteOne({ _id: this._id });
     }
-    this.__closed = true;
-    return this.save();
 }
 
 function saveNewVersion() {

package/src/model/utils.js

@@ -7,12 +7,16 @@ function getBaseResult() {
 }
 
 function createInsertManySuccessSignature(count) {
-    return Object.assign(
-        {
-            insertedCount: count,
-        },
-        getBaseResult()
-    );
+    if (count > 0) {
+        return Object.assign(
+            {
+                insertedCount: count,
+            },
+            getBaseResult()
+        );
+    } else {
+        return Object.assign({}, getBaseResult());
+    }
 }
 
 function createInsertOneSuccessSignature() {
@@ -31,12 +35,16 @@ function createUpdateManySuccessSignature(count) {
 }
 
 function createDeleteManySuccessSignature(count) {
-    return Object.assign(
-        {
-            deletedCount: count,
-        },
-        getBaseResult()
-    );
+    if (count > 0) {
+        return Object.assign(
+            {
+                deletedCount: count,
+            },
+            getBaseResult()
+        );
+    } else {
+        return Object.assign({}, getBaseResult());
+    }
 }
 
 function insertResponseSuccess(res, count = 1) {
@@ -68,6 +76,7 @@ function deleteManyResponseSuccess(res, count) {
 }
 
 module.exports.deleteManyResponseSuccess = deleteManyResponseSuccess;
+
 /**
  * checking result of modification queries to ensure that changes were made
  */

package/src/types.js

@@ -169,4 +169,52 @@
  * @property    {notFieldModel}     [model]
  */
 
+/**
+ * @typedef {string}    uuid
+ */
+
+/**
+ * @typedef {object}    ListAndCountResult
+ * @property {Array<notAppDocument>}    list    list of extended mongoose documents
+ * @property {number} skip                      count of skiped from start of set
+ * @property {number} count                     total count of documents in this set
+ * @property {number} page                      number of returned page
+ * @property {number} pages                     total count of pages in this set
+ */
+
+/**
+ * @typedef     {object}    notAppModelMethods
+ * @property    {function(object):object} sanitizeInput
+ * @property    {function(uuid, [Array<string>], [object]):Promise<notAppDocument>} getOne
+ * @property    {function(number, [Array<string>], [object]):Promise<notAppDocument>} getOneByID
+ * @property    {function(uuid, [object]):Promise<notAppDocument>} getOneRaw
+ * @property    {function(string, object):Promise<notAppDocument|Array<notAppDocument>|undefined>} makeQuery
+ * @property    {function(number, number, object, object|Array):Promise<Array<notAppDocument>>} list
+ * @property    {function(string, Array<String>, object, Array<String>):Promise<Array<notAppDocument>>} listByField
+ * @property    {function([object]):Promise<Array<notAppDocument>>} listAll
+ * @property    {function(object|array):Promise<Array<notAppDocument>>} listAllAndPopulate
+ * @property    {function(object):Promise<number>} countWithFilter
+ * @property    {function(number, number, object, object | Array, Array<String>):Promise<Array<notAppDocument>>} listAndPopulate
+ * @property    {function(number, number, object, object|array, object|array, object):Promise<ListAndCountResult>} listAndCount
+ * @property    {function(object):Promise<notAppDocument>} add
+ * @property    {function(object, object, boolean):Promise<notAppDocument|undefined>} update
+ * @property    {function(object):Promise<undefined>} removeOne
+ * @property    {function(object):Promise<undefined>} removeMany
+ */
+
+/**
+ * @typedef     {import('mongoose').Model & notAppModelMethods}    notAppModel
+ **/
+
+/**
+ * @typedef     {object}    notAppDocumentMethods
+ * @property    {function():number} getID
+ * @property    {function([object]):Promise<notAppDocument|undefined>} close
+ * @property    {function():Promise<notAppDocument>} saveNewVersion
+ **/
+
+/**
+ * @typedef     {import('mongoose').Document & notAppDocumentMethods}    notAppDocument
+ **/
+
 module.exports = {};

package/test/model/default.js

@@ -974,6 +974,11 @@ module.exports = ({
             describe("close", () => {
                 it("simple run", async () => {
                     const ctx = {
+                        schema: {
+                            statics: {
+                                __versioning: true,
+                            },
+                        },
                         __closed: false,
                         async save() {
                             return this;

package/test/model/proto.js

@@ -351,6 +351,8 @@ module.exports = ({ mongod, mongoose }) => {
                 "listAllAndPopulate",
                 "listAndCount",
                 "listByField",
+                "removeMany",
+                "removeOne",
             ]);
             expect(moduleProto1.mongooseSchema.methods).to.have.keys([
                 "getName",

package/test/notModel.js

@@ -41,11 +41,11 @@ describe("notModel", function () {
         mongoose,
     });
 
-    require("./model/utils")({
+    /*require("./model/utils")({
         expect,
         mongod,
         mongoose,
-    });
+    });*/
 
     after(async () => {
         await mongoose.disconnect();