Adding functionality to allow duplicate entries

when validating an array of ID values (GitHub issue #12).

Bumped version for release

Author: martin-css

README.md

@@ -129,6 +129,16 @@ Model.plugin(id-validator, {
    * Defaults to built-in mongoose connection if not specified.
    */
   connection: myConnection
+  
+  /* Applies to validation of arrays of ID references only. Set
+   * to true if you sometimes have the same object ID reference
+   * repeated in an array. If set, the validator will use the
+   * total of unique ID references instead of total number of array
+   * entries when checking the database.
+   *
+   * Defaults to false
+   */
+  allowDuplicates: true
 });
 ```
 

lib/id-validator.js

@@ -1,30 +1,31 @@
 var mongoose = require('mongoose');
 var Schema = mongoose.Schema;
 
-function IdValidator(){
+function IdValidator() {
     this.enabled = true;
 }
 
-IdValidator.prototype.enable = function(){
+IdValidator.prototype.enable = function () {
     this.enabled = true;
 }
 
-IdValidator.prototype.disable = function(){
+IdValidator.prototype.disable = function () {
     this.enabled = false;
 }
 
-IdValidator.prototype.validate = function(schema, options){
+IdValidator.prototype.validate = function (schema, options) {
     var self = this;
     options = options || {};
     var message = options.message || "{PATH} references a non existing ID";
     var connection = options.connection || mongoose;
+    var allowDuplicates = options.allowDuplicates || false;
 
     var caller = (self instanceof IdValidator) ? self : IdValidator.prototype;
 
-    return caller.validateSchema(schema, message, connection);
+    return caller.validateSchema(schema, message, connection, allowDuplicates);
 }
 
-IdValidator.prototype.validateSchema = function(schema, message, connection) {
+IdValidator.prototype.validateSchema = function (schema, message, connection, allowDuplicates) {
     var self = this;
     var caller = (self instanceof IdValidator) ? self : IdValidator.prototype;
     schema.eachPath(function (path, schemaType) {
@@ -54,15 +55,15 @@ IdValidator.prototype.validateSchema = function(schema, message, connection) {
 
         if (validateFunction) {
             schema.path(path).validate(function (value, respond) {
-                if(!(self instanceof IdValidator) || self.enabled){
-                    return validateFunction(this, connection, refModelName, value, conditions, respond);
+                if (!(self instanceof IdValidator) || self.enabled) {
+                    return validateFunction(this, connection, refModelName, value, conditions, respond, allowDuplicates);
                 }
                 return respond(true);
             }, message);
         }
 
     });
-}
+};
 
 function executeQuery(query, conditions, validateValue, respond) {
     for (var fieldName in conditions) {
@@ -85,13 +86,22 @@ function validateId(doc, connection, refModelName, value, conditions, respond) {
     executeQuery(query, conditions, 1, respond);
 }
 
-function validateIdArray(doc, connection, refModelName, values, conditions, respond) {
+function validateIdArray(doc, connection, refModelName, values, conditions, respond, allowDuplicates) {
     if (values == null || values.length == 0) {
         return respond(true);
     }
+
+    var checkValues = values;
+    if (allowDuplicates) {
+        //Extract unique values only
+        checkValues = values.filter(function (v, i) {
+            return values.indexOf(v) === i
+        });
+    }
+
     var refModel = connection.model(refModelName);
-    var query = refModel.count().where('_id')['in'](values);
-    executeQuery(query, conditions, values.length, respond);
+    var query = refModel.count().where('_id')['in'](checkValues);
+    executeQuery(query, conditions, checkValues.length, respond);
 }
 
 module.exports = IdValidator.prototype.validate;

package.json

@@ -1,6 +1,6 @@
 {
     "name": "mongoose-id-validator",
-    "version": "0.1.10",
+    "version": "0.2.0",
     "description": "Mongoose plugin to validate that ObjectID references refer to objects that actually exist in the referenced collection",
     "author": {
         "name": "Martin Campbell",
@@ -32,7 +32,7 @@
         "test": "./node_modules/.bin/mocha -R spec"
     },
     "devDependencies": {
-        "mongoose": "~3.8.0",
+        "mongoose": "*",
         "async": "~0.2.9",
         "should": "~3.0.1",
         "mocha": "^2.2.1"

test/id-validator.js

@@ -12,16 +12,16 @@ if (process.env.MONGO_PORT_27017_TCP_PORT) {
 }
 var connection2;
 
-function validatorConcept(schema){
+function validatorConcept(schema) {
 
     var idvalidator = new IdValidator();
     schema.plugin(IdValidator.prototype.validate.bind(idvalidator));
 
-    schema.statics.enableValidation = function(){
+    schema.statics.enableValidation = function () {
         idvalidator.enable();
     }
 
-    schema.statics.disableValidation = function(){
+    schema.statics.disableValidation = function () {
         idvalidator.disable();
     }
 }
@@ -351,7 +351,59 @@ describe('mongoose-id-validator Integration Tests', function () {
                 err.errors.should.property('femaleFriends');
                 done();
             });
-        })
+        });
+    });
+
+    describe('Array Duplicate Tests', function () {
+
+        var InventoryItemSchema = new Schema({
+            name: String
+        });
+
+        function createInventorySchema(options) {
+            var s = new Schema({
+                items: [
+                    {
+                        type: Schema.Types.ObjectId,
+                        ref: 'InventoryItem'
+                    }
+                ]
+            });
+            s.plugin(validator, options);
+            return s;
+        }
+
+        var InventoryNoDuplicatesSchema = createInventorySchema();
+        var InventoryDuplicatesSchema = createInventorySchema({
+            allowDuplicates: true
+        });
+
+
+        var InventoryItem = mongoose.model('InventoryItem', InventoryItemSchema);
+        var InventoryNoDuplicates = mongoose.model('InventoryNoDuplicates', InventoryNoDuplicatesSchema);
+        var InventoryDuplicates = mongoose.model('InventoryDuplicatesSchema', InventoryDuplicatesSchema);
+
+        var item1 = new InventoryItem({name: 'Widgets'});
+
+        before(function (done) {
+            async.series([
+                item1.save.bind(item1)
+            ], done);
+        });
+
+        it('Should fail to validate duplicate entries with default option', function (done) {
+            var i = new InventoryNoDuplicates({items: [item1, item1]});
+            i.validate(function (err) {
+                err.should.property('name', 'ValidationError');
+                err.errors.should.property('items');
+                done();
+            });
+        });
+
+        it('Should pass validation of duplicate entries when allowDuplicates set', function (done) {
+            var i = new InventoryDuplicates({items: [item1, item1]});
+            i.validate(done);
+        });
 
     });