++ed by:
AZJADFTRE KARJALA JACOBY KWAKWA KEEDI

14 PAUSE users
7 non-PAUSE users.

Jan Henning Thorsen

NAME

JSON::Validator - Validate data against a JSON schema

SYNOPSIS

  use JSON::Validator;
  my $validator = JSON::Validator->new;

  # Define a schema - http://json-schema.org/learn/miscellaneous-examples.html
  # You can also load schema from disk or web
  $validator->schema({
    type       => "object",
    required   => ["firstName", "lastName"],
    properties => {
      firstName => {type => "string"},
      lastName  => {type => "string"},
      age       => {type => "integer", minimum => 0, description => "Age in years"}
    }
  });

  # Validate your data
  my @errors = $validator->validate({firstName => "Jan Henning", lastName => "Thorsen", age => -42});

  # Do something if any errors was found
  die "@errors" if @errors;

  # Use joi() to build the schema
  use JSON::Validator 'joi';

  $validator->schema(joi->object->props({
    firstName => joi->string->required,
    lastName  => joi->string->required,
    age       => joi->integer->min(0),
  }));

  # joi() can also validate directly
  my @errors = joi(
    {firstName => "Jan Henning", lastName => "Thorsen", age => -42},
    joi->object->props({
      firstName => joi->string->required,
      lastName  => joi->string->required,
      age       => joi->integer->min(0),
    });
  );

DESCRIPTION

JSON::Validator is a data structure validation library based around JSON Schema. This module can be used directly with a JSON schema or you can use the elegant DSL schema-builder JSON::Validator::joi to define the schema programmatically.

Supported schema formats

JSON::Validator can load JSON schemas in multiple formats: Plain perl data structured (as shown in "SYNOPSIS"), JSON or YAML. The JSON parsing is done with Mojo::JSON, while YAML files require the optional module YAML::XS to be installed.

Resources

Here are some resources that are related to JSON schemas and validation:

Bundled specifications

This module comes with some JSON specifications bundled, so your application don't have to fetch those from the web. These specifications should be up to date, but please submit an issue if they are not.

Files referenced to an URL will automatically be cached if the first element in "cache_paths" is a writable directory. Note that the cache headers for the remote assets are not honored, so you will manually need to remove any cached file, should you need to refresh them.

To download and cache an online asset, do this:

  JSON_VALIDATOR_CACHE_PATH=/some/writable/directory perl myapp.pl

Here is the list of the bundled specifications:

ERROR OBJECT

The methods "validate" and the function "validate_json" returns a list of JSON::Validator::Error objects when the input data violates the "schema".

FUNCTIONS

joi

  use JSON::Validator "joi";
  my $joi    = joi;
  my @errors = joi($data, $joi); # same as $joi->validate($data);

Used to construct a new JSON::Validator::Joi object or perform validation.

validate_json

  use JSON::Validator "validate_json";
  my @errors = validate_json $data, $schema;

This can be useful in web applications:

  my @errors = validate_json $c->req->json, "data://main/spec.json";

See also "validate" and "ERROR OBJECT" for more details.

ATTRIBUTES

cache_paths

  my $validator = $validator->cache_paths(\@paths);
  my $array_ref = $validator->cache_paths;

A list of directories to where cached specifications are stored. Defaults to JSON_VALIDATOR_CACHE_PATH environment variable and the specs that is bundled with this distribution.

JSON_VALIDATOR_CACHE_PATH can be a list of directories, each separated by ":".

See "Bundled specifications" for more details.

formats

  my $hash_ref  = $validator->formats;
  my $validator = $validator->formats(\%hash);

Holds a hash-ref, where the keys are supported JSON type "formats", and the values holds a code block which can validate a given format. A code block should return undef on success and an error string on error:

  sub { return defined $_[0] && $_[0] eq "42" ? undef : "Not the answer." };

See JSON::Validator::Formats for a list of supported formats.

ua

  my $ua        = $validator->ua;
  my $validator = $validator->ua(Mojo::UserAgent->new);

Holds a Mojo::UserAgent object, used by "schema" to load a JSON schema from remote location.

The default Mojo::UserAgent will detect proxy settings and have "max_redirects" in Mojo::UserAgent set to 3.

version

  my $int       = $validator->version;
  my $validator = $validator->version(7);

Used to set the JSON Schema version to use. Will be set automatically when using "load_and_validate_schema", unless already set.

