Schema validation with subschema and internal reference

[nicomuns]

Hello,

I'm having trouble validating a JSON against a JSON schema. My case is a bit specific, I'll try to describe it as clearly as possible.

I have a function that takes two string arguments:

• p_rootSchemaPath: the path of the root schema
• p_location: a location inside the root schema, in the form /key1/key2/..., used to extract a specific part of the root schema (It is empty most of the time).

I create my validator with make_json_schema and give it my own URI resolver to resolve external references and it works fine.

Now my case is the following, p_rootSchemaPath can also be a JSON which is not a schema. But then p_location is not empty, it is used to extract a part of p_rootSchemaPath, part which contains an internal reference pointing to an actual schema defined somewhere else in the document, like so "$ref": "#/.../...".

The code looks like this:

void func(const std::string& p_rootSchemaPath, const std::string& p_location) {
    ojson schema = ojson::parse(retrieveSchemaContent(p_rootSchemaPath));

    if (p_location != "") {
        ojson schemaPart = jsonpointer::get(schema, p_location);
        schema = schemaPart;
    }

    auto resolver = [](const uri& p_uri) {
        // ...
    };

    jsonschema::evaluation_options options;
    evalOptions.default_base_uri(p_rootSchemaPath);
    
    validator = std::make_unique<jsonschema::json_schema<ojson>>(jsonschema::make_json_schema(schema, resolver, options));
}

And this is what a simplified root schema looks like here (which again is not a schema in this particular case):

{
    "key_A": {
        "key_A_1": {
            "foo": {
                "payload": {
                    "type": "object",
                    "patternProperties": {
                        "some_regex": {
                            "type": "object",
                            "$ref": "#/key_A/key_A_2/bar"
                        }
                    }
                }
            }
        },
        "key_A_2": {
            "bar": {
                "$schema": "http://json-schema.org/draft-07/schema#",
                "type": "object",
                "properties": {
                    "name": { "type": "string" },
                    "containers": {
                        "type": "array",
                        "items": [
                            {
                                "type": "object",
                                "properties": {
                                    "number_A": { "type": "number" },
                                    "number_B": { "type": "number" }
                                }
                            }
                        ]
                    }
                }
            }
        }
    }
}

With p_location = "/key_A/key_A_1/foo/payload"

So in my function, after the if block, I end up with schema being equal to:

{
    "type": "object",
    "patternProperties": {
        "some_regex": {
            "type": "object",
            "$ref": "#/key_A/key_A_2/bar"
        }
    }
}

But then I don't know how to proceed. The URI resolver does not get called for the internal reference (which I think is normal because it is only called for external references?).

I get the error Unresolved reference 'path_of_root_schema.json#/key_A/key_A_2/bar' when calling make_json_schema.
In this error message, path_of_root_schema.json does not have the same value as p_rootSchemaPath.
If p_rootSchemaPath = "/this/is/my/folder/file.json", the error says Unresolved reference 'is/my/folder/file.json#/key_A/key_A_2/bar'.

I tried simplify my use case the most I could to avoid making an even longer post. Let me know if some information is missing.

Thanks in advance!

[danielaparker]

Okay, from jsoncons's point of view, $ref in payload is accessing an external resource (one outside a schema resource.) Therefore, I think you should substitute

"$ref": "/key_A/key_A_2/bar"  

for

"$ref": "#/key_A/key_A_2/bar"  

Note that we write the reference with a leading slash to prevent URI resolution from merging '/key_A/key_A_2/bar' with the default base URI path '/this/is/my/folder/file' (which we don't want.)

Then all references should be resolved in the usual way:

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

namespace jsonschema = jsoncons::jsonschema;
namespace jsonpointer = jsoncons::jsonpointer;

std::string input_str = R"(
{
    "key_A": {
        "key_A_1": {
            "foo": {
                "payload": {
                    "type": "object",
                    "patternProperties": {
                        "some_regex": {
                            "type": "object",
                            "$ref": "/key_A/key_A_2/bar"  
                        }
                    }
                }
            }
        },
        "key_A_2": {
            "bar": {
                "$schema": "http://json-schema.org/draft-07/schema#",
                "type": "object",
                "properties": {
                    "name": { "type": "string" },
                    "containers": {
                        "type": "array",
                        "items": [
                            {
                                "type": "object",
                                "properties": {
                                    "number_A": { "type": "number" },
                                    "number_B": { "type": "number" }
                                }
                            }
                        ]
                    }
                }
            }
        }
    }
}
)";

int main()
{
    auto input = jsoncons::ojson::parse(input_str);

    auto schema = jsonpointer::get(input, "/key_A/key_A_1/foo/payload");

    auto resolver = [&](const jsoncons::uri& uri) -> jsoncons::ojson
        {
            std::cout << "path: " << uri.path() << "\n";
            std::error_code ec;
            jsoncons::ojson schemaPart = jsonpointer::get(input, uri.path(), ec);

            return ec ? jsoncons::ojson::null() : schemaPart;
        };

    try
    {
        auto options = jsonschema::evaluation_options{}
            .default_base_uri("/this/is/my/folder/file");
        auto compiled = jsonschema::make_json_schema(schema, resolver, options);
    }
    catch (const std::exception& e)
    {
        std::cout << e.what() << "\n"; 
    }
}

Output:

path: /key_A/key_A_2/bar

[nicomuns]

Thanks a lot, it is working now.
I left the # in the schema but removed it when loading the schema content in RAM.