not-node 6.2.27 → 6.3.0

package/package.json

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

package/src/common.js

@@ -366,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/init/lib/security.js

@@ -8,25 +8,26 @@ module.exports = class InitSecurity {
             let CSPDirectives = config.get("CSP");
             let result = {};
             Object.keys(CSPDirectives).forEach((nm) => {
-                result[nm + "Src"] = CSPDirectives[nm].join(" ");
-                if (["default", "connect"].includes(nm)) {
-                    result[nm + "Src"] += " " + corsLine;
+                result[nm] = [...CSPDirectives[nm]];
+                if (
+                    Array.isArray(corsArr) &&
+                    ["default-src", "connect-src"].includes(nm)
+                ) {
+                    result[nm].push(...corsLine);
                 }
             });
             return result;
         } catch (e) {
-            Log.error(e);
+            Log && Log.error(e);
             return {};
         }
     }
 
-    async run({ master, config, options }) {
+    async run({ master, config }) {
         //adding protection
         const helmet = require("helmet");
         const CSPDirectives = this.getCSPDirectives({
-            options,
             config,
-            master,
         });
         master.getServer().use(
             helmet({

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),