not-node 5.0.22 → 5.1.2

package/src/model/proto.js

@@ -1,173 +1,204 @@
 /** @module Model/Proto */
 
-const enrich = require('./enrich'),
-  saveVersion = require('./versioning').version,
-  { Schema } = require('mongoose'),
-  defaultModel= require('./default'),
-  log = require('not-log')(module, 'ModelProto');
-
-
-module.exports = class ModelFabricate{
-
-  static isIgnored(targetModule){
-    return targetModule.IGNORE;
-  }
-
-  static initOptions(options, targetModule){
-    if (!options) {
-      options = {
-        schemaOptions: {}
-      };
-    } else {
-      if (!options.schemaOptions) {
-        options.schemaOptions = {};
-      }
+const enrich = require("./enrich"),
+    saveVersion = require("./versioning").version,
+    { Schema } = require("mongoose"),
+    defaultModel = require("./default"),
+    log = require("not-log")(module, "ModelProto");
+
+module.exports = class ModelFabricate {
+    static isIgnored(targetModule) {
+        return targetModule.IGNORE;
     }
-    if (targetModule.schemaOptions) {
-      options.schemaOptions = targetModule.schemaOptions;
-    }
-    return options;
-  }
-
 
-  static isNotExtendable(targetModule){
-    return targetModule.keepNotExtended;
-  }
-
-  static extendSchemaFrom(src, dest){
-    if (src) {
-      for (let j in src) {
-        if (typeof src[j].get === 'function' && typeof src[j].set === 'function') {
-          dest(j).get(src[j].get).set(src[j].set);
+    static initOptions(options, targetModule) {
+        if (!options) {
+            options = {
+                schemaOptions: {},
+            };
         } else {
-          dest(j, src[j]);
+            if (!options.schemaOptions) {
+                options.schemaOptions = {};
+            }
+        }
+        if (targetModule.schemaOptions) {
+            options.schemaOptions = targetModule.schemaOptions;
         }
-      }
+        return options;
     }
-  }
 
-  static extendBySource(schema, targetModule){
-    if (targetModule.thisMethods) {
-      Object.assign(schema.methods, targetModule.thisMethods);
+    static isNotExtendable(targetModule) {
+        return targetModule.keepNotExtended;
     }
 
-    if (targetModule.thisStatics) {
-      Object.assign(schema.statics, targetModule.thisStatics);
+    static extendSchemaFrom(src, dest) {
+        if (src) {
+            for (let j in src) {
+                if (
+                    typeof src[j].get === "function" &&
+                    typeof src[j].set === "function"
+                ) {
+                    dest(j).get(src[j].get).set(src[j].set);
+                } else {
+                    dest(j, src[j]);
+                }
+            }
+        }
     }
-    this.extendSchemaFrom(targetModule.thisVirtuals, schema.virtual.bind(schema));
-    this.extendSchemaFrom(targetModule.thisPre, schema.pre.bind(schema));
-    this.extendSchemaFrom(targetModule.thisPost, schema.post.bind(schema));
-  }
-
-  static enrichByFields(targetModule, options){
-    if (targetModule.enrich) {
-      if (targetModule.enrich.validators) {
-        targetModule.thisSchema = enrich.byFieldsValidators(targetModule.thisSchema, options);
-      }
-      if (targetModule.enrich.versioning) {
-        targetModule.thisSchema = enrich.byFieldsForVersioning(targetModule.thisSchema, targetModule.thisModelName);
-      }
-      if (targetModule.enrich.increment) {
-        targetModule.thisSchema = enrich.byFieldsForIncrement(targetModule.thisSchema, targetModule.thisModelName);
-      }
+
+    static extendBySource(schema, targetModule) {
+        if (targetModule.thisMethods) {
+            Object.assign(schema.methods, targetModule.thisMethods);
+        }
+
+        if (targetModule.thisStatics) {
+            Object.assign(schema.statics, targetModule.thisStatics);
+        }
+        this.extendSchemaFrom(
+            targetModule.thisVirtuals,
+            schema.virtual.bind(schema)
+        );
+        this.extendSchemaFrom(targetModule.thisPre, schema.pre.bind(schema));
+        this.extendSchemaFrom(targetModule.thisPost, schema.post.bind(schema));
     }
-  }
-
-  static collectFieldsForIndexes(targetModule){
-    let fieldsForIndexes = [];
-    for(let fieldName in targetModule.thisSchema){
-      let field = targetModule.thisSchema[fieldName];
-      if (field.unique){
-        fieldsForIndexes.push(fieldName);
-        field.unique = false;
-      }
+
+    static enrichByFields(targetModule, options) {
+        if (targetModule.enrich) {
+            if (targetModule.enrich.validators) {
+                targetModule.thisSchema = enrich.byFieldsValidators(
+                    targetModule.thisSchema,
+                    options
+                );
+            }
+            if (targetModule.enrich.versioning) {
+                targetModule.thisSchema = enrich.byFieldsForVersioning(
+                    targetModule.thisSchema,
+                    targetModule.thisModelName
+                );
+            }
+            if (targetModule.enrich.increment) {
+                targetModule.thisSchema = enrich.byFieldsForIncrement(
+                    targetModule.thisSchema,
+                    targetModule.thisModelName
+                );
+            }
+        }
     }
-    return fieldsForIndexes;
-  }
 
+    static collectFieldsForIndexes(targetModule) {
+        let fieldsForIndexes = [];
+        for (let fieldName in targetModule.thisSchema) {
+            let field = targetModule.thisSchema[fieldName];
+            if (field.unique) {
+                fieldsForIndexes.push(fieldName);
+                field.unique = false;
+            }
+        }
+        return fieldsForIndexes;
+    }
 
-  static createIndexesForFields(schema, fieldsForIndexes){
-    for(let fieldName of fieldsForIndexes){
-      let rule = {__closed: 1, __latest: 1, _id: 1 };
-      rule[fieldName] = 1;
-      schema.index(rule, { unique: true });
+    static createIndexesForFields(schema, fieldsForIndexes) {
+        for (let fieldName of fieldsForIndexes) {
+            let rule = { __closed: 1, __latest: 1, _id: 1 };
+            rule[fieldName] = 1;
+            schema.index(rule, { unique: true });
+        }
     }
-  }
-
-  static createIndexesForText(schema, targetModule){
-    if(targetModule.enrich.textIndex){
-      schema.index(
-        targetModule.enrich.textIndex,
-        {
-          name: Object.keys(targetModule.enrich.textIndex).join('__')
+
+    static createIndexesForText(schema, targetModule) {
+        if (targetModule.enrich.textIndex) {
+            schema.index(targetModule.enrich.textIndex, {
+                name: Object.keys(targetModule.enrich.textIndex).join("__"),
+            });
         }
-      );
     }
-  }
-
-  static markFor(schema, targetModule){
-    if (targetModule.enrich) {
-      if (targetModule.enrich.increment) {
-        if(Object.prototype.hasOwnProperty.call(targetModule.enrich, 'incrementOptions')){
-          enrich.markForIncrement(schema, targetModule.thisModelName, targetModule.enrich.incrementOptions);
-        }else{
-          enrich.markForIncrement(schema, targetModule.thisModelName);
+
+    static markFor(schema, targetModule) {
+        if (targetModule.enrich) {
+            if (targetModule.enrich.increment) {
+                if (
+                    Object.prototype.hasOwnProperty.call(
+                        targetModule.enrich,
+                        "incrementOptions"
+                    )
+                ) {
+                    enrich.markForIncrement(
+                        schema,
+                        targetModule.thisModelName,
+                        targetModule.enrich.incrementOptions
+                    );
+                } else {
+                    enrich.markForIncrement(schema, targetModule.thisModelName);
+                }
+            }
+            if (targetModule.enrich.versioning) {
+                enrich.markForVersioning(schema);
+                schema.statics.saveVersion = saveVersion;
+            }
         }
-      }
-      if (targetModule.enrich.versioning) {
-        enrich.markForVersioning(schema);
-        schema.statics.saveVersion = saveVersion;
-      }
     }
-  }
-
-  static extendSchema(targetModule, options){
-    if (ModelFabricate.isNotExtendable(targetModule)) {
-      return new Schema(targetModule.thisSchema, options.schemaOptions);
-    } else {
-      ModelFabricate.enrichByFields(targetModule, options);
-      //collecting information of unique fields, removing unique flag from schema
-      let fieldsForIndexes = ModelFabricate.collectFieldsForIndexes(targetModule);
-      //creating schema for model
-      let schema = new Schema(targetModule.thisSchema, options.schemaOptions);
-      if(schema){
-        //creating unique indexes
-        ModelFabricate.createIndexesForFields(schema, fieldsForIndexes);
-        ModelFabricate.createIndexesForText(schema, targetModule);
-        //adding specific fields and indetificators
-        ModelFabricate.markFor(schema, targetModule);
-        //extending schema methods, statics, virtuals by user defined and default content
-        ModelFabricate.extendBySource(schema, targetModule);
-        ModelFabricate.extendBySource(schema, defaultModel);
-        return schema;
-      }else{
-        return false;
-      }
+
+    static extendSchema(targetModule, options) {
+        if (ModelFabricate.isNotExtendable(targetModule)) {
+            return new Schema(targetModule.thisSchema, options.schemaOptions);
+        } else {
+            ModelFabricate.enrichByFields(targetModule, options);
+            //collecting information of unique fields, removing unique flag from schema
+            let fieldsForIndexes =
+                ModelFabricate.collectFieldsForIndexes(targetModule);
+            //creating schema for model
+            let schema = new Schema(
+                targetModule.thisSchema,
+                options.schemaOptions
+            );
+            if (schema) {
+                //creating unique indexes
+                ModelFabricate.createIndexesForFields(schema, fieldsForIndexes);
+                ModelFabricate.createIndexesForText(schema, targetModule);
+                //adding specific fields and indetificators
+                ModelFabricate.markFor(schema, targetModule);
+                //extending schema methods, statics, virtuals by user defined and default content
+                ModelFabricate.extendBySource(schema, targetModule);
+                ModelFabricate.extendBySource(schema, defaultModel);
+                return schema;
+            } else {
+                return false;
+            }
+        }
     }
-  }
 
-  static initMongooseModel(targetModule, schema, mongoose){
-    if (mongoose.modelNames().indexOf(targetModule.thisModelName)===-1){
-      targetModule[targetModule.thisModelName] = mongoose.model(targetModule.thisModelName, schema);
-    }else{
-      targetModule[targetModule.thisModelName] = mongoose.connection.model(targetModule.thisModelName);
+    static initMongooseModel(targetModule, schema, mongoose) {
+        if (mongoose.modelNames().indexOf(targetModule.thisModelName) === -1) {
+            targetModule[targetModule.thisModelName] = mongoose.model(
+                targetModule.thisModelName,
+                schema
+            );
+        } else {
+            targetModule[targetModule.thisModelName] =
+                mongoose.connection.model(targetModule.thisModelName);
+        }
+        targetModule[targetModule.thisModelName].createIndexes();
     }
-    targetModule[targetModule.thisModelName].createIndexes();
-  }
-
-  static fabricate(targetModule, options, mongoose) {
-    if(ModelFabricate.isIgnored(targetModule)){ return; }
-
-    options = ModelFabricate.initOptions(options, targetModule);
-
-    const schema = ModelFabricate.extendSchema(targetModule, options);
-    if(schema){
-      targetModule.mongooseSchema = schema;
-      try {
-        ModelFabricate.initMongooseModel(targetModule, schema, mongoose);
-      } catch (error) {
-        log.error(error);
-      }
+
+    static fabricate(targetModule, options, mongoose) {
+        if (ModelFabricate.isIgnored(targetModule)) {
+            return;
+        }
+
+        options = ModelFabricate.initOptions(options, targetModule);
+
+        const schema = ModelFabricate.extendSchema(targetModule, options);
+        if (schema) {
+            targetModule.mongooseSchema = schema;
+            try {
+                ModelFabricate.initMongooseModel(
+                    targetModule,
+                    schema,
+                    mongoose
+                );
+            } catch (error) {
+                log.error(error);
+            }
+        }
     }
-  }
 };

package/src/model/routine.js

@@ -1,95 +1,104 @@
 /** @module Model/Routine */
 
-const incrementNext = require('./increment');
+const incrementNext = require("./increment");
 
-class ModelRoutine{
-
-  static incremental(model){
-    return model.schema.statics.__incField;
-  }
-
-  static versioning(model){
-    return model.schema.statics.__versioning;
-  }
+class ModelRoutine {
+    static incremental(model) {
+        return model.schema.statics.__incField;
+    }
 
-  static addWithoutVersion(model, data) {
-    return (new model(data)).save();
-  }
+    static versioning(model) {
+        return model.schema.statics.__versioning;
+    }
 
-  static async addWithVersion(model, data) {
-    data.__latest = true;
-    const item = await (new model(data)).save();
-    return await model.saveVersion(item._id);
-  }
+    static addWithoutVersion(model, data) {
+        return new model(data).save();
+    }
 
-  static async add(model, data) {
-    if (ModelRoutine.incremental(model)) {
-      const modelID = await incrementNext.next(model.__incModel, model.__incFilter, data);
-      data[model.__incField] = modelID;
-      if (ModelRoutine.versioning(model)) {
-        return await ModelRoutine.addWithVersion(model, data);
-      } else {
-        return await ModelRoutine.addWithoutVersion(model, data);
-      }
-    } else {
-      if (ModelRoutine.versioning(model)) {
-        return await ModelRoutine.addWithVersion(model, data);
-      } else {
-        return await ModelRoutine.addWithoutVersion(model, data);
-      }
+    static async addWithVersion(model, data) {
+        data.__latest = true;
+        const item = await new model(data).save();
+        return await model.saveVersion(item._id);
     }
-  }
 
-  static async update(model, filter, data){
-    if (ModelRoutine.versioning(model)) {
-      return ModelRoutine.updateWithVersion(model, filter, data);
-    } else {
-      return ModelRoutine.updateWithoutVersion(model, filter, data);
+    static async add(model, data) {
+        if (ModelRoutine.incremental(model)) {
+            const modelID = await incrementNext.next(
+                model.__incModel,
+                model.__incFilter,
+                data
+            );
+            data[model.__incField] = modelID;
+            if (ModelRoutine.versioning(model)) {
+                return await ModelRoutine.addWithVersion(model, data);
+            } else {
+                return await ModelRoutine.addWithoutVersion(model, data);
+            }
+        } else {
+            if (ModelRoutine.versioning(model)) {
+                return await ModelRoutine.addWithVersion(model, data);
+            } else {
+                return await ModelRoutine.addWithoutVersion(model, data);
+            }
+        }
     }
-  }
 
-  static updateWithoutVersion(model, filter, data) {
-    return model.findOneAndUpdate(
-      filter,
-      data,
-      {returnOriginal: false,  new: true}
-    ).exec();
-  }
+    static async update(model, filter, data) {
+        if (ModelRoutine.versioning(model)) {
+            return ModelRoutine.updateWithVersion(model, filter, data);
+        } else {
+            return ModelRoutine.updateWithoutVersion(model, filter, data);
+        }
+    }
 
-  static async updateWithVersion(model, filter, data) {
-    filter.__latest = true;
-    filter.__closed = false;
-    const item = await model.findOneAndUpdate(filter, data, {returnOriginal: false}).exec();
-    return model.saveVersion(item._id);
-  }
+    static updateWithoutVersion(model, filter, data) {
+        return model
+            .findOneAndUpdate(filter, data, {
+                returnOriginal: false,
+                new: true,
+            })
+            .exec();
+    }
 
-  static async updateMany(model, filter, data){
-    if (ModelRoutine.versioning(model)) {
-      return ModelRoutine.updateManyWithVersion(model, filter, data);
-    } else {
-      return ModelRoutine.updateManyWithoutVersion(model, filter, data);
+    static async updateWithVersion(model, filter, data) {
+        filter.__latest = true;
+        filter.__closed = false;
+        const item = await model
+            .findOneAndUpdate(filter, data, { returnOriginal: false })
+            .exec();
+        return model.saveVersion(item._id);
     }
-  }
 
-  static updateManyWithoutVersion(model, filter, data) {
-    return model.updateMany(
-      filter,
-      data
-    );
-  }
+    static async updateMany(model, filter, data) {
+        if (ModelRoutine.versioning(model)) {
+            return ModelRoutine.updateManyWithVersion(model, filter, data);
+        } else {
+            return ModelRoutine.updateManyWithoutVersion(model, filter, data);
+        }
+    }
 
-  static async updateManyWithVersion(model, filter, data) {
-    let list = await model.find({
-      __closed: false,
-      __latest: true,
-      ...filter
-    }).exec();
-    return await Promise.allSettled(list.map((item) => {
-      return ModelRoutine.updateWithVersion(model, {_id: item._id }, data);
-    }));
-  }
+    static updateManyWithoutVersion(model, filter, data) {
+        return model.updateMany(filter, data);
+    }
 
+    static async updateManyWithVersion(model, filter, data) {
+        const list = await model
+            .find({
+                __closed: false,
+                __latest: true,
+                ...filter,
+            })
+            .exec();
+        return await Promise.allSettled(
+            list.map((item) => {
+                return ModelRoutine.updateWithVersion(
+                    model,
+                    { _id: item._id },
+                    data
+                );
+            })
+        );
+    }
 }
 
-
 module.exports = ModelRoutine;

package/src/model/utils.js

@@ -0,0 +1,33 @@
+/**
+ * checking result of modification queries to ensure that changes were made
+ */
+function updateResponseSuccess(res, count = 1) {
+    if (res) {
+        const responseList = Object.keys(res);
+        if (responseList.includes("ok")) {
+            return res.ok === 1 && res.n === count;
+        } else {
+            return res.matchedCount === count && res.modifiedCount === count;
+        }
+    } else {
+        return false;
+    }
+}
+module.exports.updateResponseSuccess = updateResponseSuccess;
+
+/**
+ * checking result of modification queries to ensure that changes were made
+ */
+function deleteResponseSuccess(res, count = 1) {
+    if (res) {
+        const responseList = Object.keys(res);
+        if (responseList.includes("ok")) {
+            return res.ok === 1 && res.n === count;
+        } else {
+            return res.deletedCount === count;
+        }
+    } else {
+        return false;
+    }
+}
+module.exports.deleteResponseSuccess = deleteResponseSuccess;