not-node 6.2.26 → 6.2.28

package/package.json

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

package/src/common.js

@@ -76,13 +76,17 @@ module.exports.getTodayDate = () => {
 /**
  *  Returns true if object has field of name
  *   @param   {object}    obj    some object
- *  @param  {string}    name  field name
+ *  @param  {string|Array<string>}    name  field name
  *  @return {boolean}          if object contains field with name
  **/
 const objHas = (obj, name) => {
     if (typeof obj === "undefined") return false;
     if (obj === null) return false;
-    return Object.prototype.hasOwnProperty.call(obj, name);
+    if (Array.isArray(name)) {
+        return name.every((itm) => typeof itm === "string" && objHas(obj, itm));
+    } else {
+        return Object.prototype.hasOwnProperty.call(obj, name);
+    }
 };
 module.exports.objHas = objHas;
 
@@ -362,3 +366,61 @@ const getValueFromEnv = (
     }
 };
 module.exports.getValueFromEnv = getValueFromEnv;
+
+/**
+ * Provides shallow object signature checks
+ *
+ * @param {object} obj                  object to check
+ * @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
+ * @return {boolean}                    true if object structured as signature
+ */
+const compareObjectSignatures = (
+    obj,
+    sign,
+    strict = true,
+    typeStrict = true
+) => {
+    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;
+            }
+        } else {
+            return false;
+        }
+    };
+
+    if (strict) {
+        if (objKeys.length === signKeys.length) {
+            return signKeys.every(checkKey);
+        } else {
+            return false;
+        }
+    } else {
+        return signKeys.every(checkKey);
+    }
+};
+
+module.exports.compareObjectSignatures = compareObjectSignatures;
+
+/**
+ * Returns first index of signature matching to object
+ *
+ * @param {object} obj                  object to match against signatures
+ * @param {Array<object>} signatures    array of signature
+ * @param {boolean} [strict=true]       check exact number of properties
+ * @param {boolean} [typeStrict=true]   check exact properties types
+ * @return {number}                     -1 if nothing is found, from 0 to signatures.length-1 if some signature
+ */
+const findSignature = (obj, signatures, strict = true, typeStrict = true) => {
+    return signatures.findIndex((sign) => {
+        return compareObjectSignatures(obj, sign, strict, typeStrict);
+    });
+};
+module.exports.findSignature = findSignature;

package/src/model/exceptions.js

