mrc-2476: Upgrade ajv to version 8.5.0 and include draft-04 extension

DESCRIPTION

@@ -1,8 +1,9 @@
 Package: jsonvalidate
 Title: Validate 'JSON' Schema
-Version: 1.2.3
+Version: 1.3.0
 Authors@R: c(person("Rich", "FitzJohn", role = c("aut", "cre"),
     email = "rich.fitzjohn@gmail.com"),
+    person("Rob", "Ashton", role = "aut"),
     person("Alicia", "Schep", role = "ctb"),
     person("Ian", "Lyttle", role = "ctb"),
     person("Kara", "Woo", role = "ctb"),
@@ -23,7 +24,8 @@ Suggests:
     knitr,
     jsonlite,
     rmarkdown,
-    testthat
+    testthat,
+    withr
 RoxygenNote: 7.1.1
 VignetteBuilder: knitr
 Encoding: UTF-8

NEWS.md

@@ -1,3 +1,8 @@
+## jsonvalidate 1.3.0
+
+* Upgrade to ajv version 8.5.0
+* Add arg `strict` to `json_validate` and `json_validator` to allow evaluating schema in strict mode for ajv only. This is off (`FALSE`) by default to use permissive behaviour detailed in JSON schema
+
 ## jsonvalidate 1.2.3
 
 * Schemas can use references to other files with JSON pointers i.e. schemas can reference parts of other files e.g. `definitions.json#/definitions/hello`

R/read.R

@@ -110,14 +110,10 @@ read_meta_schema_version <- function(schema, v8) {
     return(NULL)
   }
 
-  regex <- "^http://json-schema.org/(draft-\\d{2})/schema#$"
+  regex <- paste0("^https*://json-schema.org/",
+                  "(draft-\\d{2}|draft/\\d{4}-\\d{2})/schema#*$")
   version <- gsub(regex, "\\1", meta_schema)
 
-  versions_legal <- c("draft-04", "draft-06", "draft-07")
-  if (!(version %in% versions_legal)) {
-    stop(sprintf("Unknown meta schema version '%s'", version))
-  }
-
   version
 }
 

R/util.R

@@ -60,3 +60,10 @@ set_names <- function(x, nms) {
   names(x) <- nms
   x
 }
+
+
+note_imjv <- function(msg) {
+  if (!isTRUE(getOption("jsonvalidate.no_note_imjv", FALSE))) {
+    message(msg)
+  }
+}

R/validate.R

@@ -1,5 +1,46 @@
 ##' Create a validator that can validate multiple json files.
 ##'
+##' @section Validation Engines:
+##'
+##' We support two different json validation engines, \code{imjv}
+##'   ("is-my-json-valid") and \code{ajv} ("Another JSON
+##'   Validator"). \code{imjv} was the original validator included in
+##'   the package and remains the default for reasons of backward
+##'   compatibility. However, users are encouraged to migrate to
+##'   \code{ajv} as with it we support many more features, including
+##'   nested schemas that span multiple files, meta schema versions
+##'   later than draft-04, validating using a subschema, and
+##'   validating a subset of an input data object.
+##'
+##' If your schema uses these features we will print a message to
+##'   screen indicating that you should update. We do not use a
+##'   warning here as this will be disruptive to users. You can
+##'   disable the message by setting the option
+##'   \code{jsonvalidate.no_note_imjv} to \code{TRUE}. Consider
+##'   using \code{withr::with_options} (or simply
+##'   \code{suppressMessages}) to scope this option if you want to
+##'   quieten it within code you do not control.
+##'
+##' Updating the engine should be simply a case of adding \code{engine
+##'   = "ajv"} to your \code{json_validator} or \code{json_validate}
+##'   calls, but you may see some issues when doing so.
+##'
+##' \itemize{
+##' \item Your json now fails validation: We've seen this where
+##'   schemas spanned several files and are silently ignored. By
+##'   including these, your data may now fail validation and you will
+##'   need to either fix the data or the schema.
+##'
+##' \item Your code depended on the exact payload returned by
+##'   \code{imjv}: If you are inspecting the error result and checking
+##'   numbers of errors, or even the columns used to describe the
+##'   errors, you will likely need to update your code to accommodate
+##'   the slightly different format of \code{ajv}
+##'
+##' \item Your schema is simply invalid: If you reference an invalid
+##'   metaschema for example, jsonvalidate will fail
+##' }
+##'
 ##' @title Create a json validator
 ##'
 ##' @param schema Contents of the json schema, or a filename
@@ -17,6 +58,13 @@
 ##'   would check that the json is a valid "Hello" object. Only available if
 ##'   \code{engine = 'ajv'}.
 ##'
+##' @param strict Set whether the schema should be parsed strictly or not.
+##'   If in strict mode schemas will error to "prevent any unexpected
+##'   behaviours or silently ignored mistakes in user schema". For example
+##'   it will error if encounters unknown formats or unknown keywords. See
+##'   https://ajv.js.org/strict-mode.html for details. Only available in
+##'   \code{engine = 'ajv'}.
+##'
 ##' @section Using multiple files:
 ##'
 ##' Multiple files are supported.  You can have a schema that
