Uranus is a wrapper validation utility over chriso's awesome validator.js with some extra extension methods.
Installation:
$ npm install --save uranus
Note: 2.x
is written in Node 4x so its not compatible with previous versions of Node. For previous versions, install 1.x
:
$ npm install --save uranus@1.x
Tests:
To execute tests:
# clone the repo and change directory$ git clone https://github.com/umayr/uranus.git && cd $_# install local dependencies$ npm install# run tests$ npm test
Usage:
After installing uranus, you can simply use it as:
const Uranus = ;let result = Uranus;console // false
There are several ways to apply validations. For bulk validation you can use validateAll
which supports both array
and object
.
const Uranus = ;// For Arrays.let result = Uranus;console // true// For objects.let src =name: 'Neptune'email: 'foo@gmail.com';let rules =name:isAlpha: trueemail:isEmail: truelet result = Uranus;console // true
By default Uranus generates subject less error messages itself with the help of Cressida. For e.g:
let rules =isEmail: true;Uranus;// ['should be a valid email address.']
By default these messages are subjectless. To specify a name, you can do something like this:
// For `validateOne()`:let rules =isEmail: true;Uranus;// ['Foo should be a valid email address.']// For `validateAll()` with an array:let result = Uranus;// ['Foo should be a valid email address.']// For `validateAll()` with an object:let src =email:name: 'Foo'value: 'foo@!!!.com';let rules =email:isEmail: trueUranus;// ['Foo should be a valid email address.']
This feature can be turned off with includeName
set to false in options
moreover you can set your own error messages.
let result = Uranus;
For validating one single value, you can use validateOne
as:
let value = 'foo@email.com';let rules =isEmail: truenotNull: true;Uranus;
Both validateOne
& validateAll
methods can also be accessed by creating an instance of Uranus. For example:
const Uranus = ;let validator = ;// validateAlllet result = validator;console // true// validateOnelet value = 'foo@email.com';let rules =isEmail: truenotNull: true;let result = validator;console // true
By default validateAll
validates all the rules for all value sets but if you set progressive
to true
while creating Uranus
instance, it will stop iterating through rules when one fails. In that way you can get only one error message for one value instead of getting all, for example:
let validator = progressive: true ;let result = validator;console// ["Boo! email is invalid"]
Note: In case of static methods, options can be provided as the last argument.
Later you can get all of these messages by getAllMessages()
method. For example,
let msgs = result;console// ["Boo! email is invalid", "You're either too large or too small.", "meh, only letters, k?", "only lowercase, babes.", "No fishin'"]
You can also get message for one specific rule by:
let msg = result; // where 0 is the index of provided array.console // Boo! email is invalid
In order to get all rules for one value you can use getItem()
method, like:
let check = result;console // falseconsole // Boo! email is invalidconsole // falseconsole // You're either too large or too small.
Note: You can get whole ValidationItem
by using getRule()
.
Supported Rules:
As mentioned above, Uranus acts like a wrapper to validator.js
so it supports all validations currently provided by validator.js
. In addition to that, there are several extra validations rules that Uranus provides out of the box. Some common validations along with their args are as follows:
is: ["^[a-z]+$",'i'], // will only allow letters
is: /^[a-z]+$/i, // same as the previous example using real RegExp
not: ["[a-z]",'i'], // will not allow letters
isEmail: true, // checks for email format (foo@bar.com)
isUrl: true, // checks for url format (http://foo.com)
isIP: true, // checks for IPv4 (129.89.23.1) or IPv6 format
isIPv4: true, // checks for IPv4 (129.89.23.1)
isIPv6: true, // checks for IPv6 format
isAlpha: true, // will only allow letters
isAlphanumeric: true // will only allow alphanumeric characters, so "_abc" will fail
isNumeric: true // will only allow numbers
isInt: true, // checks for valid integers
isFloat: true, // checks for valid floating point numbers
isDecimal: true, // checks for any numbers
isLowercase: true, // checks for lowercase
isUppercase: true, // checks for uppercase
notNull: true, // won't allow null
isNull: true, // only allows null
notEmpty: true, // don't allow empty strings
equals: 'specific value', // only allow a specific value
contains: 'foo', // force specific substrings
optional: ['isUrl'] // validate the rule provided in second parameter if first param is not null
notIn: [['foo', 'bar']], // check the value is not one of these
isIn: [['foo', 'bar']], // check the value is one of these
notContains: 'bar', // don't allow specific substrings
len: [2,10], // only allow values with length between 2 and 10
isUUID: 4, // only allow uuids
isDate: true, // only allow date strings
isAfter: "2011-11-05", // only allow date strings after a specific date
isBefore: "2011-11-05", // only allow date strings before a specific date
max: 23, // only allow values
min: 23, // only allow values >= 23
isArray: true, // only allow arrays
isCreditCard: true // check for valid credit card numbers
Checkout Validator.js
project for more details on supported validations.
Note: If a rule is supported by validator.js
but it doesn't work properly in Uranus, please feel free to report an issue.
Custom Rules:
Additional rules can be added while instantiating Uranus, for e.g.
let validator = extensions: { return str; } ; let response = validator; response // true
If you want to use predefined rules in your custom rule, it can be done as:
let validator = extensions: { // Here `this` refers to the validator instance. // Therefore, all built-in validators will be available here. return this && this } ; let response = validator; response // false
Parameters passed from a rule can be accessed as additional arguments in the extension method:
let validator = extensions: { return strlength > min && strlenght < max; } ; let response = validator; response // true
License:
The MIT License (MIT)
Copyright (c) 2015 Umayr Shahid <umayrr@hotmail.co.uk>
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.