OpenRPC schema validation

[lschrafstetter-qs]

Hello,
I am currently working on a JSON-RPC interface which uses an OpenRPC interface definition.
I want to use jsoncons to validate the parameters of incoming requests.
This is an the example OpenRPC definition I am currently working with:

{
   "openrpc":"1.2.4",
   "info":{
      "version":"1.0.0",
      "title":"some OpenRPC definition",
      "license":{
         "name":"closed"
      }
   },
   "methods":[
      {
         "name":"basic method",
         "description":"A method that takes a single boolean parameter.",
         "params":[
            
         ],
         "result":{
            "name":"result",
            "description":"The result of the basic method.",
            "schema":{
               "type":"string"
            }
         }
      },
      {
         "name":"schema method",
         "description":"A method that takes a parameter based on an example schema.",
         "params":[
            {
               "name":"exampleschema",
               "description":"An example schema parameter.",
               "schema":{
                  "$ref":"#/components/schemas/exampleschema"
               },
               "required":true
            }
         ],
         "result":{
            "name":"result",
            "description":"The result of the schema method.",
            "schema":{
               "type":"string"
            }
         }
      }
   ],
   "components":{
      "schemas":{
         "exampleschema":{
            "type":"object",
            "properties":{
               "example bool":{
                  "type":"boolean",
                  "description":"An example boolean."
               },
               "example int":{
                  "type":"integer",
                  "description":"An example integer."
               }
            },
            "required":[
               "example bool",
               "example int"
            ]
         }
      }
   }
}

This is validated with the OpenRPC meta schema:
https://github.com/open-rpc/meta-schema/blob/master/schema.json

The meta schema doesn't allow additional properties like "definitions".

Is there an easy way to validate parameters of incoming messages without building a new schema out of the OpenRPC definition?
I have played around with it like this, but it doesn't work:

ojson schema = ojson::parse(OPEN_RPC_JSON_BASIC).at("components").at("schemas");
jsonschema::json_schema<ojson> compiled = jsonschema::make_json_schema(std::move(schema),
    jsonschema::evaluation_options{}.default_version(jsonschema::schema_version::draft7()));

ojson data;
data[RESPONSE_MEMBER_JSONRPC_KEY] = RESPONSE_MEMBER_JSONRPC_VALUE;
data["method"] = "schema method";
data["params"]["exampleschema"]["example bool"] = 2; // false
data["params"]["exampleschema"]["example int"] = 1;

compiled.validate(data.at("params")); // doesn't throw

I am using version 1.1.0 with MSVC and C++23.

[danielaparker]

As I understand it, OpenAPI 3.1 JSON Schema Dialects are compatible with the JSON Schema core architecture, but may add keywords, remove keywords, or modify the behavior of keywords. Comparing with networknt/json-schema-validator, they support OpenAPI 3 and 3.1 using meta-schemas and OpenAPI specific configuration options.

I can put this on the list as something to look into, but it will likely take a while.

[lschrafstetter-qs]

This is not OpenAPI, but OpenRPC. But same issue I guess. So what you are saying is that they say they stick to JSON schema Draft-7, but change keywords so that parsers don't recognize it as such? So if I want to validate schemas this way I have to parse the OpenRPC definition myself (resolving references, etc.) and create a valid JSON schema myself?

I don't think that it is a thing worth putting "on the list" if people don't stick to the JSON schema standards.

[lschrafstetter-qs]

My (basic, no production code) solution was just building a new schema.
It just takes all parameters and moves them to "properties" and moves all schemas to "$defs". It also changes the path of all references from the OpenRPC root "#/components/schemas/" to the valid schema root "#/$defs/".

static void ReplaceReferences(ojson& param_schema, const std::string& to_replace, const std::string& replacement)
{
    if (not param_schema.is_object())
        return; // base case
    
    for (auto& member : param_schema.object_range())
    {
        if (member.key() == "$ref")
        {
            std::string reference{ member.value().as_string() };
            size_t pos = reference.find(to_replace);
            if (pos != std::string::npos)
            {
                reference.replace(pos, to_replace.length(), replacement);
            }
            member.value() = reference;
        }
        else
        {
            ReplaceReferences(member.value(), to_replace, replacement); // recursive call
        }
    }
}

static auto MakeValidSchemaFromOpenrpcDefinition(const ojson& openrpc_definition) -> ojson
{
    ojson valid_schema;
    valid_schema["$id"] = "https://example.com/arrays.schema.json";
    valid_schema["$schema"] = "https://json-schema.org/draft/2020-12/schema";
    valid_schema["description"] = "OpenRPC schema parsed into a valid format";
    valid_schema["type"] = "object";

    for (const auto& method : openrpc_definition.at("methods").array_range())
    {
        std::cout << method.as_string() << std::endl;
        for (auto param : method.at("params").array_range())
        {
            std::cout << param.as_string() << std::endl;
            auto& param_schema = param.at("schema");
            ReplaceReferences(param_schema, "#/components/schemas/", "#/$defs/");
            valid_schema["properties"][param.at("name").as_string()] = param_schema;
        }
    }

    valid_schema["$defs"] = openrpc_definition.at("components").at("schemas");
    ReplaceReferences(valid_schema["$defs"], "#/components/schemas/", "#/$defs/");

    return valid_schema;
}

So the output of the above example is this:

{
    "$id": "https://example.com/arrays.schema.json",
    "$schema": "https://json-schema.org/draft/2020-12/schema",
    "description": "OpenRPC schema parsed into a valid format",
    "type": "object",
    "properties": {
        "exampleschema": {
            "$ref": "#/$defs/exampleschema"
        }
    },
    "$defs": {
        "exampleschema": {
            "type": "object",
            "properties": {
                "example bool": {
                    "type": "boolean",
                    "description": "An example boolean."
                },
                "example int": {
                    "type": "integer",
                    "description": "An example integer."
                }
            },
            "required": [
                "example bool",
                "example int"
            ]
        }
    }
}