Validate request body against dynamic OpenAPI specification with json-schema-validator - json-schema-validator

Question

I need to build an API to validate the request body against the registered schema for the respective type & subType.
API Contract:
{
"id": "<any-uuid>",
"type": "<some-type>",
"subType": "<some-sub-type>",
"data": {
}
}
Here, OpenAPI schema will be fetched based on the type and subType and then need to validate the data element against the respective OpenAPI schema.
Wrote the below snippet:
Map<String, Object> data = //get the data object from API request body;
JsonSchemaFactory jsonSchemaFactory = JsonSchemaFactory.getInstance(VersionFlag.V7);
ObjectMapper objectMapper = new ObjectMapper();
JsonNode node = objectMapper.convertValue(data, JsonNode.class);
String schemaJson = // fetch the registered schema for type and subtype
JsonSchema schema = jsonSchemaFactory.getSchema(schemaJson);
Set<ValidationMessage> errors = schema.validate(node);
// Throw exception when errors present in the Json Payload
if (errors.size() > 0) {
// throw the exception with errors
}
This code is working, when the schema don't have:
Few elements such as openapi, paths, info, components.
When one object not referring other.
API Schema in our database as follows:
{
"openapi": "3.0.0",
"paths": {},
"info": {
"title": "Patient Info API",
"version": "v0.1.0"
},
"components": {
"schemas": {
"Data": {
"type": "object",
"required": [
"action",
"patient"
],
"properties": {
"action": {
"type": "string",
"enum": [
"ADMIT",
"DISCHARGE",
"TRANSFER"
]
},
"patient": {
"$ref": "#/components/schemas/Patient"
}
}
},
"Patient": {
"type": "object",
"required": [
"firstName",
"lastName"
],
"properties": {
"firstName": {
"type": "string"
},
"lastName": {
"type": "string"
}
}
}
}
}
}
The data element in the API request body looks like this.
{
"action": "ADMIT",
"patient": {
"firstName": "John",
"lastName": "Doe"
}
}
Can json-schema-validator can help to achieve this?

Answer 1

For simplicity, wrote all the logic inside the Spring Controller itself.
package com.schema.validator.controller;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ObjectNode;
import com.google.common.io.Files;
import com.networknt.schema.*;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.core.io.Resource;
import org.springframework.http.ResponseEntity;
import org.springframework.util.CollectionUtils;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.io.IOException;
import java.nio.charset.Charset;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
/**
* A REST API to validate the request body against Open API Schema
*
*/
#RestController
#RequestMapping("schema-validate")
public class SchemaValidatorController {
private static final ObjectMapper objectMapper = new ObjectMapper();
private static final JsonSchemaFactory jsonSchemaFactory =
JsonSchemaFactory.getInstance(SpecVersion.VersionFlag.V6);
#Value("classpath:schema/json-schema.json")
private Resource schemaResource;
#PostMapping
public ResponseEntity<List<String>> validateSchema(#RequestBody Map<String, Object> jsonRequest) throws IOException {
String schemaJson = Files.asCharSource(schemaResource.getFile(), Charset.defaultCharset()).read();
final JsonNode requestJsonNode = objectMapper.valueToTree(jsonRequest);
JsonNode componentNode = objectMapper.readTree(schemaJson).get("components");
// Get first name in the JsonNode
JsonNode schemaNode = componentNode.get("schemas").elements().next();
((ObjectNode) schemaNode).set("components", componentNode);
SchemaValidatorsConfig config = new SchemaValidatorsConfig();
config.setTypeLoose(false);
config.setHandleNullableField(true);
JsonSchema jsonSchema = jsonSchemaFactory.getSchema(schemaNode, config);
Set<ValidationMessage> errors =
jsonSchema.validate(requestJsonNode, requestJsonNode, "data");
if (CollectionUtils.isEmpty(errors)) {
return ResponseEntity.ok(Collections.emptyList());
}
return ResponseEntity.ok(errors.stream()
.map(ValidationMessage::getMessage)
.collect(Collectors.toList()));
}
}
Here, json-schema.json created under resources/schema folder.
Limitation: The root element in Open API schema should be declared as a first child of schemas in Open API spec.