io.github.microcks.util.graphql.GraphQLSchemaValidator Maven / Gradle / Ivy

Go to download
/*
 * Licensed to Laurent Broudoux (the "Author") under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership. Author licenses this
 * file to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
package io.github.microcks.util.graphql;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ObjectNode;
import com.github.fge.jsonschema.core.exceptions.ProcessingException;
import graphql.analysis.QueryTraverser;
import graphql.analysis.QueryVisitor;
import graphql.language.Document;
import graphql.parser.Parser;
import graphql.schema.GraphQLSchema;
import graphql.schema.idl.RuntimeWiring;
import graphql.schema.idl.SchemaGenerator;
import graphql.schema.idl.SchemaParser;
import graphql.schema.idl.TypeDefinitionRegistry;
import io.github.microcks.util.JsonSchemaValidator;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

/**
 * Helper class for validating Json objects against their GraphQL schema. Supported version
 * of GraphQL schema is https://spec.graphql.org/October2021/.
 * @author laurent
 */
public class GraphQLSchemaValidator {

   /** A commons logger for diagnostic messages. */
   private static Logger log = LoggerFactory.getLogger(GraphQLSchemaValidator.class);

   public static final String GRAPHQL_RESPONSE_DATA = "data";

   /** Have a static mapper to avoid initialization cost. */
   private static final ObjectMapper mapper = new ObjectMapper();

   /**
    * Build a JSON Schema that should apply to a GraphQL response giving the API GraphQL SDL
    * and the query specification. Query specification allows to get structure and mandatory
    * fields from selection ; Schema allows to get type definition (scalar, arrays, objects).
    * @param schemaText The text representation of a GraphQL Schema
    * @param query The text representation of a GraphQL query
    * @return The Jackson JsonNode representing the Json schema for response
    * @throws IOException if parsing of either schema of query fails
    */
   public static JsonNode buildResponseJsonSchema(String schemaText, String query) throws IOException {
      TypeDefinitionRegistry registry = new SchemaParser().parse(schemaText);
      GraphQLSchema schema = new SchemaGenerator().makeExecutableSchema(registry, RuntimeWiring.MOCKED_WIRING);

      Document graphqlRequest = new Parser().parseDocument(query);
      QueryTraverser queryTraversal = QueryTraverser.newQueryTraverser()
            .schema(schema).document(graphqlRequest).variables(new HashMap<>())
            .build();

      ObjectNode jsonSchema = initResponseJsonSchema();
      QueryVisitor visitor = new JsonSchemaBuilderQueryVisitor((ObjectNode) jsonSchema.get("properties")
            .get(GRAPHQL_RESPONSE_DATA));

      queryTraversal.visitPreOrder(visitor);
      return jsonSchema;
   }


   /**
    * Commodity method: just a shortcut to JsonSchemaValidator.validateJson(schemaNode, jsonNode)
    * @param schemaNode The Json schema specification as a Jackson node
    * @param jsonNode The Json object as a Jackson node
    * @return The list of validation failures. If empty, json object is valid !
    */
   public static List validateJson(JsonNode schemaNode, JsonNode jsonNode) {
      try {
         return JsonSchemaValidator.validateJson(schemaNode, jsonNode);
      } catch (ProcessingException e) {
         log.debug("Got a ProcessingException while trying to interpret schemaNode as a real schema");
         List errors = new ArrayList<>();
         errors.add("schemaNode does not seem to represent a valid Json schema");
         return errors;
      }
   }

   /** Initialize the schema structure of a GraphQL Json response. */
   private static ObjectNode initResponseJsonSchema() {
      ObjectNode jsonSchema = mapper.createObjectNode();

      jsonSchema.put(JsonSchemaValidator.JSON_SCHEMA_IDENTIFIER_ELEMENT, JsonSchemaValidator.JSON_V12_SCHEMA_IDENTIFIER);
      jsonSchema.put("type", "object");
      jsonSchema.put("additionalProperties", false);
      jsonSchema.putArray("required").add(GRAPHQL_RESPONSE_DATA);

      ObjectNode properties = jsonSchema.putObject("properties");
      ObjectNode data = properties.putObject(GRAPHQL_RESPONSE_DATA);
      data.put("type", "object");
      data.putObject("properties");

      return jsonSchema;
   }
}