util-validador v1.2.2

validaciones: Validaciones NodeJS

Librería de validaciones de diversos tipos en ECMAScript 6. ##Cómo usar

const Validador = require('path/to/util-validador');
//opciones predeterminadas
const validador = new Validador();
//con opciones
let options = {
    logLevel : "debug"
}
const custom = new Validator(options)

function checkJson(myVar) {
    let schema = {
        "type" : "object",
        "properties" : {
            "nombre" : {
                "type" : "string",
                "minLength" : 3,
                "maxLength" : 45
            },
            "apellido" : {
                "type" : "string",
                "pattern": "^(.*)$"
            }           
        }           
    };      
    let result = validador.validateJson(myVar, schema);
    if(result.valid){
        alert("OK!")
    }else{
        for(let m in result.mensaje.split(",")){
            console.error(m);
        }       
        alert("Oh no!")
    }
}

Opciones

log_level

Determina el nivel de logging, utilizando logLevel. Los niveles disponibles son:

• debug
• info
• warn
• error: Valor por defecto

• silent

  validation_algorithm

  Determina si se usará jsonschema o ajv para validar json al usar validateJson():

• 0: Se utilizará Ajv. Valor por defecto. Ttiene mensajes localizados al español.

• 1: Se utilizará Json-schema.

  rut_regex

  Expresión regular para realizar la comprobación de formato de rut. Debe ser una expresión regular de javascript, no una string.

  Valor por defecto:

  /^(\d{1,3}(?:\.?\d{1,3}){2}-?[\dkK])$/

Funciones

validateJson

Retorna un objeto compuesto de dos valores, "valid" y "mensaje". "valid" es de tipo booleano "mensaje" es string.

Recibe como argumento un objeto json y un objeto schema, basado en la especificación jsonSchema.

Si la validación es positiva, la respuesta tendrá el formato:

{
  "valid" : true,
  "mensaje" : "OK"
}

Si la validación es negativa, tendrá el mismo formato, y los mensajes de error consistirán en una sola string separada por comas.

{
  "valid" : false,
  "mensaje" : "mensaje-1,mensaje-2,mensaje-3"
}

testRegex

Realiza una comparación contra una expresión regular de javascript. Retorna el valor booleano del método test. ####Uso

testRegex("12345", /^\d+$/) === true;

testRegex("12345", /^\d{3}+$/) === false;

isRut

Retorna true si el argumento es una string que contiene un rut.

Ignora los puntos separadores de miles, pero no el guión ni el dígito verificador.

No valida si el dígito verificador es correcto, solo el formato. ####Uso

 isrut("25.636.318-K") === true;
 isrut("19633144-2") === true;
 isrut("19633144") === false;

exists

Retorna true si el argumento no undefined y no es null. ####Uso

const Validador = require('path/to/util-validador');
const v = new Validador();

v.exists(null) === false;
v.exists(undefined) === false;
v.exists(NaN) === true;
v.exists(Infinity) === true;
v.exists("") === true;
v.exists(0) ===true;

isNumber

Retorna true si el valor es un número o una string que pueda ser evaluada como un número.

Valida como verdadero números enteros, reales, binarios, octales, hexadecimales y notación científica.

const Validador = require('path/to/util-validador');
const v = new Validador();
####Uso
v.isNumber(42) === true;
v.isNumber(-42) === true;
v.isNumber(42.5) === true;
v.isNumber(0b101010) === true;
v.isNumber(0o52) === true;
v.isNumber(0x2A) === true;
v.isNumber(4.2e1) === true;
v.isNumber(-4.2e-2) === true;
v.isNumber("42") === true;
v.isNumber("42.5") === true;
v.isNumber("0b101010") === true;

v.isNumber(null) === false;
v.isNumber(undefined) === false;
v.isNumber({number : 0}) === false;
v.isNumber([1,2]) === false;
v.isNumber("abc123") === false;
v.isNumber("123.4.5") === false;

isInteger

Realiza las mismas validaciones que isNumber() y adicionalmente solo retorna true si el valor es un número entero. ####Uso

v.isInteger(42) === true;
v.isInteger(42.5) === false;
v.isInteger(42e-3) === false;

isString

