Skip to content
Pure Lua JSON schema validator for Lua/LuaJIT
Lua Makefile
Branch: devel
Clone or download
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Permalink
Type Name Latest commit message Commit time
Failed to load latest commit information.
lib
rockspec change: name style. Oct 24, 2019
spec change: removed useless file. Oct 22, 2019
t change: name style. Oct 24, 2019
.gitignore
.gitmodules
LICENSE updated license Oct 22, 2019
Makefile change: name style. Oct 24, 2019
README.md change: name style. Oct 24, 2019

README.md

jsonschema: JSON schema validator

This library provides a JSON schema draft 4, draft 6, draft 7 validator for Lua/LuaJIT. Note that even though it uses the JSON Schema semantics, it is neither bound or limited to JSON. It can be used to validate saner key/value data formats as well (Lua tables, msgpack, bencode, ...).

It has been designed to validate incoming data for HTTP APIs so it is decently fast: it works by transforming the given schema into a pure Lua function on-the-fly. Work is currently in progress to make it as JIT-friendly as possible.

Installation

This module is pure Lua/LuaJIT project, it support Lua 5.2, Lua 5.3, LuaJIT 2.1 beta.

The preferred way to install this library is to use Luarocks:

luarocks install jsonschema

Running the tests:

git submodule update --init --recrusive
make dev
make test

The project references the pcre regular library.

If you were using the LuaJIT of OpenResty, it will use the built-in ngx.re.find automaticly. But if you are using Lua 5.2, 5.3 or LuaJIT 2.1 beta, you will need to install lrexlib-pcre.

In addition, the project also relies on the net_url library, which you need to install anyway.

Usage

Getting started

local jsonschema = require 'jsonschema'

-- Note: do cache the result of schema compilation as this is a quite
-- expensive process
local myvalidator = jsonschema.generate_validator {
  type = 'object',
  properties = {
    foo = { type = 'string' },
    bar = { type = 'number' },
  },
}

print(myvalidator{ foo='hello', bar=42 })

Advanced usage

Some advanced features of JSON Schema are not possible to implement using the standard library and require third party libraries to be work.

In order to not force one particular library, and not bloat this library for the simple schemas, extension points are provided: the generate_validator takes a second table argument that can be used to customise the generated parser.

local v = jsonschema.generate_validator(schema, {
    -- a value used to check null elements in the validated documents
    -- defaults to `cjson.null` (if available) or `nil`
    null = null_token,

    -- function called to match patterns, defaults to string.find.
    -- The JSON schema specification mentions that the validator should obey
    -- the ECMA-262 specification but Lua pattern matching library is much more
    -- primitive than that. Users might want to use PCRE or other more powerful
    -- libraries here
    match_pattern = function(string, patt)
        return ... -- boolean value
    end,

    -- function called to resolve external schemas. It is called with the full
    -- url to fetch (without the fragment part) and must return the
    -- corresponding schema as a Lua table.
    -- There is no default implementation: this function must be provided if
    -- resolving external schemas is required.
    external_resolver = function(url)
        return ... -- Lua table
    end,

    -- name when generating the validator function, it might ease debugging as
    -- as it will appear in stack traces.
    name = "myschema",
})

Differences with JSONSchema

Due to the nature of the Lua language, the full JSON schema support is difficult to reach. Some of the limitations can be solved using the advanced options detailed previously, but some features are not supported (correctly) at this time:

  • Empty tables and empty arrays are the same from Lua point of view
  • Unicode strings are considered as a stream of bytes (so length checks might not behave as expected)

On the other hand, some extra features are supported:

  • The type table can be used to match arrays or objects, it is also much faster than array or object as it does not involve walking the table to find out if it's a sequence or a hash
  • The type function can be used to check for functions
You can’t perform that action at this time.