not-node 5.1.41 → 5.1.42

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "not-node",
-  "version": "5.1.41",
+  "version": "5.1.42",
   "description": "node complimentary part for client side notFramework.",
   "main": "index.js",
   "scripts": {
@@ -64,6 +64,7 @@
     "not-validation": "^0.0.8",
     "rate-limiter-flexible": "^2.3.7",
     "redis": "^4.1.1",
+    "redlock": "^5.0.0-beta.2",
     "rfdc": "^1.3.0",
     "rmdir": "^1.2.0",
     "serve-static": "*",

package/src/core/index.js

@@ -1,6 +1,6 @@
-const {generatePaths} = require('../common');
+const { generatePaths } = require("../common");
 
 module.exports = {
-  name: 'not-node',
-  paths: generatePaths(['fields', 'locales'], __dirname)
+    name: "not-node",
+    paths: generatePaths(["fields", "locales"], __dirname),
 };

package/src/init/index.js

@@ -141,6 +141,7 @@ class Init {
                 config: Init.getConfig(), //access to config
                 options, //options
                 master: Init, //this class
+                emit: ADDS.run.bind(ADDS),
             };
             //running all prepared initalizers with current context
             await initSequence.run(context);

package/src/init/{app.js → lib/app.js}

@@ -1,17 +1,15 @@
-const notAppConstructor = require("../app.js");
+const notAppConstructor = require("../../app.js");
 const ENV = process.env.NODE_ENV || "development";
 const path = require("path");
 const logger = require("not-log");
-const log = logger(module, "not-node//init");
+const log = logger(module, "not-node//init//app");
 const { notErrorReporter } = require("not-error");
 
-const emit = require("./additional").run;
-
 module.exports = class InitApp {
     static AppConstructor = notAppConstructor;
     static ReporterConstructor = notErrorReporter;
 
-    static async createApp({ config, options, master }) {
+    static async createApp({ config, options, master, emit }) {
         await emit("app.create.pre", { config, options, master });
         master.setApp(
             new InitApp.AppConstructor({ mongoose: master.getMongoose() })
@@ -19,7 +17,7 @@ module.exports = class InitApp {
         await emit("app.create.post", { config, options, master });
     }
 
-    static async setAppEnvs({ config, options, master }) {
+    static async setAppEnvs({ config, options, master, emit }) {
         await emit("app.setEnv.pre", { config, options, master });
         master.setEnv("hostname", config.get("hostname"));
         master.setEnv("server", `https://` + config.get("host"));
@@ -35,13 +33,13 @@ module.exports = class InitApp {
         await emit("app.setEnv.post", { config, options, master });
     }
 
-    static async initCore({ config, options, master }) {
+    static async initCore({ config, options, master, emit }) {
         await emit("app.initCore.pre", { config, options, master });
         master.getApp().importModuleFrom(path.join(__dirname, "../core"));
         await emit("app.initCore.post", { config, options, master });
     }
 
-    static async importModules({ config, options, master }) {
+    static async importModules({ config, options, master, emit }) {
         await emit("app.importModules.pre", { config, options, master });
         master.getApp().importModulesFrom(config.get("modulesPath"));
         if (Array.isArray(config.get("importModulesFromNPM"))) {
@@ -70,15 +68,15 @@ module.exports = class InitApp {
         }
     }
 
-    async run({ config, options, master }) {
+    async run({ config, options, master, emit }) {
         try {
             log.info("Init not-app...");
             await emit("app.pre", { config, options, master });
-            await InitApp.createApp({ config, options, master });
-            await InitApp.setAppEnvs({ config, options, master });
-            await InitApp.initCore({ config, options, master });
-            await InitApp.importModules({ config, options, master });
-            await InitApp.createReporter({ config, options, master });
+            await InitApp.createApp({ config, options, master, emit });
+            await InitApp.setAppEnvs({ config, options, master, emit });
+            await InitApp.initCore({ config, options, master, emit });
+            await InitApp.importModules({ config, options, master, emit });
+            await InitApp.createReporter({ config, options, master, emit });
             await emit("app.post", { config, options, master });
         } catch (e) {
             master.throwError(e.message, 1);

package/src/init/{core.js → lib/core.js}

@@ -1,5 +1,5 @@
 const path = require("path");
-const Fields = require("../fields");
+const Fields = require("../../fields");
 const notLocale = require("not-locale");
 
 module.exports = class InitCore {

package/src/init/{cors.js → lib/cors.js}

@@ -1,5 +1,4 @@
-const log = require("not-log")(module, "not-node//init");
-const ADDS = require("./additional");
+const log = require("not-log")(module, "not-node//init//cors");
 
 module.exports = class InitCORS {
     static getOriginFilter(whitelist) {
@@ -8,8 +7,8 @@ module.exports = class InitCORS {
         };
     }
 
-    async run({ config, options, master }) {
-        await ADDS.run("cors.pre", { config, options, master });
+    async run({ config, options, master, emit }) {
+        await emit("cors.pre", { config, options, master });
         const cors = require("cors");
         log.info("Setting up CORS rules...");
         const whitelist = config.get("cors");
@@ -20,6 +19,6 @@ module.exports = class InitCORS {
         };
         log.info("CORS options", corsOptions);
         master.getServer().use(cors(corsOptions));
-        await ADDS.run("cors.post", { config, options, master });
+        await emit("cors.post", { config, options, master });
     }
 };

package/src/init/{db → lib/db}/index.js

@@ -1,5 +1,5 @@
 const path = require("path");
-const { objHas } = require("../../common");
+const { objHas } = require("../../../common");
 
 module.exports = class InitDB {
     static default = path.resolve(__dirname, "./mongoose.js");
@@ -32,7 +32,7 @@ module.exports = class InitDB {
      * require('not-node').getEnv('mongoose')
      * require('not-node').getEnv('redis')
      **/
-    async run({ master, config, options }) {
+    async run({ master, config, options, emit }) {
         const conf = config.get("db");
         for (let driver in conf) {
             const Constructor = InitDB.getConstructor(driver);
@@ -42,6 +42,7 @@ module.exports = class InitDB {
                 options,
                 conf: conf[driver],
                 alias: driver,
+                emit,
             });
         }
     }

package/src/init/{db → lib/db}/ioredis.js

@@ -1,5 +1,4 @@
-const log = require("not-log")(module, "not-node//init");
-const ADDS = require("../additional");
+const log = require("not-log")(module, "not-node//init//db//ioredis");
 
 module.exports = class InitDBRedisIO {
     static async initRedis({ conf, master, alias }) {
@@ -11,8 +10,8 @@ module.exports = class InitDBRedisIO {
         log.log("redis client");
     }
 
-    async run({ config, options, master, conf, alias }) {
-        await ADDS.run(`db.${alias}.pre`, {
+    async run({ config, options, master, conf, alias, emit }) {
+        await emit(`db.${alias}.pre`, {
             config,
             options,
             master,
@@ -20,7 +19,7 @@ module.exports = class InitDBRedisIO {
             alias,
         });
         await InitDBRedisIO.initRedis({ conf, master, alias });
-        await ADDS.run(`db.${alias}.post`, {
+        await emit(`db.${alias}.post`, {
             config,
             options,
             master,

package/src/init/{db → lib/db}/mongoose.js

@@ -1,5 +1,4 @@
-const log = require("not-log")(module, "not-node//init");
-const ADDS = require("../additional");
+const log = require("not-log")(module, "not-node//init//db//mongoose");
 
 module.exports = class InitDBMongoose {
     static fixMongooseOptions(opts) {
@@ -10,7 +9,7 @@ module.exports = class InitDBMongoose {
     }
 
     static async initMongoose({ conf, master, alias }) {
-        const Increment = require("../../model/increment.js");
+        const Increment = require("../../../model/increment.js");
         log.info("Setting up mongoose connection...");
         const mongoose = require("mongoose");
         mongoose.Promise = global.Promise;
@@ -26,9 +25,9 @@ module.exports = class InitDBMongoose {
         master.setEnv(`db.${alias}`, mongoose);
     }
 
-    async run({ config, options, master, conf, alias }) {
+    async run({ config, options, master, conf, alias, emit }) {
         log.info(`db.${alias}.pre`);
-        await ADDS.run(`db.${alias}.pre`, {
+        await emit(`db.${alias}.pre`, {
             config,
             options,
             master,
@@ -36,7 +35,7 @@ module.exports = class InitDBMongoose {
             alias,
         });
         await InitDBMongoose.initMongoose({ conf, master, alias });
-        await ADDS.run(`db.${alias}.post`, {
+        await emit(`db.${alias}.post`, {
             config,
             options,
             master,

package/src/init/{db → lib/db}/redis.js

@@ -1,6 +1,5 @@
 const { notError } = require("not-error");
-const log = require("not-log")(module, "not-node//init");
-const ADDS = require("../additional");
+const log = require("not-log")(module, "not-node//init//db//redis");
 
 module.exports = class InitDBRedis {
     static async initRedis({ conf, master, alias }) {
@@ -11,8 +10,8 @@ module.exports = class InitDBRedis {
         master.setEnv(`db.${alias}`, redisClient);
     }
 
-    async run({ config, options, master, conf, alias }) {
-        await ADDS.run(`db.${alias}.pre`, {
+    async run({ config, options, master, conf, alias, emit }) {
+        await emit(`db.${alias}.pre`, {
             config,
             options,
             master,
@@ -20,7 +19,7 @@ module.exports = class InitDBRedis {
             alias,
         });
         await InitDBRedis.initRedis({ conf, master, alias });
-        await ADDS.run(`db.${alias}.post`, {
+        await emit(`db.${alias}.post`, {
             config,
             options,
             master,

package/src/init/{env.js → lib/env.js}

@@ -1,5 +1,4 @@
-const log = require("not-log")(module, "not-node//init");
-const ADDS = require("./additional");
+const log = require("not-log")(module, "not-node//init//env");
 
 module.exports = class InitENV {
     static getProxyPort(config) {
@@ -21,9 +20,9 @@ module.exports = class InitENV {
         return name;
     }
 
-    async run({ config, options, master }) {
+    async run({ config, options, master, emit }) {
         log.info("Setting up server environment variables...");
-        await ADDS.run("env.pre", { config, options, master });
+        await emit("env.pre", { config, options, master });
         config.set(
             "staticPath",
             master.getAbsolutePath(config.get("path:static") || "static")
@@ -45,6 +44,6 @@ module.exports = class InitENV {
             log.log("wsPath", master.getAbsolutePath(config.get("path:ws")));
             config.set("wsPath", master.getAbsolutePath(config.get("path:ws")));
         }
-        await ADDS.run("env.post", { config, options, master });
+        await emit("env.post", { config, options, master });
     }
 };

package/src/init/{express.js → lib/express.js}

@@ -1,5 +1,4 @@
-const emit = require("./additional").run;
-const Log = require("not-log")(module, "not-node//init");
+const Log = require("not-log")(module, "not-node//init//express");
 
 module.exports = class InitExpress {
     static requestLogging({ /*config, options, */ master }) {
@@ -9,7 +8,7 @@ module.exports = class InitExpress {
         });
     }
 
-    async run({ options, config, master }) {
+    async run({ options, config, master, emit }) {
         Log.info("Init express app...");
         await emit("express.pre", { options, config, master });
         //express

package/src/init/{http.js → lib/http.js}

@@ -1,6 +1,5 @@
-const log = require("not-log")(module, "not-node//init");
+const log = require("not-log")(module, "not-node//init//http");
 const fs = require("fs");
-const ADDS = require("./additional");
 
 module.exports = class InitHTTP {
     listenPromise({ config, master }) {
@@ -61,13 +60,13 @@ module.exports = class InitHTTP {
         return config.get("ssl:enabled") === true;
     }
 
-    async run({ options, config, master }) {
-        await ADDS.run("http.pre", { options, config, master });
+    async run({ options, config, master, emit }) {
+        await emit("http.pre", { options, config, master });
         if (InitHTTP.isSecure({ config })) {
             await this.runHTTPS({ options, config, master });
         } else {
             await this.runHTTP({ options, config, master });
         }
-        await ADDS.run("http.post", { options, config, master });
+        await emit("http.post", { options, config, master });
     }
 };

package/src/init/{informer.js → lib/informer.js}

@@ -1,4 +1,4 @@
-const log = require("not-log")(module, "not-node//init");
+const log = require("not-log")(module, "not-node//init//informer");
 
 module.exports = class InitInformer {
     async run({ master }) {

package/src/init/{middleware.js → lib/middleware.js}

@@ -1,10 +1,9 @@
-const log = require("not-log")(module, "not-node//init");
-const ADDS = require("./additional");
+const log = require("not-log")(module, "not-node//init//middleware");
 
 module.exports = class InitMiddleware {
-    async run({ config, options, master }) {
+    async run({ config, options, master, emit }) {
         log.info("Setting up middlewares...");
-        await ADDS.run("middleware.pre", { config, options, master });
+        await emit("middleware.pre", { config, options, master });
         const input = config.get("middleware");
         if (input) {
             for (let ware in input) {
@@ -22,6 +21,6 @@ module.exports = class InitMiddleware {
                 }
             }
         }
-        await ADDS.run("middleware.post", { config, options, master });
+        await emit("middleware.post", { config, options, master });
     }
 };

package/src/init/{monitoring.js → lib/monitoring.js}

@@ -1,4 +1,4 @@
-const Log = require("not-log")(module, "not-node//init");
+const Log = require("not-log")(module, "not-node//init//monitoring");
 
 module.exports = class InitMonitoring {
     async run() {

package/src/init/{rateLimiter.js → lib/rateLimiter.js}

@@ -1,6 +1,5 @@
-const emit = require("./additional").run;
 const log = require("not-log")(module, "RateLimiter");
-const { partCopyObj } = require("../common");
+const { partCopyObj } = require("../../common");
 
 const DEFAULT_OPTIONS = {
     keyPrefix: "rateLimiterMiddleware",
@@ -23,7 +22,7 @@ module.exports = class InitRateLimiter {
         };
     }
 
-    async run({ config, master }) {
+    async run({ config, master, emit }) {
         await emit("rateLimiter.pre", { config, master });
         const rateLimiter = InitRateLimiter.createRateLimiter({
             config,

package/src/init/lib/redlock.js

@@ -0,0 +1,44 @@
+const log = require("not-log")(module, "not-node//init//redlock");
+const { default: Redlock, ResourceLockedError } = require("redlock");
+const { notError } = require("not-error");
+
+const DEFAULT_CONFIG = {
+    driftFactor: 0.01, // multiplied by lock ttl to determine drift time
+    retryCount: 10,
+    retryDelay: 200, // time in ms
+    retryJitter: 200, // time in ms
+    automaticExtensionThreshold: 500, // time in ms
+};
+
+module.exports = class InitDBRedlock {
+    static async initLocker({ master, alias, redisClientAlias, config }) {
+        log.info("Setting up ioredis locker...");
+        const redisClient = master.getEnv(`db.${redisClientAlias}`);
+        const redlockConfig = config.get(`db.${alias}`);
+        const redlock = new Redlock(
+            [redisClient],
+            redlockConfig || DEFAULT_CONFIG
+        );
+        redlock.on("error", (error) => {
+            // Ignore cases where a resource is explicitly marked as locked on a client.
+            if (error instanceof ResourceLockedError) {
+                return;
+            }
+            // Log all other errors.
+            log.error(error);
+            master.getApp().report(new notError("Redlock failed", {}, error));
+        });
+        master.setEnv(`db.${alias}`, redlock);
+    }
+
+    async run({ master, config, emit, options }) {
+        await emit("redlock.pre", { config, options, master });
+        await InitDBRedlock.initLocker({
+            config,
+            master,
+            alias: "redlock",
+            redisClientAlias: "ioredis",
+        });
+        await emit("redlock.post", { config, options, master });
+    }
+};

package/src/init/{routes.js → lib/routes.js}

@@ -1,7 +1,7 @@
 "use strict";
 
 const serveStatic = require("serve-static");
-const log = require("not-log")(module, "not-node//init");
+const log = require("not-log")(module, "not-node//init//routes");
 const { notError, notValidationError, notRequestError } = require("not-error");
 
 module.exports = class InitRoutes {

package/src/init/{security.js → lib/security.js}

@@ -1,4 +1,4 @@
-const Log = require("not-log")(module, "not-node//init");
+const Log = require("not-log")(module, "not-node//init//security");
 
 module.exports = class InitSecurity {
     getCSPDirectives({ config }) {

package/src/init/{sessions → lib/sessions}/index.js

@@ -16,9 +16,9 @@ module.exports = class InitSessions {
         }
     }
 
-    async run({ master, config, options }) {
+    async run({ master, config, options, emit }) {
         const conf = config.get("session");
         const Constructor = InitSessions.getConstructor(conf);
-        await new Constructor().run({ master, config, options, conf });
+        await new Constructor().run({ master, config, options, conf, emit });
     }
 };

package/src/init/{sessions → lib/sessions}/mongoose.js

@@ -1,6 +1,5 @@
 const { notError } = require("not-error");
-const log = require("not-log")(module, "not-node//init");
-const ADDS = require("../additional");
+const log = require("not-log")(module, "not-node//init//sessions//mongoose");
 
 module.exports = class InitSessionsMongo {
     static createStore({ config, master, expressSession }) {
@@ -29,10 +28,10 @@ module.exports = class InitSessionsMongo {
         return store;
     }
 
-    async run({ config, options, master }) {
+    async run({ config, options, master, emit }) {
         const expressSession = require("express-session");
         log.info("Setting up user sessions handler(mongoose)...");
-        await ADDS.run("sessions.pre", { config, options, master });
+        await emit("sessions.pre", { config, options, master });
         master.getServer().use(
             expressSession({
                 secret: config.get("session:secret"),
@@ -47,6 +46,6 @@ module.exports = class InitSessionsMongo {
                 }),
             })
         );
-        await ADDS.run("sessions.post", { config, options, master });
+        await emit("sessions.post", { config, options, master });
     }
 };

package/src/init/{sessions → lib/sessions}/redis.js

@@ -1,12 +1,11 @@
-const log = require("not-log")(module, "not-node//init");
-const ADDS = require("../additional");
+const log = require("not-log")(module, "not-node//init//sessions//ioredis");
 
 const DEFAULT_CLIENT = "ioredis";
 
 module.exports = class InitSessionsRedis {
-    async run({ config, options, master }) {
+    async run({ config, options, master, emit }) {
         log.info("Setting up user sessions handler(redis)...");
-        await ADDS.run("sessions.pre", { config, options, master });
+        await emit("sessions.pre", { config, options, master });
         const expressSession = require("express-session");
         const storeClient = config.get("session.client", DEFAULT_CLIENT);
         const redisClient = master.getEnv(`db.${storeClient}`);
@@ -26,6 +25,6 @@ module.exports = class InitSessionsRedis {
                 }),
             })
         );
-        await ADDS.run("sessions.post", { config, options, master });
+        await emit("sessions.post", { config, options, master });
     }
 };

package/src/init/{static.js → lib/static.js}

@@ -1,7 +1,5 @@
 const path = require("path");
 
-const ADDS = require("./additional");
-
 const DEFAULT_ROLES = ["root", "admin", "client", "user", "guest"];
 
 module.exports = class InitStatic {
@@ -40,8 +38,8 @@ module.exports = class InitStatic {
         };
     }
 
-    async run({ config, options, master }) {
-        await ADDS.run("static.pre", { config, options, master });
+    async run({ config, options, master, emit }) {
+        await emit("static.pre", { config, options, master });
         master.getServer().use(
             "/front/(:role).js",
             InitStatic.createStaticFrontServer("js", {
@@ -58,6 +56,6 @@ module.exports = class InitStatic {
                 master,
             })
         );
-        await ADDS.run("static.post", { config, options, master });
+        await emit("static.post", { config, options, master });
     }
 };

package/src/init/{template.js → lib/template.js}

@@ -1,5 +1,4 @@
-const log = require("not-log")(module, "not-node//init");
-const ADDS = require("./additional");
+const log = require("not-log")(module, "not-node//init//template");
 
 const DEFAULT = {
     views: "views",
@@ -12,12 +11,12 @@ module.exports = class InitTemplate {
         return val || DEFAULT;
     }
 
-    async run({ config, options, master }) {
+    async run({ config, options, master, emit }) {
         const input = InitTemplate.loadConfig({ config });
         log.info("Setting up template (" + input.engine + ") engine...");
-        await ADDS.run("template.pre", { config, options, master, input });
+        await emit("template.pre", { config, options, master, input });
         master.getServer().set("views", master.getAbsolutePath(input.views));
         master.getServer().set("view engine", input.engine);
-        await ADDS.run("template.post", { config, options, master });
+        await emit("template.post", { config, options, master });
     }
 };

package/src/init/sequence.standart.js

@@ -1,24 +1,25 @@
-const initEnv = require("./env");
-const initDB = require("./db");
-const initExpress = require("./express");
-const initCompression = require("./compression");
-const initSecurity = require("./security");
-const initBodyparser = require("./bodyparser");
-const initMethodOverride = require("./methodoverride");
-const initFileupload = require("./fileupload");
-const initNotApp = require("./app");
-const initSessions = require("./sessions");
-const initTemplate = require("./template");
-const initCORS = require("./cors");
+const initEnv = require("./lib/env");
+const initDB = require("./lib/db");
+const InitDBRedlock = require("./lib/redlock");
+const initExpress = require("./lib/express");
+const initCompression = require("./lib/compression");
+const initSecurity = require("./lib/security");
+const initBodyparser = require("./lib/bodyparser");
+const initMethodOverride = require("./lib/methodoverride");
+const initFileupload = require("./lib/fileupload");
+const initNotApp = require("./lib/app");
+const initSessions = require("./lib/sessions");
+const initTemplate = require("./lib/template");
+const initCORS = require("./lib/cors");
 //const initCore = require('./core');
-const initMiddleware = require("./middleware");
-const initStatic = require("./static");
-const initRoutes = require("./routes");
-const initRateLimiter = require("./rateLimiter");
-const initModules = require("./modules");
-const initInformer = require("./informer");
-const initHTTP = require("./http");
-const initMonitoring = require("./monitoring");
+const initMiddleware = require("./lib/middleware");
+const initStatic = require("./lib/static");
+const initRoutes = require("./lib/routes");
+const initRateLimiter = require("./lib/rateLimiter");
+const initModules = require("./lib/modules");
+const initInformer = require("./lib/informer");
+const initHTTP = require("./lib/http");
+const initMonitoring = require("./lib/monitoring");
 
 module.exports = [
     //creating set of variables derived from basic ones,
@@ -26,6 +27,8 @@ module.exports = [
     initEnv,
     //DB access drivers
     initDB,
+    //locking mech based upon ioredis
+    InitDBRedlock,
     //http(s) server
     initExpress,
     initRateLimiter,

package/src/model/default.js

@@ -386,7 +386,7 @@ function close() {
 }
 
 function saveNewVersion() {
-    return routine.update(this, { _id: this._id }, this.toObject());
+    return routine.update(this.constructor, { _id: this._id }, this.toObject());
 }
 
 module.exports.thisMethods = {

package/src/model/exceptions.js

@@ -7,13 +7,13 @@ class VersioningExceptionSameOldData extends notError {
 }
 module.exports.VersioningExceptionSameOldData = VersioningExceptionSameOldData;
 
-class VersioningExceptioNoPreviousVersions extends notError {
+class VersioningExceptionNoPpreviousVersions extends notError {
     constructor() {
         super("not-node:versioning_error_no_previous_versions");
     }
 }
-module.exports.VersioningExceptioNoPreviousVersions =
-    VersioningExceptioNoPreviousVersions;
+module.exports.VersioningExceptionNoPpreviousVersions =
+    VersioningExceptionNoPpreviousVersions;
 
 class IncrementExceptionIDGeneratorRebaseFailed extends notError {
     constructor() {

package/src/model/routine.js

@@ -2,99 +2,153 @@
 
 const incrementNext = require("./increment");
 const { DBExceptionUpdateOneWasNotSuccessful } = require("../exceptions/db");
+
 //const { updateResponseSuccess } = require("./utils");
 class ModelRoutine {
-    static incremental(model) {
-        return model.schema.statics.__incField;
+    static incremental(ModelConstructor) {
+        return ModelConstructor.schema.statics.__incField;
     }
 
-    static versioning(model) {
-        return model.schema.statics.__versioning;
+    static versioning(ModelConstructor) {
+        return ModelConstructor.schema.statics.__versioning;
     }
 
-    static addWithoutVersion(model, data) {
-        return new model(data).save();
+    static addWithoutVersion(ModelConstructor, data) {
+        return new ModelConstructor(data).save();
     }
 
-    static async addWithVersion(model, data) {
+    static async addWithVersion(ModelConstructor, data) {
         data.__latest = true;
-        const item = await new model(data).save();
-        return await model.saveVersion(item._id);
+        const item = await new ModelConstructor(data).save();
+        return await ModelConstructor.saveVersion(item._id);
     }
 
-    static async add(model, data) {
-        if (ModelRoutine.incremental(model)) {
+    static async add(ModelConstructor, data) {
+        if (ModelRoutine.incremental(ModelConstructor)) {
             const modelID = await incrementNext.next(
-                model.__incModel,
-                model.__incFilter,
+                ModelConstructor.__incModel,
+                ModelConstructor.__incFilter,
                 data
             );
-            data[model.__incField] = modelID;
-            if (ModelRoutine.versioning(model)) {
-                return await ModelRoutine.addWithVersion(model, data);
+            data[ModelConstructor.__incField] = modelID;
+            if (ModelRoutine.versioning(ModelConstructor)) {
+                return await ModelRoutine.addWithVersion(
+                    ModelConstructor,
+                    data
+                );
             } else {
-                return await ModelRoutine.addWithoutVersion(model, data);
+                return await ModelRoutine.addWithoutVersion(
+                    ModelConstructor,
+                    data
+                );
             }
         } else {
-            if (ModelRoutine.versioning(model)) {
-                return await ModelRoutine.addWithVersion(model, data);
+            if (ModelRoutine.versioning(ModelConstructor)) {
+                return await ModelRoutine.addWithVersion(
+                    ModelConstructor,
+                    data
+                );
             } else {
-                return await ModelRoutine.addWithoutVersion(model, data);
+                return await ModelRoutine.addWithoutVersion(
+                    ModelConstructor,
+                    data
+                );
             }
         }
     }
 
-    static async update(model, filter, data) {
-        if ("_id" in data) delete data._id;
-        if (ModelRoutine.versioning(model)) {
-            return ModelRoutine.updateWithVersion(model, filter, data);
+    static async update(ModelConstructor, filter, data) {
+        if (data && "_id" in data) delete data._id;
+        if (ModelRoutine.versioning(ModelConstructor)) {
+            return ModelRoutine.updateWithVersion(
+                ModelConstructor,
+                filter,
+                data
+            );
         } else {
-            return ModelRoutine.updateWithoutVersion(model, filter, data);
+            return ModelRoutine.updateWithoutVersion(
+                ModelConstructor,
+                filter,
+                data
+            );
         }
     }
 
-    static updateWithoutVersion(model, filter, data) {
-        return model
-            .findOneAndUpdate(filter, data, {
+    static updateWithoutVersion(ModelConstructor, filter, data) {
+        return ModelConstructor.findOneAndUpdate(
+            filter,
+            { $set: data },
+            {
                 returnOriginal: false,
-                returnDocument: "fater",
+                returnDocument: "after",
                 new: true,
-            })
-            .exec();
+            }
+        )
+            .exec()
+            .then((result) => {
+                if (result) {
+                    return result;
+                } else {
+                    throw new Error("updateWithoutVersion FAILED");
+                }
+            });
     }
 
-    static async updateWithVersion(model, filter, data) {
-        filter.__latest = true;
-        filter.__closed = false;
-        const result = await model
-            .findOneAndUpdate(filter, data, {
-                returnOriginal: false,
-                returnDocument: "fater",
-                new: true,
-            })
-            .exec();
-        if (result) {
-            return model.saveVersion(result._id);
-        } else {
-            throw new DBExceptionUpdateOneWasNotSuccessful();
-        }
+    static async updateWithVersion(ModelConstructor, filter, data) {
+        let result;
+        const session = await ModelConstructor.startSession();
+        await session.withTransaction(async () => {
+            filter.__latest = true;
+            filter.__closed = false;
+            if (ModelConstructor.findOneAndUpdate) {
+                const updateResult = await ModelConstructor.findOneAndUpdate(
+                    filter,
+                    { $set: data },
+                    {
+                        returnOriginal: false,
+                        returnDocument: "after",
+                        new: true,
+                    }
+                );
+                if (updateResult) {
+                    result = await ModelConstructor.saveVersion(
+                        ModelConstructor,
+                        updateResult._id
+                    );
+                } else {
+                    throw new DBExceptionUpdateOneWasNotSuccessful();
+                }
+            } else {
+                throw new DBExceptionUpdateOneWasNotSuccessful();
+            }
+        });
+        session.endSession();
+        return result;
     }
 
-    static async updateMany(model, filter, data) {
+    static async updateMany(ModelConstructor, filter, data) {
         if ("_id" in data) delete data._id;
-        if (ModelRoutine.versioning(model)) {
-            return ModelRoutine.updateManyWithVersion(model, filter, data);
+        if (ModelRoutine.versioning(ModelConstructor)) {
+            return ModelRoutine.updateManyWithVersion(
+                ModelConstructor,
+                filter,
+                data
+            );
         } else {
-            return ModelRoutine.updateManyWithoutVersion(model, filter, data);
+            return ModelRoutine.updateManyWithoutVersion(
+                ModelConstructor,
+                filter,
+                data
+            );
         }
     }
 
-    static updateManyWithoutVersion(model, filter, data) {
-        return model.updateMany(filter, data);
+    static updateManyWithoutVersion(ModelConstructor, filter, data) {
+        return ModelConstructor.updateMany(filter, data);
     }
 
-    static async updateManyWithVersion(model, filter, data) {
-        const list = await model.find({
+    static async updateManyWithVersion(ModelConstructor, filter, data) {
+        const list = await ModelConstructor.find({
             __closed: false,
             __latest: true,
             ...filter,
@@ -102,7 +156,7 @@ class ModelRoutine {
         return await Promise.allSettled(
             list.map((item) => {
                 return ModelRoutine.updateWithVersion(
-                    model,
+                    ModelConstructor,
                     { _id: item._id },
                     data
                 );

package/src/model/versioning.js

@@ -11,8 +11,12 @@ const TECH_FIELDS = [
     "__closed",
 ];
 
+function toObject(obj) {
+    return obj.toObject ? obj.toObject() : obj;
+}
+
 const {
-    VersioningExceptioNoPreviousVersions,
+    VersioningExceptioNoPpreviousVersions,
     VersioningExceptionSameOldData,
 } = require("./exceptions.js");
 
@@ -36,7 +40,7 @@ class ModelVersioning {
             doc.__versions = [];
         }
         doc.__versions.unshift(version._id); //первая в массиве последняя [3,2,1,0]
-        return doc.save();
+        doc.markModified("__versions");
     }
 
     static stripTechData(a) {
@@ -47,7 +51,7 @@ class ModelVersioning {
     }
 
     static jsonCopy(a) {
-        return JSON.parse(JSON.stringify(a));
+        return JSON.parse(JSON.stringify(toObject(a)));
     }
 
     static isThisDocsDifferent(a, b) {
@@ -61,20 +65,20 @@ class ModelVersioning {
 
     /**
      * Compares latest version in __versions list in data with data
-     * @param {MongooseModel}  thisModel   model of data
+     * @param {MongooseModel}  ModelConstructor   model of data
      * @param {Object}         data        data to save
      * @return {boolean}                   if data differs from latest version
      */
-    static async isNew(thisModel, data) {
+    static async isNew(ModelConstructor, data) {
         let latestId = ModelVersioning.getLatestVersionId(data);
-        let previous = await thisModel.findById(latestId);
+        let previous = await ModelConstructor.findOne({ _id: latestId });
         if (typeof previous !== "undefined" && previous !== null) {
             return ModelVersioning.isThisDocsDifferent(
                 data,
-                previous.toObject()
+                toObject(previous)
             );
         } else {
-            throw new VersioningExceptioNoPreviousVersions();
+            throw new VersioningExceptioNoPpreviousVersions();
         }
     }
 
@@ -82,28 +86,26 @@ class ModelVersioning {
      * Saves current version to versions archive, updates current version versioning tags
      * @param {ObjectId}      id             current version _id (just saved version)
      * @param {Object}      data             data to save
-     * @param {MongooseModel} thisModel      model to use
+     * @param {MongooseModel} ModelConstructor      model to use
      * @return {Promise<MongooseDocument>}   current version with updated versioning tags
      */
-    static async saveVersion(id, data, model) {
+    static async saveVersion(id, data, ModelConstructor) {
         let preservedVersionNumber = ModelVersioning.extractVersionNumber(data),
             preservedVersionsList = [...data.__versions]; //making copy
-        let different = await ModelVersioning.isNew(model, data);
+        let different = await ModelVersioning.isNew(ModelConstructor, data);
         if (different) {
             //it's not latest version, it's archived copy
             delete data.__latest;
             //saves to archive with preserved data
-            let versionDoc = new model(data);
+            let versionDoc = new ModelConstructor(data);
             versionDoc.__version = preservedVersionNumber;
             versionDoc.__versions = preservedVersionsList;
             await versionDoc.save();
             //updating history
-            let originalDoc = await model.findById(id).exec();
+            let originalDoc = await ModelConstructor.findOne({ _id: id });
             originalDoc.__version = preservedVersionNumber + 1;
-            return await ModelVersioning.addVersionToHistory(
-                originalDoc,
-                versionDoc
-            );
+            ModelVersioning.addVersionToHistory(originalDoc, versionDoc);
+            return await originalDoc.save();
         }
         throw new VersioningExceptionSameOldData();
     }
@@ -112,24 +114,24 @@ class ModelVersioning {
      * Saves first version. Run AFTER doing .save() on document.
      * @param {ObjectId}      id             current version _id (just saved version)
      * @param {Object}      data             data to save
-     * @param {MongooseModel} thisModel      model to use
+     * @param {MongooseModel} ModelConstructor      model to use
      * @return {Promise<MongooseDocument>}   current version with updated versions tags
      */
-    static async saveFirstVersion(id, data, thisModel) {
+    static async saveFirstVersion(id, data, ModelConstructor) {
         //it's not latest version, it's archived copy
         delete data.__latest;
         //saves to archive
-        let versionDoc = new thisModel(data);
+        let versionDoc = new ModelConstructor(data);
         await versionDoc.save();
         //retrieving original
-        let originalDoc = await thisModel.findById(id).exec();
+
+        //const findById = getFunc(thisModel,'findById');
+        let originalDoc = await ModelConstructor.findOne({ _id: id });
         //first version
         originalDoc.__version = 1;
         //adding to history
-        return await ModelVersioning.addVersionToHistory(
-            originalDoc,
-            versionDoc
-        );
+        ModelVersioning.addVersionToHistory(originalDoc, versionDoc);
+        return await originalDoc.save();
     }
 
     /**
@@ -139,14 +141,14 @@ class ModelVersioning {
      * @param {MongooseModel} doc document to save
      * @return {Promise<MongooseDocument>}   current version with updated versions tags
      */
-    static saveDiff(doc) {
-        let data = doc.toObject(),
+    static saveDiff(ModelConstructor, doc) {
+        let data = toObject(doc),
             id = data._id;
         delete data._id;
         if (ModelVersioning.versionsHistoryExists(data)) {
-            return ModelVersioning.saveVersion(id, data, this);
+            return ModelVersioning.saveVersion(id, data, ModelConstructor);
         } else {
-            return ModelVersioning.saveFirstVersion(id, data, this);
+            return ModelVersioning.saveFirstVersion(id, data, ModelConstructor);
         }
     }
 
@@ -157,10 +159,10 @@ class ModelVersioning {
      * add _id of copy to list of document.__versions
      * and increment __version number
      **/
-    static version(id) {
-        return this.findById(id)
-            .exec()
-            .then(ModelVersioning.saveDiff.bind(this));
+    static async version(id) {
+        const ModelConstructor = this;
+        const original = await ModelConstructor.findOne({ _id: id });
+        return await ModelVersioning.saveDiff(ModelConstructor, original);
     }
 }