Integrating GraphQL into project

README.md

@@ -60,9 +60,9 @@ gzcat < gse.sql.gz | mysql -u gseadmin -pLugano2020 gse
 
 ### Server
 
-Before attempting to run the server, I advise you generate your own GitHub personal access token (PAT).
-Said token should include the `repo` scope, in order for it to effectively crawl the GitHub API.
-While the token is not mandatory, the impact its presence has on the mining speed can not be understated.
+Before attempting to run the server, you must generate your own GitHub personal access token (PAT).
+GHS relies on the GraphQL API, which is inaccessible without authentication. 
+The token must include the `repo` scope, in order for it to access the information present in the GitHub API.
 
 Once that is done, you can run the server locally using Maven:
 

pom.xml

@@ -115,6 +115,14 @@
 			<groupId>org.springframework.boot</groupId>
 			<artifactId>spring-boot-starter-web</artifactId>
 		</dependency>
+		<dependency>
+			<groupId>org.springframework.boot</groupId>
+			<artifactId>spring-boot-starter-webflux</artifactId>
+		</dependency>
+		<dependency>
+			<groupId>org.springframework.boot</groupId>
+			<artifactId>spring-boot-starter-graphql</artifactId>
+		</dependency>
 		<dependency>
 			<groupId>org.springframework.boot</groupId>
 			<artifactId>spring-boot-starter-aop</artifactId>

src/main/java/usi/si/seart/config/GraphQlConfig.java

@@ -0,0 +1,57 @@
+package usi.si.seart.config;
+
+import lombok.AllArgsConstructor;
+import org.jetbrains.annotations.NotNull;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.graphql.client.GraphQlClient;
+import org.springframework.graphql.client.HttpGraphQlClient;
+import org.springframework.web.reactive.function.client.ClientRequest;
+import org.springframework.web.reactive.function.client.ClientResponse;
+import org.springframework.web.reactive.function.client.ExchangeFilterFunction;
+import org.springframework.web.reactive.function.client.ExchangeFunction;
+import org.springframework.web.reactive.function.client.WebClient;
+import reactor.core.publisher.Mono;
+import usi.si.seart.github.Endpoint;
+import usi.si.seart.github.GitHubTokenManager;
+
+@Configuration
+@AllArgsConstructor(onConstructor_ = @Autowired)
+public class GraphQlConfig {
+
+    GitHubTokenManager gitHubTokenManager;
+
+    @Bean
+    public GraphQlClient graphQlClient() {
+        return HttpGraphQlClient.create(webClient());
+    }
+
+    @Bean
+    public WebClient webClient() {
+        return WebClient.builder()
+                .baseUrl(Endpoint.GRAPH_QL.toString())
+                .defaultHeader("X-GitHub-Api-Version", "2022-11-28")
+                .filter(exchangeFilterFunction())
+                .build();
+    }
+
+    @Bean
+    public ExchangeFilterFunction exchangeFilterFunction() {
+        return new ExchangeFilterFunction() {
+
+            @NotNull
+            @Override
+            public Mono<ClientResponse> filter(@NotNull ClientRequest original, @NotNull ExchangeFunction next) {
+                ClientRequest modified = ClientRequest.from(original)
+                        .headers(headers -> {
+                            String token = gitHubTokenManager.getCurrentToken();
+                            if (token != null)
+                                headers.setBearerAuth(token);
+                        })
+                        .build();
+                return next.exchange(modified);
+            }
+        };
+    }
+}

src/main/java/usi/si/seart/converter/JsonObjectToErrorResponseConverter.java

@@ -4,19 +4,19 @@
 import com.google.gson.JsonObject;
 import org.springframework.core.convert.converter.Converter;
 import org.springframework.lang.NonNull;
-import usi.si.seart.github.ErrorResponse;
+import usi.si.seart.github.RestErrorResponse;
 
 import java.net.MalformedURLException;
 import java.net.URL;
 import java.util.Optional;
 import java.util.stream.StreamSupport;
 
