README
Introduction
Validator Framework, write once and use anywhere.
Install
$ npm install vfw
Demo
var vfw = require('vfw')
// check object
var ruleSet = vfw.parse({
a: 'String:required',
b: 'Money'
})
ruleSet.check({a: 'as', b: 99}) // => true
ruleSet.check({a: 12, b: 'x.x'}) // => false
// check array
ruleSet = vfw.parse(['String', 'Moeny'])
ruleSet.check(['as',99]) // => true
ruleSet.check([123, 'x.x']) // => false
// check multidimensional array
ruleSet = vfw.parse({
$array: {
$array: 'String'
}
})
ruleSet.check([['as'], ['ds']]) // => true
// your can parse and check any js object
ruleSet = vfw.parse({
a: {
b: 'String'
c: ['Method', 'Url']
}
})
ruleSet.check({a: {b: 'as', c: ['get', 'http://github.com']}})
// with logic element, $and ,$or and $xor is supported, and your can extend more
ruleSet = vfw.parse({
$or: {
a: 'String',
b: 'Moeny'
}
})
ruleSet.check({a: 'as'}) // => true
ruleSet.check({a: 23, b: 12.2}) // => true
// with expression
ruleSet = vfw.parse({
a: {
$eq: 1
}
})
ruleSet.check({a: 1}) // => 1
// use without parse api
vfw.type('String', 'as') // => true
var a = 1
vfw.expression('eq', a, 1) // => true
// $ is short for expression
vfw.$('eq', a, 1) // => true
// everything in vfw is extendable
// extend your own type
vfw.extend('type', {
Word: function (str) {
return /^\w+$/.test(str)
}
})
vfw.type('Word', 'azAZ_09') // => true
ruleSet = vfw.parse({a: 'Word'})
ruleSet.check({a: 'azAZ_09'}) // => true
// extend your own expression
vfw.extend('expression', {
$gt: function (str, len) {
return str && str.length > len
}
})
var b = [1, 2]
vfw.$('gt', b, 1) // => true
ruleSet = vfw.parse({a: {$gt: 2}})
ruleSet.check({a: 'aas'}) // => true
// extend your own struct
vfw.extend('struct', 'User', {
name: 'Word:required',
// 类型 Word 长度 小于等于6
password: {
$type: 'Word',
$lte: 6
}
})
vfw.struct('User', {name: 'asd_123', password: 'asd_as'}) // => true
vfw.struct('User', {name: 'asd_123', password: 'asd_as123'}) // => false
vfw.struct('User', {password: 'ass123'}) // => false
API
vfw.type(Type, target)
vfw.type('String', 'asd') // => true
vfw.type('Number', 'asd') // => false
vfw.express or vfw.$
vfw.$('in', [1, 2], 1) // => true
vfw.struct(StructName, target)
vfw.struct('User', {user: 'lee', password: '123456'})
vfw.extendRule(opts)
- extend your own RuleType. type, expression, struct are all instanceof RuleType.
vfw.extendRule({
// canHandle function must be rewrited to tell vfw what it can handle
canHandle: function (obj) {
return /^@/.test(obj)
},
name: 'custom'
})
// if name supported
vfw.custom('@as', 12)
// and you can write rule like this
vfw.parse({
a: '@string'
})
vfw.extendParser(Function)
// extend a new RuleType, the rule '#xxx' will be handled by isXxx
// for example, #string will be handled by isString
vfw.extendParser(function (rule, struct, ruleIns) {
// if this function cant handle the rule, return false, and this rule will handled by others
if (!(typeof rule === 'string' && rule.charAt(0) === '#')) return false
rule = rule.slice(1)
rule = 'is' + rule.charAt(0).toUpperCase() + rule.slice(1)
var handler = vfw.get(rule)
if (!handler) return false
ruleIns.setHandler(handler, rule)
struct.add(ruleIns)
return true
})
var _ = require('lodash')
vfw.include('type', _)
// use _.isPlainObject
var struct = vfw.parse({a: '#PlainObject'})
struct.check({a: {a: 1}}) // => true
vfw.extend(type, extends)
- type
String
name of RuleType, like 'type', 'expression' - extends
Object
the functions you want to extend
vfw.extend('type', {
Money: function(){},
Url: function(){}
})
vfw.extend('expression', {
$lt: function(target, len){},
$startWith: function(target, char){}
})
// once extended, those rules can be used anywhere
vfw.include(type, obj)
- type
String
name of RuleType, like 'type', 'expression' - obj
Object
- you can include a lib like lodash, validator or others and use the functions they supported
var _ = require('lodash')
vfw.include('type', _)
// use _.isPlainObject
var struct = vfw.parse({a: '#PlainObject'})
struct.check({a: {a: 1}}) // => true