Constructing type tree based on the JSON schema

[roszakg]

Hi,

I'm trying to work out how to construct the type tree based on the given JSON Schema.

To give you an example let's look at the following schema from json-schema.org:

{
  "$id": "https://example.com/arrays.schema.json",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "description": "A representation of a person, company, organization, or place",
  "type": "object",
  "properties": {
    "fruits": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "vegetables": {
      "type": "array",
      "items": {
        "$ref": "#/$defs/veggie"
      }
    }
  },
  "$defs": {
    "veggie": {
      "type": "object",
      "required": [
        "veggieName",
        "veggieLike"
      ],
      "properties": {
        "veggieName": {
          "type": "string",
          "description": "The name of the vegetable."
        },
        "veggieLike": {
          "type": "boolean",
          "description": "Do I like this vegetable?"
        }
      }
    }
  }
}

combined with the following JSON data:

{
  "fruits": [
    "apple",
    "orange",
    "pear"
  ],
  "vegetables": [
    {
      "veggieName": "potato",
      "veggieLike": true
    },
    {
      "veggieName": "broccoli",
      "veggieLike": false
    }
  ]
}

What I'm trying to do is to dump the tree like structure (based just on schema itself and not the data) that describes a type of the particular field (or multiple types in a general case).

In the example above it would yield something like:

/ - [object]
"fruits" - [array]
[0] - [string]
"vegetables" - [array]
[0] - [object]
"veggieName" - string
"veggieLike" - boolean

What I need that for is to facilitate the conversion from data structure that does not convey any type information to JSON.

Is there a way to use jsoncons to facilitate such a schema guided conversion?

[danielaparker]

@roszakg, Apologies for the late response, just returned from vacation. The information that you need is in the json_schema object, but there's currently no way to access it. We could provide a visit function that accepts a callback argument to be invoked with information about specific keywords. In your use case, is it only the type keyword that you need to inspect?

[roszakg]

@danielaparker

Thank you for getting back to me - I hope you enjoyed your vacations :)
I'm really grateful for the support I'm getting from you.

At this point I'm mostly interested in field types.
However I can imagine that in the future being able to access another things (like checking if the additionalProperties or unevaluatedProperties are allowed for a given subschema) could also be useful.

I'm also wondering how to handle the "patternProperties" while accessing the type of the fields.

Having ability to access the internals of the json_schema with the callback sounds very nice :)

[danielaparker]

I've added a walk member function that takes a callback to json_schema, code currently on master, which allows you to process the schema tree as shown below.

#include <jsoncons/json.hpp>
#include <jsoncons_ext/jsonschema/jsonschema.hpp>
#include <iostream>
#include <cassert>

using jsoncons::ojson;
namespace jsonschema = jsoncons::jsonschema;

int main()
{
    std::string schema_string = R"(
{
  "$id": "https://example.com/arrays.schema.json",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "description": "A representation of a person, company, organization, or place",
  "type": "object",
  "properties": {
    "fruits": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "vegetables": {
      "type": "array",
      "items": {
        "$ref": "#/$defs/veggie"
      }
    }
  },
  "$defs": {
    "veggie": {
      "type": "object",
      "required": [
        "veggieName",
        "veggieLike"
      ],
      "properties": {
        "veggieName": {
          "type": "string",
          "description": "The name of the vegetable."
        },
        "veggieLike": {
          "type": "boolean",
          "description": "Do I like this vegetable?"
        }
      }
    }
  }
}
    )";

    ojson schema = ojson::parse(schema_string);
    jsonschema::json_schema<ojson> compiled = jsonschema::make_json_schema(std::move(schema));

    std::string data_string = R"(
{
  "fruits": [
    "apple",
    "orange",
    "pear"
  ],
  "vegetables": [
    {
      "veggieName": "potato",
      "veggieLike": true
    },
    {
      "veggieName": "broccoli",
      "veggieLike": false
    }
  ]
}
    )";

    // Data
    ojson data = ojson::parse(data_string);

    auto reporter = [](const std::string& keyword,
        const ojson& subschema, 
        const jsoncons::uri& /*schema_location*/,
        const ojson& /*instance*/, 
        const jsoncons::jsonpointer::json_pointer& instance_location) -> jsonschema::walk_result
        {
            if (keyword == "type")
            {
                assert(subschema.is_object());
                auto it = subschema.find("type");
                if (it != subschema.object_range().end())
                {
                    std::cout << instance_location.string() << ": " << it->value() << "\n";
                }
            }
            return jsonschema::walk_result::advance;
        };
    compiled.walk(data, reporter);
}

Output:

/fruits/0: "string"
/fruits/1: "string"
/fruits/2: "string"
/fruits: "array"
/vegetables/0/veggieName: "string"
/vegetables/0/veggieLike: "boolean"
/vegetables/0: "object"
/vegetables/1/veggieName: "string"
/vegetables/1/veggieLike: "boolean"
/vegetables/1: "object"
/vegetables: "array"
: "object"

The types shown are the allowed types as specified in the schema. No validation is performed in the walk function.

We now store the original schema document(s) in the json_schema object, and can provide the subschemas corresponding to schema locations.

This is still a work in progress, need to add a lot of tests.

[roszakg]

Hi @danielaparker,

I looks very good.

However what I mainly had in mind was ability to traverse/walk the schema without the actual Json data.
Just like you would if you wanted to create the example data out of schema file.

I know that understandably you are traversing the instance and cross-checking it with schema so it might be unnatural to do the traversal differently.

[danielaparker]

With cyclical schemas, the processor has to know when to stop, and normally it's the data that tells it when to stop.