@@ -1,4 +1,4 @@
-const { notError } = require("not-error");
+const notError = require("not-error/src/error.node");
 
 class VersioningExceptionSameOldData extends notError {
     constructor() {

package/src/model/increment.js

@@ -1,6 +1,6 @@
 /** @module Model/Increment */
 
-const { updateResponseSuccess } = require("./utils.js");
+const { updateResponseSuccess, insertResponseSuccess } = require("./utils.js");
 const {
     IncrementExceptionIDGeneratorRebaseFailed,
     IncrementExceptionIDGenerationFailed,
@@ -25,9 +25,9 @@ let schema = null;
 
 /**
  * Returns sub-list of fields which is not contained in object
- * @param {Array.string} fields  list of fields
+ * @param {Array<string>} fields  list of fields
  * @param {Object}       data    object to filter against
- * @return {Array.string}        sub-list of fields not contained in object
+ * @return {Array<string>}        sub-list of fields not contained in object
  **/
 function notContainedInData(fields, data) {
     let keys = Object.keys(data);
@@ -52,7 +52,7 @@ function formId(modelName, filterFields, data) {
 module.exports.formId = formId;
 /**
  * Some drivers versions work-arounds
- * @param  {Mongoose.Model} thisModel   counter model
+ * @param  {import('mongoose').Model} thisModel   counter model
  * @param  {Object}         which     filter object of update request
  * @param  {Object}         cmd          command object of update request
  * @param  {Object}         opts       options of request
@@ -76,9 +76,9 @@ function newGetNext() {
      * sub-set of all documents, which is grouped by fields (filterFields) with
      * same value
      * @param  {string}  modelName
-     * @param  {Array.string}  filterFields    list of fild names, which is used for grouping
+     * @param  {Array<string>}  filterFields    list of fild names, which is used for grouping
      * @param  {Object}  data                  item data
-     * @return {Promise.Number}
+     * @return {Promise<Number>}
      **/
     return async function (modelName, filterFields, data) {
         let thisModel = this;
@@ -105,7 +105,7 @@ function newGetNext() {
                 upsert: true,
             };
         const res = await secureUpdate(thisModel, which, cmd, opts);
-        if (updateResponseSuccess(res)) {
+        if (updateResponseSuccess(res) || insertResponseSuccess(res, 1)) {
             const doc = await thisModel.findOne({ id });
             return doc.seq;
         } else {
@@ -116,12 +116,12 @@ function newGetNext() {
 
 module.exports.newGetNext = newGetNext;
 
-/**
- * Sets new current ID for model
- * @param {string} modelName   name of target model
- * @param {number} ID          desired new start ID for model
- **/
 function newRebase() {
+    /**
+     * Sets new current ID for model
+     * @param {string} modelName   name of target model
+     * @param {number} ID          desired new start ID for model
+     **/
     return async function (modelName, ID) {
         let thisModel = this;
         let which = {

package/src/model/proto.js

@@ -73,11 +73,6 @@ module.exports = class ModelFabricate {
 
     static enrichByFields(targetModule, options) {
         if (targetModule.enrich) {
-            const model_name = targetModule.thisModelName;
-            console.log(
-                `MODEL: ${model_name}`,
-                JSON.stringify(options, null, 4)
-            );
             if (targetModule.enrich.validators) {
                 targetModule.thisSchema = enrich.byFieldsValidators(
                     targetModule.thisSchema,
@@ -198,9 +193,7 @@ module.exports = class ModelFabricate {
         if (ModelFabricate.isIgnored(targetModule)) {
             return;
         }
-
         options = ModelFabricate.initOptions(options, targetModule);
-
         const schema = ModelFabricate.extendSchema(targetModule, options);
         if (schema) {
             targetModule.mongooseSchema = schema;
@@ -211,7 +204,7 @@ module.exports = class ModelFabricate {
                     mongoose
                 );
             } catch (error) {
-                log.error(error);
+                log && log.error(error);
             }
         }
     }

package/src/model/utils.js

@@ -1,3 +1,29 @@
+const { findSignature } = require("../common");
+
+const INSERT_SIGNATURE = {
+    acknowledged: true,
+    modifiedCount: 0,
+    upsertedId: {},
+    upsertedCount: 1,
+    matchedCount: 0,
+};
+
+const SIGNATURES = {
+    INSERT: [INSERT_SIGNATURE],
+    UPDATE: [],
+    DELETE: [],
+};
+
+function insertResponseSuccess(res, count = 1) {
+    const ind = findSignature(res, SIGNATURES.INSERT);
+    if (ind === -1) {
+        return false;
+    }
+    return SIGNATURES.INSERT[ind].upsertedCount === count;
+}
+
+module.exports.insertResponseSuccess = insertResponseSuccess;
+
 /**
  * checking result of modification queries to ensure that changes were made
  */

package/src/model/versioning.js

@@ -65,9 +65,9 @@ class ModelVersioning {
 
     /**
      * Compares latest version in __versions list in data with data
-     * @param {MongooseModel}  ModelConstructor   model of data
+     * @param {import('mongoose').Model}  ModelConstructor   model of data
      * @param {Object}         data        data to save
-     * @return {boolean}                   if data differs from latest version
+     * @return {Promise<boolean>}                   if data differs from latest version
      */
     static async isNew(ModelConstructor, data) {
         let latestId = ModelVersioning.getLatestVersionId(data);
@@ -84,10 +84,10 @@ class ModelVersioning {
 
     /**
      * Saves current version to versions archive, updates current version versioning tags
-     * @param {ObjectId}      id             current version _id (just saved version)
+     * @param {import('mongoose').Types.ObjectId}      id             current version _id (just saved version)
      * @param {Object}      data             data to save
-     * @param {MongooseModel} ModelConstructor      model to use
-     * @return {Promise<MongooseDocument>}   current version with updated versioning tags
+     * @param {import('mongoose').Model} ModelConstructor      model to use
+     * @return {Promise<import('mongoose').Document>}   current version with updated versioning tags
      */
     static async saveVersion(id, data, ModelConstructor) {
         let preservedVersionNumber = ModelVersioning.extractVersionNumber(data),
@@ -112,10 +112,10 @@ class ModelVersioning {
 
     /**
      * Saves first version. Run AFTER doing .save() on document.
-     * @param {ObjectId}      id             current version _id (just saved version)
+     * @param {import('mongoose').Types.ObjectId}      id             current version _id (just saved version)
      * @param {Object}      data             data to save
-     * @param {MongooseModel} ModelConstructor      model to use
-     * @return {Promise<MongooseDocument>}   current version with updated versions tags
+     * @param {import('mongoose').Model} ModelConstructor      model to use
+     * @return {Promise<import('mongoose').Document>}   current version with updated versions tags
      */
     static async saveFirstVersion(id, data, ModelConstructor) {
         //it's not latest version, it's archived copy
@@ -138,8 +138,8 @@ class ModelVersioning {
      * Save document
      * if document is new - creates document
      * if it's updated document - updates document and versioning history
-     * @param {MongooseModel} doc document to save
-     * @return {Promise<MongooseDocument>}   current version with updated versions tags
+     * @param {import('mongoose').Model} doc document to save
+     * @return {Promise<import('mongoose').Document>}   current version with updated versions tags
      */
     static saveDiff(ModelConstructor, doc) {
         let data = toObject(doc),

package/test/common.js

@@ -1,151 +1,193 @@
-const expect = require('chai').expect,
-	mongoose = require('mongoose'),
-	path = require('path'),
-	ObjectId = mongoose.Types.ObjectId,
-	Common = require('../src/common');
-
-describe('Common', function() {
-	describe('firstLetterToLower', function() {
-		it('`Some error` -> `some error`', function() {
-			expect(Common.firstLetterToLower('Some error')).to.be.equal('some error');
-		});
-	});
-
-	describe('firstLetterToUpper', function() {
-		it('`some error` -> `Some error`', function() {
-			expect(Common.firstLetterToUpper('some error')).to.be.equal('Some error');
-		});
-	});
-
-	let testie = 'Иероним Босх';
-	describe(`validateObjectId, build in validator failed on ${testie}`, function() {
-
-		it(`Mongoose.Types.ObjectId.isValid('${testie}') -> true`, function(){
-			expect(ObjectId.isValid(testie)).to.be.ok;
-		});
-
-		it(`validateObjectId(${testie}) -> false`, function() {
-			expect(Common.validateObjectId(testie)).to.be.not.ok;
-		});
-
-		it('validateObjectId(`5af96abbce4adb46c5202ed3`) -> true', function() {
-			expect(Common.validateObjectId('5af96abbce4adb46c5202ed3')).to.be.ok;
-		});
-
-		it('validateObjectId(undefined) -> false', function() {
-			expect(Common.validateObjectId(undefined)).to.be.false;
-		});
-	});
-
-	describe('compareObjectIds', function() {
-		it('null and null -> false', function() {
-			expect(Common.compareObjectIds(null, null)).to.be.false;
-		});
-		it('1 and 1 -> false', function() {
-			expect(Common.compareObjectIds(1, 1)).to.be.false;
-		});
-		it('"1" and 1 -> false', function() {
-			expect(Common.compareObjectIds("1", 1)).to.be.false;
-		});
-	});
-
-
-	describe('getTodayDate', ()=>{
-		it('today', ()=>{
-			const res = Common.getTodayDate();
-			expect(typeof res).to.be.equal('number');
-		});
-	});
-	//
-	describe('executeObjectFunction', ()=>{
-		it('promise', async ()=>{
-			const obj = {
-				async method(...params){
-					return 'apple '+params.join('.');
-				}
-			}, name = 'method', params = [1,2,3,true];
-			const res = await Common.executeObjectFunction(obj, name, params);
-			expect(res).to.be.equal('apple 1.2.3.true');
-		});
-
-		it('function', async ()=>{
-			const obj = {
-				method(...params){
-					return 'apple '+params.join('.');
-				}
-			}, name = 'method', params = [1,2,3,true];
-			const res = await Common.executeObjectFunction(obj, name, params);
-			expect(res).to.be.equal('apple 1.2.3.true');
-		});
-
-		it('!obj', async ()=>{
-			const obj = null, name = 'method', params = [1,2,3,true];
-			const res = await Common.executeObjectFunction(obj, name, params);
-			expect(res).to.be.undefined;
-		});
-	});
-
-
-	describe('mapBind', function() {
-    it('to is undefined, exception throwned', function(done) {
-      let to = undefined;
-      try {
-        Common.mapBind({getModel(){}}, to, ['getModel']);
-				console.log(to);
-				done(new Error('should throw'))
-      } catch (e) {
-        expect(e).to.be.instanceof(Error);
-        done()
-      }
+const expect = require("chai").expect,
+    mongoose = require("mongoose"),
+    path = require("path"),
+    ObjectId = mongoose.Types.ObjectId,
+    Common = require("../src/common");
+
+describe("Common", function () {
+    describe("firstLetterToLower", function () {
+        it("`Some error` -> `some error`", function () {
+            expect(Common.firstLetterToLower("Some error")).to.be.equal(
+                "some error"
+            );
+        });
     });
 
-    it('list is empty', function() {
-      const to = {};
-      Common.mapBind({}, to, []);
-      expect(to).to.be.deep.equal({});
+    describe("firstLetterToUpper", function () {
+        it("`some error` -> `Some error`", function () {
+            expect(Common.firstLetterToUpper("some error")).to.be.equal(
+                "Some error"
+            );
+        });
     });
 
-    it('list item is not pointing to function', function() {
-      const to = {};
-      Common.mapBind({}, to, ['vasqa de gamma']);
-      expect(to).to.be.deep.equal({});
+    let testie = "Иероним Босх";
+    describe(`validateObjectId, build in validator failed on ${testie}`, function () {
+        it(`Mongoose.Types.ObjectId.isValid('${testie}') -> true`, function () {
+            expect(ObjectId.isValid(testie)).to.be.ok;
+        });
+
+        it(`validateObjectId(${testie}) -> false`, function () {
+            expect(Common.validateObjectId(testie)).to.be.not.ok;
+        });
+
+        it("validateObjectId(`5af96abbce4adb46c5202ed3`) -> true", function () {
+            expect(Common.validateObjectId("5af96abbce4adb46c5202ed3")).to.be
+                .ok;
+        });
+
+        it("validateObjectId(undefined) -> false", function () {
+            expect(Common.validateObjectId(undefined)).to.be.false;
+        });
+    });
+
+    describe("compareObjectIds", function () {
+        it("null and null -> false", function () {
+            expect(Common.compareObjectIds(null, null)).to.be.false;
+        });
+        it("1 and 1 -> false", function () {
+            expect(Common.compareObjectIds(1, 1)).to.be.false;
+        });
+        it('"1" and 1 -> false', function () {
+            expect(Common.compareObjectIds("1", 1)).to.be.false;
+        });
+    });
+
+    describe("getTodayDate", () => {
+        it("today", () => {
+            const res = Common.getTodayDate();
+            expect(typeof res).to.be.equal("number");
+        });
+    });
+    //
+    describe("executeObjectFunction", () => {
+        it("promise", async () => {
+            const obj = {
+                    async method(...params) {
+                        return "apple " + params.join(".");
+                    },
+                },
+                name = "method",
+                params = [1, 2, 3, true];
+            const res = await Common.executeObjectFunction(obj, name, params);
+            expect(res).to.be.equal("apple 1.2.3.true");
+        });
+
+        it("function", async () => {
+            const obj = {
+                    method(...params) {
+                        return "apple " + params.join(".");
+                    },
+                },
+                name = "method",
+                params = [1, 2, 3, true];
+            const res = await Common.executeObjectFunction(obj, name, params);
+            expect(res).to.be.equal("apple 1.2.3.true");
+        });
+
+        it("!obj", async () => {
+            const obj = null,
+                name = "method",
+                params = [1, 2, 3, true];
+            const res = await Common.executeObjectFunction(obj, name, params);
+            expect(res).to.be.undefined;
+        });
     });
-  });
-
-
-	describe('tryFile', function() {
-		const pathToExistingFile = path.join(__dirname, 'testies/module/fields/collection.js');
-		const pathToAbsentFile = path.join(__dirname, 'testies/module/fields/collection.ejs');
-		const pathToDirectory = path.join(__dirname, 'testies/module/fields/empty');
-
-		it('file exists, type file', function() {
-			const res = Common.tryFile(pathToExistingFile);
-			expect(res).to.be.equal(true);
-		});
-
-		it('file doesnt exist', function() {
-			const res = Common.tryFile(pathToAbsentFile);
-			expect(res).to.be.equal(false);
-		});
-
-		it('directory', function() {
-			const res = Common.tryFile(pathToDirectory);
-			expect(res).to.be.equal(false);
-		});
-	});
-
-	describe('copyObj', function () {
-		it('empty', function () {
-			let rule = {};
-			expect(Common.copyObj(rule)).to.be.deep.equal({});
-		});
-
-		it('not empty, then modification of new rule is not changes original', function () {
-			let rule = {some: ['data']};
-			let copyOfRule = Common.copyObj(rule);
-			delete copyOfRule.some;
-			expect(rule).to.be.deep.equal({some: ['data']});
-		});
-	});
 
+    describe("mapBind", function () {
+        it("to is undefined, exception throwned", function (done) {
+            let to = undefined;
+            try {
+                Common.mapBind({ getModel() {} }, to, ["getModel"]);
+                console.log(to);
+                done(new Error("should throw"));
+            } catch (e) {
+                expect(e).to.be.instanceof(Error);
+                done();
+            }
+        });
+
+        it("list is empty", function () {
+            const to = {};
+            Common.mapBind({}, to, []);
+            expect(to).to.be.deep.equal({});
+        });
+
+        it("list item is not pointing to function", function () {
+            const to = {};
+            Common.mapBind({}, to, ["vasqa de gamma"]);
+            expect(to).to.be.deep.equal({});
+        });
+    });
+
+    describe("tryFile", function () {
+        const pathToExistingFile = path.join(
+            __dirname,
+            "testies/module/fields/collection.js"
+        );
+        const pathToAbsentFile = path.join(
+            __dirname,
+            "testies/module/fields/collection.ejs"
+        );
+        const pathToDirectory = path.join(
+            __dirname,
+            "testies/module/fields/empty"
+        );
+
+        it("file exists, type file", function () {
+            const res = Common.tryFile(pathToExistingFile);
+            expect(res).to.be.equal(true);
+        });
+
+        it("file doesnt exist", function () {
+            const res = Common.tryFile(pathToAbsentFile);
+            expect(res).to.be.equal(false);
+        });
+
+        it("directory", function () {
+            const res = Common.tryFile(pathToDirectory);
+            expect(res).to.be.equal(false);
+        });
+    });
+
+    describe("copyObj", function () {
+        it("empty", function () {
+            let rule = {};
+            expect(Common.copyObj(rule)).to.be.deep.equal({});
+        });
+
+        it("not empty, then modification of new rule is not changes original", function () {
+            let rule = { some: ["data"] };
+            let copyOfRule = Common.copyObj(rule);
+            delete copyOfRule.some;
+            expect(rule).to.be.deep.equal({ some: ["data"] });
+        });
+    });
+
+    describe("objHas", () => {
+        it("one field, exists", () => {
+            const obj = { field: 1 };
+            expect(Common.objHas(obj, "field")).to.be.true;
+        });
+
+        it("one field, dont exists", () => {
+            const obj = { field: 1 };
+            expect(Common.objHas(obj, "field2")).to.be.false;
+        });
+
+        it("few fields, one dont exists", () => {
+            const obj = { field: 1, goo: true, joe: "foo" };
+            expect(Common.objHas(obj, ["field", "goo", "laste"])).to.be.false;
+        });
+
+        it("few fields, all exists", () => {
+            const obj = { field: 1, goo: true, joe: "foo" };
+            expect(Common.objHas(obj, ["field", "goo", "joe"])).to.be.true;
+        });
+
+        it("few fields, some names is not string", () => {
+            const obj = { field: 1, goo: true, joe: "foo" };
+            expect(Common.objHas(obj, [1, "goo", undefined])).to.be.false;
+        });
+    });
 });