-public class JsonObjectToErrorResponseConverter implements Converter<JsonObject, ErrorResponse> {
+public class JsonObjectToErrorResponseConverter implements Converter<JsonObject, RestErrorResponse> {
 
     @Override
     @NonNull
-    public ErrorResponse convert(@NonNull JsonObject source) {
-        ErrorResponse.ErrorResponseBuilder builder = ErrorResponse.builder();
+    public RestErrorResponse convert(@NonNull JsonObject source) {
+        RestErrorResponse.RestErrorResponseBuilder builder = RestErrorResponse.builder();
 
         builder.message(source.get("message").getAsString());
 
@@ -48,7 +48,7 @@ public ErrorResponse convert(@NonNull JsonObject source) {
                     String codeName = Optional.ofNullable(object.get("code"))
                             .map(JsonElement::getAsString)
                             .orElse(null);
-                    return new ErrorResponse.Error(resource, field, codeName, message);
+                    return new RestErrorResponse.Error(resource, field, codeName, message);
                 }).forEach(builder::error);
 
         return builder.build();

src/main/java/usi/si/seart/converter/JsonObjectToGraphQlErrorResponse.java

@@ -0,0 +1,66 @@
+package usi.si.seart.converter;
+
+import com.google.common.reflect.TypeToken;
+import com.google.gson.Gson;
+import com.google.gson.JsonArray;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import graphql.ErrorClassification;
+import graphql.language.SourceLocation;
+import lombok.AllArgsConstructor;
+import org.jetbrains.annotations.NotNull;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.core.convert.converter.Converter;
+import org.springframework.stereotype.Component;
+import usi.si.seart.github.GraphQlErrorResponse;
+
+import java.lang.reflect.Type;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+import java.util.stream.StreamSupport;
+
+@Component
+@AllArgsConstructor(onConstructor_ = @Autowired)
+public class JsonObjectToGraphQlErrorResponse implements Converter<JsonObject, GraphQlErrorResponse> {
+
+    Gson gson;
+    JsonObjectToSourceLocationConverter sourceLocationConverter;
+    StringToGraphQlErrorResponseErrorTypeConverter errorTypeConverter;
+
+    @Override
+    @NotNull
+    public GraphQlErrorResponse convert(@NotNull JsonObject source) {
+        GraphQlErrorResponse.GraphQlErrorResponseBuilder builder = GraphQlErrorResponse.builder();
+
+        String message = source.getAsJsonPrimitive("message").getAsString();
+        builder.message(message);
+        ErrorClassification errorType = errorTypeConverter.convert(message);
+        builder.errorType(errorType);
+
+        if (source.has("path")) {
+            JsonArray array = source.getAsJsonArray("path");
+            Type type = new TypeToken<List<Object>>() { }.getType();
+            List<Object> parsedPath = gson.fromJson(array, type);
+            builder.parsedPath(parsedPath);
+        }
+
+        if (source.has("locations")) {
+            JsonArray array = source.getAsJsonArray("locations");
+            List<SourceLocation> locations = StreamSupport.stream(array.spliterator(), true)
+                    .map(JsonElement::getAsJsonObject)
+                    .map(sourceLocationConverter::convert)
+                    .collect(Collectors.toList());
+            builder.locations(locations);
+        }
+
+        if (source.has("extensions")) {
+            JsonObject object = source.getAsJsonObject("extensions");
+            Type type = new TypeToken<Map<String, Object>>() { }.getType();
+            Map<String, Object> extensions = gson.fromJson(object, type);
+            builder.extensions(extensions);
+        }
+
+        return builder.build();
+    }
+}

src/main/java/usi/si/seart/converter/JsonObjectToSourceLocationConverter.java

@@ -0,0 +1,23 @@
+package usi.si.seart.converter;
+
+import com.google.gson.Gson;
+import com.google.gson.JsonObject;
+import graphql.language.SourceLocation;
+import lombok.AllArgsConstructor;
+import org.jetbrains.annotations.NotNull;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.core.convert.converter.Converter;
+import org.springframework.stereotype.Component;
+
+@Component
+@AllArgsConstructor(onConstructor_ = @Autowired)
+public class JsonObjectToSourceLocationConverter implements Converter<JsonObject, SourceLocation> {
+
+    private final Gson gson;
+
+    @Override
+    @NotNull
+    public SourceLocation convert(@NotNull JsonObject source) {
+        return gson.fromJson(source, SourceLocation.class);
+    }
+}

src/main/java/usi/si/seart/converter/ListToJsonArrayConverter.java

@@ -0,0 +1,25 @@
+package usi.si.seart.converter;
+
+import com.google.gson.Gson;
+import com.google.gson.JsonArray;
+import lombok.AllArgsConstructor;
+import org.jetbrains.annotations.NotNull;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.core.convert.converter.Converter;
+import org.springframework.stereotype.Component;
+
+import java.util.List;
+
+@Component
+@AllArgsConstructor(onConstructor_ = @Autowired)
+public class ListToJsonArrayConverter implements Converter<List<?>, JsonArray> {
+
+    private final Gson gson;
+
+    @Override
+    @NotNull
+    public JsonArray convert(@NotNull List<?> source) {
+        String string = gson.toJson(source);
+        return gson.fromJson(string, JsonArray.class);
+    }
+}

src/main/java/usi/si/seart/converter/MapToJsonObjectConverter.java

@@ -0,0 +1,25 @@
+package usi.si.seart.converter;
+
+import com.google.gson.Gson;
+import com.google.gson.JsonObject;
+import lombok.AllArgsConstructor;
+import org.jetbrains.annotations.NotNull;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.core.convert.converter.Converter;
+import org.springframework.stereotype.Component;
+
+import java.util.Map;
+
+@Component
+@AllArgsConstructor(onConstructor_ = @Autowired)
+public class MapToJsonObjectConverter implements Converter<Map<String, ?>, JsonObject> {
+
+    private final Gson gson;
+
+    @Override
+    @NotNull
+    public JsonObject convert(@NotNull Map<String, ?> source) {
+        String string = gson.toJson(source);
+        return gson.fromJson(string, JsonObject.class);
+    }
+}

src/main/java/usi/si/seart/converter/StringToGraphQlErrorResponseErrorTypeConverter.java

@@ -0,0 +1,81 @@
+package usi.si.seart.converter;
+
+import org.jetbrains.annotations.NotNull;
+import org.springframework.core.convert.converter.Converter;
+import org.springframework.lang.Nullable;
+import org.springframework.stereotype.Component;
+import usi.si.seart.github.GraphQlErrorResponse;
+
+import java.util.regex.Pattern;
+
+@Component
+public class StringToGraphQlErrorResponseErrorTypeConverter implements Converter<String, GraphQlErrorResponse.ErrorType>
+{
+    // https://www.debuggex.com/r/kzZ6PfNvkQLAg3qG
+    private static final Pattern RATE_LIMITED_PATTERN = Pattern.compile(
+            "^API rate limit exceeded for user ID (\\d+)\\.$"
+    );
+
+    // https://www.debuggex.com/r/1unTNcRjYb3M8TrH
+    private static final Pattern FIELD_ERROR_PATTERN = Pattern.compile(
+            "^Field '([^']+)' doesn't exist on type '([^']+)'$"
+    );
+
+    // https://www.debuggex.com/r/yK-tNA559lGPF0aL
+    private static final Pattern NOT_FOUND_PATTERN = Pattern.compile(
+            "^Could not resolve to an? (\\w+) with the (\\w+) (?:of )?'([^']+)'\\.$"
+    );
+
+    // https://www.debuggex.com/r/6BjTNEeyleQXfBjx
+    private static final Pattern ARGUMENT_TYPE_ERROR_PATTERN = Pattern.compile(
+            "^Argument '([^']+)' on Field '([^']+)' has an invalid value \\(([^)]+)\\). Expected type '([^']+)'\\.$"
+    );
+
+    // https://www.debuggex.com/r/mcZ2rcy61FSqVpBO
+    private static final Pattern ARGUMENT_MISSING_ERROR_PATTERN = Pattern.compile(
+            "^Field '([^']+)' is missing required arguments?: (\\w+(?:,\\s*\\w+)*)$"
+    );
+
+    // https://www.debuggex.com/r/emiQbdZlfCYhAlhi
+    private static final Pattern ARGUMENT_UNKNOWN_ERROR_PATTERN = Pattern.compile(
+            "^Field '([^']+)' doesn't accept argument '([^']+)'$"
+    );
+
+    // https://www.debuggex.com/r/_WAiksCCoBiSq9nw
+    private static final Pattern VARIABLE_VALUE_ERROR_PATTERN = Pattern.compile(
+            "^Variable \\$(\\w+) of type (\\w+!?) was provided invalid value$"
+    );
+
+    // https://www.debuggex.com/r/OqQixKpVA8MogqMH
+    private static final Pattern VARIABLE_UNUSED_ERROR_PATTERN = Pattern.compile(
+            "^Variable \\$(\\w+) is declared by (\\w+)(?: query)? but not used$"
+    );
+
+    @Override
+    @Nullable
+    public GraphQlErrorResponse.ErrorType convert(@NotNull String source) {
+        if (source.equals("A query attribute must be specified and must be a string."))
+            return GraphQlErrorResponse.ErrorType.EMPTY_QUERY;
+        if (source.equals("Unexpected end of document"))
+            return GraphQlErrorResponse.ErrorType.EARLY_EOF;
+        if (source.startsWith("Parse error"))
+            return GraphQlErrorResponse.ErrorType.PARSE_ERROR;
+        if (RATE_LIMITED_PATTERN.matcher(source).matches())
+            return GraphQlErrorResponse.ErrorType.RATE_LIMITED;
+        if (FIELD_ERROR_PATTERN.matcher(source).matches())
+            return GraphQlErrorResponse.ErrorType.FIELD_ERROR;
+        if (NOT_FOUND_PATTERN.matcher(source).matches())
+            return GraphQlErrorResponse.ErrorType.NOT_FOUND;
+        if (ARGUMENT_TYPE_ERROR_PATTERN.matcher(source).matches())
+            return GraphQlErrorResponse.ErrorType.ARGUMENT_TYPE_ERROR;
+        if (ARGUMENT_MISSING_ERROR_PATTERN.matcher(source).matches())
+            return GraphQlErrorResponse.ErrorType.ARGUMENT_MISSING_ERROR;
+        if (ARGUMENT_UNKNOWN_ERROR_PATTERN.matcher(source).matches())
+            return GraphQlErrorResponse.ErrorType.ARGUMENT_UNKNOWN_ERROR;
+        if (VARIABLE_VALUE_ERROR_PATTERN.matcher(source).matches())
+            return GraphQlErrorResponse.ErrorType.VARIABLE_VALUE_ERROR;
+        if (VARIABLE_UNUSED_ERROR_PATTERN.matcher(source).matches())
+            return GraphQlErrorResponse.ErrorType.VARIABLE_UNUSED_ERROR;
+        return null;
+    }
+}

src/main/java/usi/si/seart/exception/github/GitHubAPIException.java

@@ -1,12 +1,12 @@
 package usi.si.seart.exception.github;
 
 import lombok.experimental.StandardException;
-import usi.si.seart.github.ErrorResponse;
+import usi.si.seart.github.RestErrorResponse;
 
 @StandardException
 public class GitHubAPIException extends RuntimeException {
 
-    public GitHubAPIException(ErrorResponse errorResponse) {
+    public GitHubAPIException(RestErrorResponse errorResponse) {
         this(errorResponse.toString());
     }
 }