Retorna true si el valor es una string.

Arreglos de caracteres, aunque pueden ser considerados como "string", también devuelven falso. ####Uso

v.isString("hola mundo") === true;
v.isString(new String("El veloz murciélago hindú comía feliz cardillo y" +
"kiwi. La cigüeña tocaba el saxofón detrás del palenque de paja")) === true;

v.isString(['H','o','l','a']) === false;
v.isString(null) === false;
v.isString(undefined) === false;
v.isString("") === false;

isEmptyString

Retorna true si y solo si el argumento es una string y está vacía. ####Uso

v.isEmptyString("") === true;

v.isEmptyString(" ") === false;

isBlankString

Retorna true si el argumento es una string que está vacía o solo contiene caracteres de espacio en blanco. ####Uso

v.isBlankString(" ") === true;
v.isBlankString("") === true;
v.isBlankString("\n") === true;
v.isBlankString("\r") === true;
v.isBlankString("\t") === true;

v.isEmptyString(".") === false;
v.isBlankString(undefined) === false;

isEmptyObject

Retorna true si y solo si el argumento es un objeto vacío. ####Uso

v.isEmptyObject({}) === true;
v.isEmptyObject(new Object()) === true;

v.isEmptyObject("") === false;
v.isEmptyObject(0) === false;
v.isEmptyObject(null) === false;
v.isEmptyObject(undefined) === false;

isEmptyArray

Retorna true si y solo si el argumento es un objeto vacío ####Uso

v.isEmptyArray([]) === true;
v.isEmptyArray(new Array()) === true;

v.isEmptyArray([1,2,3]) === false;
v.isEmptyArray("") === false;
v.isEmptyArray(0) === false;
v.isEmptyArray(null) === false;
v.isEmptyArray(undefined) === false;

val

El objeto val expone la librería validation-utils en su totalidad. Aquí una copia de la sección de validadores de su readme

Validators

• array(entity , errorText) - check if entity is an array.
• boolean_(entity , errorText) - check if entity is a boolean.
• booleanNonStrict(entity , errorText) - check if entity is a boolean or a (case-insensitive) 'true' or 'false' string.
• booleanFalse(entity , errorText) - check if entity is a boolean with value False.
• booleanTrue(entity , errorText) - check if entity is a boolean with value True.
• date(entity , errorText) - check if entity is an instance of Date.
• equal(entity, expectedEqualEntity , errorText) - check if entity is equal to the expected one (compared with ===).
• falsy(entity , errorText) - check if entity is falsy.
• function_(entity , errorText) - check if entity is a function.
• inheritsFrom(entityClass, expectedParentClass , errorText) - check if class inherits from a given class.
• instanceOf(entity, expectedClass , errorText) - check if entity is an instance of a given class.
• notEmpty(entity , errorText) - check if entity is not an empty Object, String or Array.
• notNil(entity , errorText) - check if entity is not null or undefined.
• nil(entity , errorText) - check if entity is null or undefined.
• number(entity , errorText) - check if entity is a number.
• positiveNumber(entity , errorText) - check if entity is a positive number.
• negativeNumber(entity , errorText) - check if entity is a negative number.
• greaterThan(number, threshold , errorText) - check if entity is a number than is greater than the specified threshold.
• lessThan(number, threshold , errorText) - check if entity is a number than is less than the specified threshold.
• string(entity , errorText) - check if entity is a string.
• object_(entity , errorText) - check if entity is an object.
• truthy(entity , errorText) - check if entity is truthy.
• withProperties(entity, expectedProperties) - check if entity has at least a given set of properties defined.

Important: All validators return validated value as a result and throw an error when validation fails. ####Uso

let validator_utils = v.val;
try{
validator_utils.isAlpha("123abc");
}catch(e){
console.error("No es alfanumérico");
}

stringVal

El objeto stringVal expone la librería validator en su totalidad.

Aquí una copia de la sección de validadores de su readme.

Validators

Sanitizers

Here is a list of the sanitizers currently available.

####Uso

let stringValidator = v.stringVal;
if(stringValidator.isEmail("person@gmail.com")) console.log("es un email");

Tests

Los tests funcionan con mocha.

Para correr los tests:

   npm test