not-node 5.0.22 → 5.1.2

package/src/model/enrich.js

@@ -1,74 +1,82 @@
 /** @module Model/Enrich */
-const
-  Schema = require('mongoose').Schema,
-  {firstLetterToLower,isFunc, objHas} = require('../common'),
-  buildValidator = require('./buildValidator');
+const Schema = require("mongoose").Schema,
+    { firstLetterToLower, isFunc, objHas } = require("../common"),
+    buildValidator = require("./buildValidator");
 
-class ModelEnricher{
-  static getIncrementalFieldName(modelName) {
-    return firstLetterToLower(modelName) + 'ID';
-  }
+class ModelEnricher {
+    static getIncrementalFieldName(modelName) {
+        return firstLetterToLower(modelName) + "ID";
+    }
 
-  static byFieldsForVersioning(objectSchema, modelName) {
-    objectSchema.__version = {
-      type: Number,
-      required: true,
-      default: 0
-    };
-    objectSchema.__latest = {
-      type: Boolean,
-      required: true,
-      default: 0
-    };
-    objectSchema.__versions = [{
-      type: Schema.Types.ObjectId,
-      required: false,
-      ref: modelName,
-      default: []
-    }];
-    objectSchema.__closed = {
-      type: Boolean,
-      required: true,
-      default: false
-    };
-    return objectSchema;
-  }
+    static byFieldsForVersioning(objectSchema, modelName) {
+        objectSchema.__version = {
+            type: Number,
+            required: true,
+            default: 0,
+        };
+        objectSchema.__latest = {
+            type: Boolean,
+            required: true,
+            default: 0,
+        };
+        objectSchema.__versions = [
+            {
+                type: Schema.Types.ObjectId,
+                required: false,
+                ref: modelName,
+                default: [],
+            },
+        ];
+        objectSchema.__closed = {
+            type: Boolean,
+            required: true,
+            default: false,
+        };
+        return objectSchema;
+    }
 
-  static byFieldsForIncrement(objectSchema, modelName) {
-    objectSchema[this.getIncrementalFieldName(modelName)] = {
-      type: Number,
-      required: true,
-      searchable: true,
-      sortable: true
-    };
-    return objectSchema;
-  }
+    static byFieldsForIncrement(objectSchema, modelName) {
+        objectSchema[this.getIncrementalFieldName(modelName)] = {
+            type: Number,
+            required: true,
+            searchable: true,
+            sortable: true,
+        };
+        return objectSchema;
+    }
 
-  static markForIncrement(mongooseSchema, modelName, options) {
-    mongooseSchema.statics.__incField = this.getIncrementalFieldName(modelName);
-    mongooseSchema.statics.__incModel = modelName;
-    if(options && options.filter){
-      mongooseSchema.statics.__incFilter = options.filter;
+    static markForIncrement(mongooseSchema, modelName, options) {
+        mongooseSchema.statics.__incField =
+            this.getIncrementalFieldName(modelName);
+        mongooseSchema.statics.__incModel = modelName;
+        if (options && options.filter) {
+            mongooseSchema.statics.__incFilter = options.filter;
+        }
+        return mongooseSchema;
     }
-    return mongooseSchema;
-  }
 
-  static markForVersioning(mongooseSchema) {
-    mongooseSchema.statics.__versioning = true;
-    return mongooseSchema;
-  }
+    static markForVersioning(mongooseSchema) {
+        mongooseSchema.statics.__versioning = true;
+        return mongooseSchema;
+    }
 
-  static byFieldsValidators (mongooseSchema, options) {
-    if (mongooseSchema) {
-      for (let fieldName in mongooseSchema) {
-        if (objHas(mongooseSchema[fieldName], 'validate') && mongooseSchema[fieldName].validate.length && !isFunc(mongooseSchema[fieldName].validate[0])) {
-          mongooseSchema[fieldName].validate = buildValidator(mongooseSchema[fieldName].validate, options);
+    static byFieldsValidators(mongooseSchema, options) {
+        if (mongooseSchema) {
+            for (let fieldName in mongooseSchema) {
+                if (
+                    objHas(mongooseSchema[fieldName], "validate") &&
+                    mongooseSchema[fieldName].validate.length &&
+                    !isFunc(mongooseSchema[fieldName].validate[0])
+                ) {
+                    mongooseSchema[fieldName].validate = buildValidator(
+                        mongooseSchema[fieldName].validate,
+                        options
+                    );
+                }
+            }
         }
-      }
+        return mongooseSchema;
     }
-    return mongooseSchema;
-  }
 }
 
-
 module.exports = ModelEnricher;

package/src/model/increment.js

@@ -1,173 +1,160 @@
 /** @module Model/Increment */
 
-
+const { updateResponseSuccess } = require("./utils.js");
 
 const thisSchema = {
-  id: {
-    type: String,
-    unique: true,
-    required: true
-  },
-  seq: {
-    type: Number,
-    default: 0,
-    required: true
-  }
+    id: {
+        type: String,
+        unique: true,
+        required: true,
+    },
+    seq: {
+        type: Number,
+        default: 0,
+        required: true,
+    },
 };
 
 let mongooseLocal = null;
 let schema = null;
 
 /**
-* Returns sub-list of fields which is not contained in object
-* @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
-**/
-function notContainedInData(fields, data){
-  let keys = Object.keys(data);
-  return fields.filter((field)=>{
-    return !keys.includes(field);
-  });
+ * Returns sub-list of fields which is not contained in object
+ * @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
+ **/
+function notContainedInData(fields, data) {
+    let keys = Object.keys(data);
+    return fields.filter((field) => {
+        return !keys.includes(field);
+    });
 }
 
 module.exports.notContainedInData = notContainedInData;
 
 /**
-*
-**/
-function formId(modelName, filterFields, data){
-  let idParts = [
-    modelName,
-    ...filterFields.map( field => data[field].toString() )
-  ];
-  return idParts.join('_');
+ *
+ **/
+function formId(modelName, filterFields, data) {
+    let idParts = [
+        modelName,
+        ...filterFields.map((field) => data[field].toString()),
+    ];
+    return idParts.join("_");
 }
 
 module.exports.formId = formId;
 /**
-* Some drivers versions work-arounds
-* @param  {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
-**/
-function secureUpdate(thisModel, which, cmd, opts){
-  if (typeof thisModel.updateOne === 'function') {
-    return thisModel.updateOne(which, cmd, opts).exec();
-  } else {
-    return thisModel.update(which, cmd, opts).exec();
-  }
+ * Some drivers versions work-arounds
+ * @param  {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
+ **/
+function secureUpdate(thisModel, which, cmd, opts) {
+    if (typeof thisModel.updateOne === "function") {
+        return thisModel.updateOne(which, cmd, opts).exec();
+    } else {
+        return thisModel.update(which, cmd, opts).exec();
+    }
 }
 
 module.exports.secureUpdate = secureUpdate;
 
-function updateResponseSuccess(res){
-  if(res){
-    const responseList = Object.keys(res);
-    if(responseList.includes('ok')){
-      return (res.ok === 1 && res.n === 1);
-    }else{
-      return (res.matchedCount === 1 && res.modifiedCount === 1);
-    }
-  }else{
-    return false;
-  }
-}
-
 /**
-* Generate new ID for current model and filterFields
-**/
+ * Generate new ID for current model and filterFields
+ **/
 function newGetNext() {
-  /**
-  * Generates next ID for modelName with additional possibility to index only in
-  * 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  {Object}  data                  item data
-  * @return {Promise.Number}
-  **/
-  return async function(modelName, filterFields, data) {
-    let thisModel = this;
-    let id = modelName;
-    if(Array.isArray(filterFields)){
-      //if we miss fields in data for grouping
-      let miss = notContainedInData(filterFields, data);
-      if(miss.length === 0){
-        id = formId(modelName, filterFields, data);
-      }else{
-        throw new Error('Fields not exist in data object: ' + miss.join(', '));
-      }
-    }
-    let which = {
-        id
-      },
-      cmd = {
-        $inc: {
-          seq: 1
+    /**
+     * Generates next ID for modelName with additional possibility to index only in
+     * 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  {Object}  data                  item data
+     * @return {Promise.Number}
+     **/
+    return async function (modelName, filterFields, data) {
+        let thisModel = this;
+        let id = modelName;
+        if (Array.isArray(filterFields)) {
+            //if we miss fields in data for grouping
+            let miss = notContainedInData(filterFields, data);
+            if (miss.length === 0) {
+                id = formId(modelName, filterFields, data);
+            } else {
+                throw new Error(
+                    "Fields not exist in data object: " + miss.join(", ")
+                );
+            }
         }
-      },
-      opts = {
-        new: true,
-        upsert: true
-      };
-    const res = await secureUpdate(thisModel, which, cmd, opts);
-    if(updateResponseSuccess(res)){
-      const doc = await thisModel.findOne({id});
-      return doc.seq;
-    }else{
-      throw new Error('ID generation failed');
-    }
-  };
+        let which = {
+                id,
+            },
+            cmd = {
+                $inc: {
+                    seq: 1,
+                },
+            },
+            opts = {
+                new: true,
+                upsert: true,
+            };
+        const res = await secureUpdate(thisModel, which, cmd, opts);
+        if (updateResponseSuccess(res)) {
+            const doc = await thisModel.findOne({ id });
+            return doc.seq;
+        } else {
+            throw new Error("ID generation failed");
+        }
+    };
 }
 
 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(){
-  return async function(modelName, ID) {
-    let thisModel = this;
-    let which = {
-        id: modelName
-      },
-      cmd = {
-        seq: ID
-      },
-      opts = {
-        new: true,
-        upsert: true
-      };
-    //updating
-    let res = await secureUpdate(thisModel, which, cmd, opts);
-    if(updateResponseSuccess(res)){
-      return ID;
-    }else{
-      throw new Error('ID generator rebase failed');
-    }
-  };
+ * Sets new current ID for model
+ * @param {string} modelName   name of target model
+ * @param {number} ID          desired new start ID for model
+ **/
+function newRebase() {
+    return async function (modelName, ID) {
+        let thisModel = this;
+        let which = {
+                id: modelName,
+            },
+            cmd = {
+                seq: ID,
+            },
+            opts = {
+                new: true,
+                upsert: true,
+            };
+        //updating
+        let res = await secureUpdate(thisModel, which, cmd, opts);
+        if (updateResponseSuccess(res)) {
+            return ID;
+        } else {
+            throw new Error("ID generator rebase failed");
+        }
+    };
 }
 
 module.exports.newRebase = newRebase;
 
-module.exports.init = function(mongoose) {
-  mongooseLocal = mongoose;
-  schema = new(mongooseLocal.Schema)(thisSchema);
-  schema.statics.getNext = newGetNext();
-  schema.statics.rebase = newRebase();
-  let model = null;
-  try {
-    model = mongooseLocal.model('Increment', schema);
-  }catch{
-    model = mongooseLocal.model('Increment');
-  }
-  module.exports.model = model;
-  module.exports.next = model.getNext.bind(model);
-  module.exports.rebase = model.rebase.bind(model);
+module.exports.init = function (mongoose) {
+    mongooseLocal = mongoose;
+    schema = new mongooseLocal.Schema(thisSchema);
+    schema.statics.getNext = newGetNext();
+    schema.statics.rebase = newRebase();
+    let model = null;
+    try {
+        model = mongooseLocal.model("Increment", schema);
+    } catch {
+        model = mongooseLocal.model("Increment");
+    }
+    module.exports.model = model;
+    module.exports.next = model.getNext.bind(model);
+    module.exports.rebase = model.rebase.bind(model);
 };