METHODS

bundle

  my $schema = $validator->bundle(\%args);

Used to create a new schema, where the $ref are resolved. %args can have:

  • {replace = 1}>

    Used if you want to replace the $ref inline in the schema. This currently does not work if you have circular references. The default is to move all the $ref definitions into the main schema with custom names. Here is an example on how a $ref looks before and after:

      {"$ref":"../some/place.json#/foo/bar"}
         => {"$ref":"#/definitions/____some_place_json-_foo_bar"}
    
      {"$ref":"http://example.com#/foo/bar"}
         => {"$ref":"#/definitions/_http___example_com-_foo_bar"}
  • {schema = {...}}>

    Default is to use the value from the "schema" attribute.

coerce

  my $validator = $validator->coerce(booleans => 1, numbers => 1, strings => 1);
  my $validator = $validator->coerce({booleans => 1, numbers => 1, strings => 1});
  my $hash_ref  = $validator->coerce;

Set the given type to coerce. Before enabling coercion this module is very strict when it comes to validating types. Example: The string "1" is not the same as the number 1, unless you have coercion enabled.

Loading a YAML document will enable "booleans" automatically. This feature is experimental, but was added since YAML has no real concept of booleans, such as Mojo::JSON or other JSON parsers.

get

  my $sub_schema = $validator->get("/x/y");
  my $sub_schema = $validator->get(["x", "y"]);

Extract value from "schema" identified by the given JSON Pointer. Will at the same time resolve $ref if found. Example:

  $validator->schema({x => {'$ref' => '#/y'}, y => {'type' => 'string'}});
  $validator->schema->get('/x')           == undef
  $validator->schema->get('/x')->{'$ref'} == '#/y'
  $validator->get('/x')                   == {type => 'string'}

The argument can also be an array-ref with the different parts of the pointer as each elements.

load_and_validate_schema

  my $validator = $validator->load_and_validate_schema($schema, \%args);

Will load and validate $schema against the OpenAPI specification. $schema can be anything "schema" in JSON::Validator accepts. The expanded specification will be stored in "schema" in JSON::Validator on success. See "schema" in JSON::Validator for the different version of $url that can be accepted.

%args can be used to further instruct the validation process:

  • schema

    Defaults to "http://json-schema.org/draft-04/schema#", but can be any structured that can be used to validate $schema.

schema

  my $validator = $validator->schema($json_or_yaml_string);
  my $validator = $validator->schema($url);
  my $validator = $validator->schema(\%schema);
  my $validator = $validator->schema(JSON::Validator::Joi->new);
  my $schema    = $validator->schema;

Used to set a schema from either a data structure or a URL.

$schema will be a Mojo::JSON::Pointer object when loaded, and undef by default.

The $url can take many forms, but needs to point to a text file in the JSON or YAML format.

  • file://...

    A file on disk. Note that it is required to use the "file" scheme if you want to reference absolute paths on your file system.

  • http://... or https://...

    A web resource will be fetched using the Mojo::UserAgent, stored in "ua".

  • data://Some::Module/spec.json

    Will load a given "spec.json" file from Some::Module using "data_section" in Mojo::Loader.

  • data:///spec.json

    A "data" URL without a module name will use the current package and search up the call/inheritance tree.

  • Any other URL

    An URL (without a recognized scheme) will be treated as a path to a file on disk.

singleton

  my $validator = JSON::Validator->singleton;

Returns the JSON::Validator object used by "validate_json".

validate

  my @errors = $validator->validate($data);
  my @errors = $validator->validate($data, $schema);

Validates $data against a given JSON "schema". @errors will contain validation error objects or be an empty list on success.

See "ERROR OBJECT" for details.

$schema is optional, but when specified, it will override schema stored in "schema". Example:

  $validator->validate({hero => "superwoman"}, {type => "object"});

SEE ALSO

COPYRIGHT AND LICENSE

Copyright (C) 2014-2018, Jan Henning Thorsen

This program is free software, you can redistribute it and/or modify it under the terms of the Artistic License version 2.0.

AUTHOR

Jan Henning Thorsen - jhthorsen@cpan.org

Daniel Böhmer - post@daniel-boehmer.de

Ed J - mohawk2@users.noreply.github.com

Kevin Goess - cpan@goess.org

Martin Renvoize - martin.renvoize@gmail.com