@@ -33,12 +81,14 @@
 ##'
 ##' @export
 ##' @example man-roxygen/example-json_validator.R
-json_validator <- function(schema, engine = "imjv", reference = NULL) {
+json_validator <- function(schema, engine = "imjv", reference = NULL,
+                           strict = FALSE) {
   v8 <- env$ct
   schema <- read_schema(schema, v8)
+
   switch(engine,
          imjv = json_validator_imjv(schema, v8, reference),
-         ajv = json_validator_ajv(schema, v8, reference),
+         ajv = json_validator_ajv(schema, v8, reference, strict),
          stop(sprintf("Unknown engine '%s'", engine)))
 }
 
@@ -74,9 +124,10 @@ json_validator <- function(schema, engine = "imjv", reference = NULL) {
 ##' @example man-roxygen/example-json_validate.R
 json_validate <- function(json, schema, verbose = FALSE, greedy = FALSE,
                           error = FALSE, engine = "imjv", reference = NULL,
-                          query = NULL) {
-  tmp <- json_validator(schema, engine, reference = reference)
-  tmp(json, verbose, greedy, error, query)
+                          query = NULL, strict = FALSE) {
+  validator <- json_validator(schema, engine, reference = reference,
+                              strict = strict)
+  validator(json, verbose, greedy, error, query)
 }
 
 
@@ -85,17 +136,25 @@ json_validator_imjv <- function(schema, v8, reference) {
   meta_schema_version <- schema$meta_schema_version %||% "draft-04"
 
   if (!is.null(reference)) {
+    ## This one has to be an error; it has never worked and makes no
+    ## sense.
     stop("subschema validation only supported with engine 'ajv'")
   }
 
   if (meta_schema_version != "draft-04") {
-    stop(sprintf(
-      "meta schema version '%s' is only supported with engine 'ajv'",
-      meta_schema_version))
+    ## We detect the version, so let the user know they are not really
+    ## getting what they're asking for
+    note_imjv(paste(
+      "meta schema version other than 'draft-04' is only supported with",
+      sprintf("engine 'ajv' (requested: '%s')", meta_schema_version),
+      "- falling back to use 'draft-04'"))
+    meta_schema_version <- "draft-04"
   }
 
   if (length(schema$dependencies) > 0L) {
-    stop("Schema references are only supported with engine 'ajv'")
+    ## We've found references, but can't support them. Let the user
+    ## know.
+    note_imjv("Schema references are only supported with engine 'ajv'")
   }
 
   v8$call("imjv_create", name, meta_schema_version, V8::JS(schema$schema))
@@ -119,19 +178,25 @@ json_validator_imjv <- function(schema, v8, reference) {
 }
 
 
-json_validator_ajv <- function(schema, v8, reference) {
+json_validator_ajv <- function(schema, v8, reference, strict) {
   name <- random_id()
   meta_schema_version <- schema$meta_schema_version %||% "draft-07"
 
+  versions_legal <- c("draft-04", "draft-06", "draft-07", "draft/2019-09",
+                      "draft/2020-12")
+  if (!(meta_schema_version %in% versions_legal)) {
+    stop(sprintf("Unknown meta schema version '%s'", meta_schema_version))
+  }
+
   if (is.null(reference)) {
     reference <- V8::JS("null")
   }
   if (is.null(schema$filename)) {
     schema$filename <- V8::JS("null")
   }
   dependencies <- V8::JS(schema$dependencies %||% "null")
-  v8$call("ajv_create", name, meta_schema_version, V8::JS(schema$schema),
-          schema$filename, dependencies, reference)
+  v8$call("ajv_create", name, meta_schema_version, strict,
+          V8::JS(schema$schema), schema$filename, dependencies, reference)
 
   ret <- function(json, verbose = FALSE, greedy = FALSE, error = FALSE,
                   query = NULL) {
@@ -164,6 +229,10 @@ validation_result <- function(res, error, verbose) {
       stop(validation_error(res))
     }
     if (verbose) {
+      ## In ajv version < 8 errors had dataPath property. This has
+      ## been renamed to instancePath in v8 +. Keep dataPath for
+      ## backwards compatibility to support dccvalidator
+      res$errors$dataPath <- res$errors$instancePath
       attr(success, "errors") <- res$errors
     }
   }
@@ -177,7 +246,7 @@ validation_error <- function(res) {
   n <- nrow(errors)
   if (res$engine == "ajv") {
     detail <- paste(sprintf("\t- %s (%s): %s",
-                            errors$dataPath,
+                            errors$instancePath,
                             errors$schemaPath,
                             errors$message),
                     collapse = "\n")

inst/LICENSE.ajv

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2015-2017 Evgeny Poberezkin
+Copyright (c) 2015-2021 Evgeny Poberezkin
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal