Add new module graphql-kotlin-spring-server (ExpediaGroup#329)

* WIP: boot server

* fix detekt

* fix unit test + copyright notice

* rename to graphql-kotlin-spring-server

* fix packages

* simplify package structure

* add unit tests

* include integration test in jacoco coverage calculation

* fix javadoc link

* subscription test

* Fix subscription unit tests

* additional unit tests

* subscription handler tests are actually integration tests

Author: dariuszkuc

README.md

@@ -10,6 +10,7 @@ GraphQL Kotlin consists of number of libraries that aim to simplify GraphQL inte
 
 * [graphql-kotlin-schema-generator](/graphql-kotlin-schema-generator) - Code only GraphQL schema generation for Kotlin
 * [graphql-kotlin-federation](/graphql-kotlin-federation) - Schema generator extension to build federated GraphQL schemas
+* [graphql-kotlin-spring-server](/graphql-kotlin-spring-server) - Spring Boot auto-configuration library to create GraphQL web app
 * [examples](/examples) - Example apps that use graphql-kotlin libraries to test and demonstrate usages
 
 ## ⌨️ Usage

examples/federation/base-app/pom.xml

@@ -14,7 +14,7 @@
     <packaging>jar</packaging>
 
     <properties>
-        <spring-boot.version>2.1.2.RELEASE</spring-boot.version>
+        <spring-boot.version>2.2.0.M5</spring-boot.version>
 
         <!-- skip release plugins -->
         <maven.source.skip>true</maven.source.skip>
@@ -23,19 +23,9 @@
     <dependencies>
         <dependency>
             <groupId>com.expediagroup</groupId>
-            <artifactId>graphql-kotlin-schema-generator</artifactId>
+            <artifactId>graphql-kotlin-spring-server</artifactId>
             <version>${project.parent.version}</version>
         </dependency>
-        <dependency>
-            <groupId>com.expediagroup</groupId>
-            <artifactId>graphql-kotlin-federation</artifactId>
-            <version>${project.parent.version}</version>
-        </dependency>
-        <dependency>
-            <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-starter-webflux</artifactId>
-            <version>${spring-boot.version}</version>
-        </dependency>
     </dependencies>
 
     <build>
@@ -81,11 +71,10 @@
                     </dependency>
                 </dependencies>
             </plugin>
-            <!-- TODO enable detekt/ktlint -->
-<!--            <plugin>-->
-<!--                <groupId>org.apache.maven.plugins</groupId>-->
-<!--                <artifactId>maven-antrun-plugin</artifactId>-->
-<!--            </plugin>-->
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-antrun-plugin</artifactId>
+            </plugin>
             <plugin>
                 <groupId>org.jetbrains.dokka</groupId>
                 <artifactId>dokka-maven-plugin</artifactId>

examples/federation/base-app/src/main/kotlin/com/expediagroup/graphql/sample/Application.kt

@@ -16,81 +16,13 @@
 
 package com.expediagroup.graphql.sample
 
-import com.expediagroup.graphql.TopLevelObject
-import com.expediagroup.graphql.execution.KotlinDataFetcherFactoryProvider
-import com.expediagroup.graphql.extensions.print
-import com.expediagroup.graphql.federation.FederatedSchemaGeneratorConfig
-import com.expediagroup.graphql.federation.FederatedSchemaGeneratorHooks
-import com.expediagroup.graphql.federation.execution.FederatedTypeRegistry
-import com.expediagroup.graphql.federation.toFederatedSchema
-import com.expediagroup.graphql.hooks.SchemaGeneratorHooks
-import com.expediagroup.graphql.sample.datafetchers.CustomDataFetcherFactoryProvider
-import com.expediagroup.graphql.sample.datafetchers.SpringDataFetcherFactory
-import com.expediagroup.graphql.sample.exceptions.CustomDataFetcherExceptionHandler
-import com.expediagroup.graphql.sample.query.Query
-import graphql.GraphQL
-import graphql.execution.AsyncExecutionStrategy
-import graphql.execution.AsyncSerialExecutionStrategy
-import graphql.execution.DataFetcherExceptionHandler
-import graphql.execution.SubscriptionExecutionStrategy
-import graphql.schema.GraphQLSchema
-import org.slf4j.LoggerFactory
 import org.springframework.boot.autoconfigure.SpringBootApplication
 import org.springframework.boot.runApplication
-import org.springframework.context.annotation.Bean
 
 @SpringBootApplication
-class Application {
-
-    private val logger = LoggerFactory.getLogger(Application::class.java)
-
-    @Bean
-    fun hooks() = FederatedSchemaGeneratorHooks(FederatedTypeRegistry())
-
-    @Bean
-    fun dataFetcherFactoryProvider(springDataFetcherFactory: SpringDataFetcherFactory, hooks: SchemaGeneratorHooks) =
-        CustomDataFetcherFactoryProvider(springDataFetcherFactory, hooks)
-
-    @Bean
-    fun schemaConfig(hooks: FederatedSchemaGeneratorHooks, dataFetcherFactoryProvider: KotlinDataFetcherFactoryProvider) = FederatedSchemaGeneratorConfig(
-        supportedPackages = listOf("com.expediagroup"),
-        hooks = hooks,
-        dataFetcherFactoryProvider = dataFetcherFactoryProvider
-    )
-
-    @Bean
-    fun schema(
-        queries: List<Query>,
-        schemaConfig: FederatedSchemaGeneratorConfig
-    ): GraphQLSchema {
-        fun List<Any>.toTopLevelObjects() = this.map {
-            TopLevelObject(it)
-        }
-
-        val schema = toFederatedSchema(
-            config = schemaConfig,
-            queries = queries.toTopLevelObjects()
-        )
-
-        logger.info(schema.print())
-
-        return schema
-    }
-
-    @Bean
-    fun dataFetcherExceptionHandler(): DataFetcherExceptionHandler = CustomDataFetcherExceptionHandler()
-
-    @Bean
-    fun graphQL(
-        schema: GraphQLSchema,
-        dataFetcherExceptionHandler: DataFetcherExceptionHandler
-    ): GraphQL = GraphQL.newGraphQL(schema)
-        .queryExecutionStrategy(AsyncExecutionStrategy(dataFetcherExceptionHandler))
-        .mutationExecutionStrategy(AsyncSerialExecutionStrategy(dataFetcherExceptionHandler))
-        .subscriptionExecutionStrategy(SubscriptionExecutionStrategy(dataFetcherExceptionHandler))
-        .build()
-}
+class Application
 
+@Suppress("SpreadOperator")
 fun main(args: Array<String>) {
     runApplication<Application>(*args)
 }

examples/federation/base-app/src/main/kotlin/com/expediagroup/graphql/sample/GraphQLResponse.kt

@@ -16,69 +16,23 @@
 
 package com.expediagroup.graphql.sample
 
-import com.expediagroup.graphql.extensions.print
-import com.fasterxml.jackson.databind.ObjectMapper
-import com.fasterxml.jackson.databind.type.MapType
-import com.fasterxml.jackson.databind.type.TypeFactory
-import graphql.schema.GraphQLSchema
 import org.springframework.beans.factory.annotation.Value
 import org.springframework.context.annotation.Bean
 import org.springframework.context.annotation.Configuration
 import org.springframework.core.io.Resource
-import org.springframework.http.HttpMethod
-import org.springframework.http.MediaType
-import org.springframework.web.reactive.function.server.ServerRequest
-import org.springframework.web.reactive.function.server.bodyToMono
+import org.springframework.web.reactive.function.server.bodyAndAwait
+import org.springframework.web.reactive.function.server.coRouter
 import org.springframework.web.reactive.function.server.html
-import org.springframework.web.reactive.function.server.json
-import org.springframework.web.reactive.function.server.router
-import reactor.core.publisher.Mono
 
 @Configuration
 class RoutesConfiguration(
-    val schema: GraphQLSchema,
-    private val queryHandler: QueryHandler,
-    private val objectMapper: ObjectMapper,
     @Value("classpath:/graphql-playground.html") private val playgroundHtml: Resource
 ) {
 
-    private val mapTypeReference: MapType = TypeFactory.defaultInstance().constructMapType(HashMap::class.java, String::class.java, Any::class.java)
-
-    @Bean
-    fun graphQLRoutes() = router {
-        (POST("/graphql") or GET("/graphql")).invoke { serverRequest ->
-            createGraphQLRequest(serverRequest)
-                .flatMap { graphQLRequest -> queryHandler.executeQuery(graphQLRequest) }
-                .flatMap { result -> ok().json().syncBody(result) }
-                .switchIfEmpty(badRequest().build())
-        }
-    }
-
-    @Bean
-    fun sdlRoute() = router {
-        GET("/sdl") {
-            ok().contentType(MediaType.TEXT_PLAIN).syncBody(schema.print())
-        }
-    }
-
     @Bean
-    fun graphQLToolRoutes() = router {
+    fun playgroundRoute() = coRouter {
         GET("/playground") {
-            ok().html().syncBody(playgroundHtml)
-        }
-    }
-
-    private fun createGraphQLRequest(serverRequest: ServerRequest): Mono<GraphQLRequest> = when {
-        serverRequest.method() == HttpMethod.POST -> serverRequest.bodyToMono()
-        serverRequest.queryParam("query").isPresent -> {
-            val query = serverRequest.queryParam("query").get()
-            val operationName: String? = serverRequest.queryParam("operationName").orElseGet { null }
-            val variables: String? = serverRequest.queryParam("variables").orElseGet { null }
-            val graphQLVariables: Map<String, Any>? = variables?.let {
-                objectMapper.readValue(it, mapTypeReference)
-            }
-            Mono.just(GraphQLRequest(query = query, operationName = operationName, variables = graphQLVariables))
+            ok().html().bodyAndAwait(playgroundHtml)
         }
-        else -> Mono.empty()
     }
 }