Un schema es una estructura con formato de JSON que describe la estructura de otro JSON, sus propiedades y las condiciones que deben cumplir. La mejor forma de crear un schema es usando una herramienta online que, a partir de un JSON, nos cree un schema básico que podamos adaptar a nuestras necesidades. Se puede usar tanto para validar desde que propiedades deben estar presentes hasta que expresión regular deben respetar los valores.

 

 El tipo string lo usamos para representar texto. Podemos validar el largo mínimo y máximo con las propiedades 'minLength' y 'maxLength' .

{
  "type": "string",
  "minLength": 2,
  "maxLength": 3
}

 

Podemos usar expresiones regulares para validar el formato con la propiedad 'pattern'.

{
  "type": "string",
  "pattern": "^(\\([0-9]{3}\\))?[0-9]{3}-[0-9]{4}$"
}

 

También contamos con la propiedad 'format', que valida formatos mas usados como email, date-time, etc.

{
  "type": "string",
  "format": "date-time"
}

 

Tenemos también la propiedad 'enum', que contiene una lista de valores aceptados.

{
  "type": "string",
  "enum": [
    "masculino",
    "femenino"
  ]
}

El tipo number describe cualquier valor numérico, tanto enteros como decimales. Con la propiedad 'multipleOf' validamos que el valor sea múltiplo de algún número.

{
  "type": "number",
  "multipleOf" : 10
}

 

Podemos definir también un rango que se debe respetar, tenemos 4 propiedades 'exclusiveMinimun' y 'exclusiveMaximun' para mínimos y máximos excluyentes, y 'minimum' y 'maximun' para mínimos y máximos no excluyentes.

{
  "type": "number",
  "minimum": 0,
  "exclusiveMaximum": 100
}

El tipo boolean es para valores de verdad, solo acepta true y false, no acepta strings, números ni ningún otro valor que pueda evaluarse como true o false. Este tipo de dato no cuenta con ninguna validación adicional.

{
  "type": "boolean"
}

Cuando tenemos un array tenemos también que describir los elementos que contiene, para eso tenemos la propiedad 'items'.

{
  "type": "array",
  "items": {
    "type": "string"
  }
}

 

En los arrays tenemos las properties 'minItems' y 'maxItems', para definir la cantidad mínima y máxima de elementos permitidos.

{
  "type": "array",
  "items": {
    "type": "string"
  },
  "minItems": 1,
  "maxItems": 3
}

 

También podemos definirlo como un array de elementos únicos con la property 'uniqueItems'

{
  "type": "array",
  "items": {
    "type": "string"
  },
  "uniqueItems": true
}

La manera de describir un objeto en un schema es describiendo cada una de sus propiedades. Por ejemplo, teniendo el siguiente objeto:

{
  "nombre": "Mauricio",
  "edad": 34,
  "email": "Esta dirección de correo electrónico está siendo protegida contra los robots de spam. Necesita tener JavaScript habilitado para poder verlo.",
  "fechaDeNacimiento": "04/02/1988"
}

 

En el schema agregamos el campo 'properties', que es un objeto que describe las propiedades del objeto

{
  "type": "object",
  "properties": {
    "nombre": {
      "type": "string"
    },
    "edad": {
      "type": "integer",
      "minimum": 0,
      "maximum": 100
    },
    "email": {
      "type": "string",
      "format": "email"
    },
    "fechaDeNacimiento": {
      "type": "string",
      "format": "date
    }
  }
}

Si necesitamos asegurarnos de que algún valor esté presente podemos agregarlo en la property 'required', un array de strings que contiene el nombre de todas las propiedades obligatorias.

{
  "type": "object",
  "properties": {
    "nombre": {
      "type": "string"
    },
    "edad": {
      "type": "integer",
      "minimum": 0,
      "maximum": 100
    },
    "email": {
      "type": "string",
      "format": "email"
    },
    "fechaDeNacimiento": {
      "type": "string",
      "format": "date"
    }
  },
  "required": [
    "nombre",
    "email"
  ]
}

 

JavaScript no cuenta con una forma nativa para validar un JSON usando un schema, por lo que vamos a usar una librería llamada 'ajv' para la validación junto con otra llamada 'ajv-formats' para validar los campos format del schema

const Ajv = require("ajv");
const addFormats = require("ajv-formats");

const schema = {
  "type": "object",
  "properties": {
    "nombre": {
      "type": "string"
    },
    "edad": {
      "type": "integer",
      "minimum": 0,
      "maximum": 100
    },
    "email": {
      "type": "string",
      "format": "email"
    },
    "fechaDeNacimiento": {
      "type": "string"
    }
  },
  "required": [
    "nombre",
    "email"
  ]
}

const persona = {
  "nombre": "Mauricio",
  "edad": 34,
  "email": "Esta dirección de correo electrónico está siendo protegida contra los robots de spam. Necesita tener JavaScript habilitado para poder verlo.",
  "fechaDeNacimiento": "04/02/1988"
}

const ajv = new Ajv();

// con esta función le agregamos la capacidad de validar formatos al validador.
addFormats(ajv);

// La funcion 'compile' acepta un schema y nos devuelve una función, esta función usará el schema para la validación.
const validar = ajv.compile(schema);

const personaValida = validar(persona);