node-validation-engine/validation-engine.js at master · amaurigabriel/node-validation-engine · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
var Promise = require('Bluebird'),
    util = require('util');

validator = {};

validator.ValidatorException = require('./lib/ValidatorException.js');
validator.primary = 'id';

validator.validate = function validatorValidate(data){
  if (typeof this.rules === 'undefined'){
    return Promise.resolve();
  }
  else if (typeof data === 'undefined' || typeof data[this.primary] === 'undefined'){
    return this.validateOnCreate(data);
  }
  else{
    return this.validateOnUpdate(data);
  }
};

validator.validateOnCreate = function validatorValidateOnCreate (data){
  var promises = [],
    self = this;

  return new Promise(function(resolve, reject){

    require('async').each(self.rules, function(field, callback){
      var rules = field.rules,
          rules_length = rules.length;

      for (var i = 0; i < rules_length; i++){
        setImmediate(function(rule, field_name, data, i){
          if (typeof rule.on === 'undefined' || rule.on === 'create'){
            promises.push(self.validateRule(rule, field_name, data));
          }

          if (i === rules.length - 1){
            callback();
          }
        }, field.rules[i], field.field, data, i);
      }
    }, function(){
      Promise.all(promises).then(resolve).catch(reject);
    });
  });
};

validator.validateOnUpdate = function validatorValidateOnUpdate(data){
  var promises = [],
    self = this;

  return new Promise(function(resolve, reject){
    require('async').each(self.rules, function(field, callback){
      var rules = field.rules,
          rules_length = rules.length;

      for (var i = 0; i < rules_length; i++){
        setImmediate(function(rule, field_name, data, i){
          if (typeof rule.on === 'undefined' || rule.on === 'update'){
            promises.push(self.validateRule(rule, field_name, data));
          }

          if (i === rules.length - 1){
            callback();
          }
        }, field.rules[i], field.field, data, i);
      }
    }, function(err){
      Promise.all(promises).then(resolve).catch(reject);
    });
  });
};

validator.validateRule = function validatorValidateRule(rule, field_name, data){
  var rule_name;

  if (typeof rule === 'string'){
    rule_name = rule;
  }
  else{
    rule_name = rule.rule;
  }

  if (typeof this.validators[rule_name] === 'function'){
    return this.validators[rule_name](rule, field_name, data);
  }
  else{
    return new Promise(function(resolve, reject){
      reject(new Error('Validator for rule ' + rule_name + ' not found.'));
    });
  }
};

validator.rules = [];
validator.validators = require('./lib/validators.js');

validator.addValidator = function validatorAddValidator(rule_name, function_handler){
  validator.validators[rule_name] = function_handler;
};

module.exports = validator;