Using a schema object

Basics

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

  # Define a schema - http://json-schema.org/learn/miscellaneous-examples.html
  # You can also load schema from disk or web
  $jv->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 = $jv->validate({firstName => "Jan Henning", lastName => "Thorsen", age => -42});

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

Using joi

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

  $jv->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),
    }),
  );

Supported schema formats

Resources

• <http://json-schema.org/documentation.html>
• <https://json-schema.org/understanding-json-schema/index.html>
• <https://github.com/json-schema/json-schema/>

Bundled specifications

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:

• JSON schema, draft 4, 6, 7, 2019-09.

  Web page: <http://json-schema.org>

  $ref: <http://json-schema.org/draft-04/schema#>, <http://json-schema.org/draft-06/schema#>, <http://json-schema.org/draft-07/schema#>.

• JSON schema for JSONPatch files

  Web page: <http://jsonpatch.com>

  $ref: <http://json.schemastore.org/json-patch#>

• Swagger / OpenAPI specification, version 2

  Web page: <https://openapis.org>

  $ref: <http://swagger.io/v2/schema.json#>

• OpenAPI specification, version 3

  Web page: <https://openapis.org>

  $ref: https://spec.openapis.org/oas/3.0/schema/2019-04-02 <https://github.com/OAI/OpenAPI-Specification/blob/master/schemas/v3.0/schema.json>

  This specification is still EXPERIMENTAL.

• Swagger Petstore

  This is used for unit tests, and should not be relied on by external users.

Optional modules

• Sereal::Encoder

  Installing Sereal::Encoder v4.00 (or later) will make "data_checksum" in JSON::Validator::Util significantly faster. This function is used both when parsing schemas and validating data.

• Format validators

  See the documentation in JSON::Validator::Formats for other optional modules to do validation of specific "format", such as "hostname", "ipv4" and others.

cache_paths

formats

  $jv->formats(...);         # Legacy
  $jv->schema->formats(...); # Recommended way

recursive_data_protection

  $jv->recursive_data_protection(...);         # Legacy
  $jv->schema->recursive_data_protection(...); # Recommended way

store

  $store = $jv->store;

Holds a JSON::Validator::Store object that caches the retrieved schemas. This object will be shared amongst different "schema" objects to prevent a schema from having to be downloaded again.

ua

bundle

  # These two lines does the same
  $data = $jv->bundle;
  $data = $jv->schema->bundle->data;

  # Recommended way
  $schema = $jv->schema->bundle;

coerce

  $jv->coerce(...);         # Legacy
  $jv->schema->coerce(...); # Recommended way

get

new

  $jv = JSON::Validator->new(%attributes);
  $jv = JSON::Validator->new(\%attributes);

Creates a new JSON::Validate object.

load_and_validate_schema

schema

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

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

$schema will be an instance of JSON::Validator::Schema::Draft4, JSON::Validator::Schema::Draft6 JSON::Validator::Schema::Draft7, JSON::Validator::Schema::Draft201909, JSON::Validator::Schema::OpenAPIv2, JSON::Validator::Schema::OpenAPIv3 or JSON::Validator::Schema.

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 JSON::Validator::Util.

• 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. If the file could not be found on disk and the path starts with "/", then the will be loaded from the app defined in "ua". Something like this:

    $jv->ua->server->app(MyMojoApp->new);
    $jv->ua->get('/any/other/url.json');
      

validate