/**
 * @param {string} name 
 * @param {number} age 
 */
function login(name, age) {
  // logic
}

let Violate = require('violations').Violate;
 
let rule = {
  name: (val) => {
    if (val === undefined) {
      return 'name is required';
    }
  },
  age: (val) => {
    if (val === undefined) {
      return 'age is required';
    }
 
    if (val < 0) {
      return 'name should larger than 0';
    }
  }
}
 
let validator = new Violate(rule);

/**
 * @param {string} name 
 * @param {number} age 
 */
function login(name, age) {
  validator.assert({ name: name, age: age });
 
  // logic
}

function main() {
  let name = input.params.name;
  let age = input.params.age;
 
 
  let violations = validator.validate({ name: name, age: age });
  if (violations) {
    violations.forEach((message) => {
      user.feedback(message);
    });
 
    return;
  }
 
  login(name, age);
}

let rule = {
  param: (val, name, _) => {
    if (_.isUndefined(value)) {
      return `${name} is required`;
    }
  }
}

let rule = {
  param: (val, name, _) => {
    if (_.isUndefined(value)) {
      return `${name} is required`;
    }
  }
}
 
let violations = (new Violate(rule)).validate({ param: undefined });
cosnole.log(violations); // [ 'param is required' ]

let rule = {
  param: (val, name, _) => {
    let messages = [];
    if (value.length < 10) {
      messages.push(`${name} should longer than 10`);
    }
 
    if (value.match(/[0-9]*/)) {
      messages.push(`${name} should contain number`);
    }
  }
}
 
let violations = (new Violate(rule)).validate({ param: 'aaa' });
cosnole.log(violations); // [ 'param should longer than 10', 'param should contain number' ]

let rule = {
  param: (val, name, _) => {
    if (_.isUndefined(value)) {
      return `${name} is required`;
    }
  }
}
 
let violations = (new Violate(rule)).validate({ param: 'a' });
cosnole.log(violations); // undefined

let rule = {
  param: (val, name, _) => {
    if (_.isUndefined(value)) {
      return; // optional
    }
  }
}

let target = {
  a: 'a',
  b: {
    c: 'c',
    d: 'd'
  }
};
 
let rules = {
  a: (v) => {
    if (v !== 'a') return 'a should "a"';
  },
  b: {
    // nested
    c: (v) => {
      if (v !== 'c') return 'c should "c"';
    },
    d: (v) => {
      if (v !== 'd') return 'd should "d"';
    }
  }
}