Client Generation - Allow schema to be on the classpath (#1136)

* Client Generation - Allow schema SDL to be on the classpath

* Suggestions and Refactors

* Minor touchup

* More improvements to the code, remove redundant edits

Author: AlexRiedler

plugins/client/graphql-kotlin-client-generator/src/main/kotlin/com/expediagroup/graphql/plugin/client/generateClient.kt

@@ -21,7 +21,6 @@ import com.expediagroup.graphql.plugin.client.generator.GraphQLClientGeneratorCo
 import com.expediagroup.graphql.plugin.client.generator.GraphQLSerializer
 import com.expediagroup.graphql.plugin.client.generator.GraphQLScalar
 import com.squareup.kotlinpoet.FileSpec
-import graphql.schema.idl.SchemaParser
 import java.io.File
 
 /**
@@ -32,7 +31,7 @@ fun generateClient(
     allowDeprecated: Boolean = false,
     customScalarsMap: List<GraphQLScalar> = emptyList(),
     serializer: GraphQLSerializer = GraphQLSerializer.JACKSON,
-    schema: File,
+    schemaPath: String,
     queries: List<File>
 ): List<FileSpec> {
     val customScalars = customScalarsMap.associateBy { it.scalar }
@@ -42,7 +41,6 @@ fun generateClient(
         customScalarMap = customScalars,
         serializer = serializer
     )
-    val graphQLSchema = SchemaParser().parse(schema)
-    val generator = GraphQLClientGenerator(graphQLSchema, config)
+    val generator = GraphQLClientGenerator(schemaPath, config)
     return generator.generate(queries)
 }

plugins/client/graphql-kotlin-client-generator/src/main/kotlin/com/expediagroup/graphql/plugin/client/generator/GraphQLClientGenerator.kt

@@ -17,6 +17,7 @@
 package com.expediagroup.graphql.plugin.client.generator
 
 import com.expediagroup.graphql.plugin.client.generator.exceptions.MultipleOperationsInFileException
+import com.expediagroup.graphql.plugin.client.generator.exceptions.SchemaUnavailableException
 import com.expediagroup.graphql.plugin.client.generator.types.generateGraphQLObjectTypeSpec
 import com.expediagroup.graphql.plugin.client.generator.types.generateVariableTypeSpec
 import com.squareup.kotlinpoet.ClassName
@@ -31,6 +32,7 @@ import com.squareup.kotlinpoet.TypeSpec
 import graphql.language.ObjectTypeDefinition
 import graphql.language.OperationDefinition
 import graphql.parser.Parser
+import graphql.schema.idl.SchemaParser
 import graphql.schema.idl.TypeDefinitionRegistry
 import kotlinx.serialization.Serializable
 import java.io.File
@@ -41,12 +43,17 @@ private const val CORE_TYPES_PACKAGE = "com.expediagroup.graphql.client.types"
  * GraphQL client code generator that uses [KotlinPoet](https://github.com/square/kotlinpoet) to generate Kotlin classes based on the specified GraphQL queries.
  */
 class GraphQLClientGenerator(
-    private val graphQLSchema: TypeDefinitionRegistry,
+    schemaPath: String,
     private val config: GraphQLClientGeneratorConfig
 ) {
     private val documentParser: Parser = Parser()
     private val typeAliases: MutableMap<String, TypeAliasSpec> = mutableMapOf()
     private val sharedTypes: MutableMap<ClassName, List<TypeSpec>> = mutableMapOf()
+    private val graphQLSchema: TypeDefinitionRegistry
+
+    init {
+        graphQLSchema = parseSchema(schemaPath)
+    }
 
     /**
      * Generate GraphQL clients for the specified queries.
@@ -196,6 +203,16 @@ class GraphQLClientGenerator(
         val rootType = operationNames[operationDefinition.operation.name]
         return graphQLSchema.getType(rootType).get() as ObjectTypeDefinition
     }
+
+    private fun parseSchema(path: String): TypeDefinitionRegistry {
+        val schemaFile = File(path)
+        return if (schemaFile.isFile) {
+            SchemaParser().parse(schemaFile)
+        } else {
+            val schemaInputStream = this.javaClass.classLoader.getResourceAsStream(path) ?: throw SchemaUnavailableException(path)
+            SchemaParser().parse(schemaInputStream)
+        }
+    }
 }
 
 internal fun String.toUpperUnderscore(): String {

plugins/client/graphql-kotlin-client-generator/src/main/kotlin/com/expediagroup/graphql/plugin/client/generator/exceptions/SchemaUnavailableException.kt

@@ -0,0 +1,6 @@
+package com.expediagroup.graphql.plugin.client.generator.exceptions
+
+/**
+ * Exception thrown when specified schema file path is not found or unavailable
+ */
+internal class SchemaUnavailableException(schemaPath: String) : RuntimeException("Specified schema file=$schemaPath does not exist")

plugins/client/graphql-kotlin-client-generator/src/test/kotlin/com/expediagroup/graphql/plugin/client/generator/GenerateInvalidClientIT.kt

@@ -16,6 +16,8 @@
 
 package com.expediagroup.graphql.plugin.client.generator
 
+import com.expediagroup.graphql.plugin.client.generator.exceptions.SchemaUnavailableException
+import org.junit.jupiter.api.Test
 import org.junit.jupiter.params.ParameterizedTest
 import org.junit.jupiter.params.provider.Arguments
 import org.junit.jupiter.params.provider.MethodSource
@@ -31,13 +33,21 @@ class GenerateInvalidClientIT {
         val (queries, _) = locateTestFiles(testDirectory)
         val expectedException = File(testDirectory, "exception.txt").readText().trim()
 
-        val generator = GraphQLClientGenerator(testSchema(), defaultConfig)
+        val generator = GraphQLClientGenerator(TEST_SCHEMA_PATH, defaultConfig)
         val exception = assertFails {
             generator.generate(queries)
         }
         assertEquals(expectedException, exception::class.simpleName)
     }
 
+    @Test
+    fun `verify an invalid schema path will raise an exception`() {
+        val exception = assertFails {
+            GraphQLClientGenerator("missingSchema.graphql", defaultConfig)
+        }
+        assertEquals(SchemaUnavailableException::class, exception::class)
+    }
+
     companion object {
         @JvmStatic
         fun invalidTests(): List<Arguments> = locateTestCaseArguments("src/test/data/invalid")

plugins/client/graphql-kotlin-client-generator/src/test/kotlin/com/expediagroup/graphql/plugin/client/generator/GraphQLTestUtils.kt

@@ -19,8 +19,6 @@ package com.expediagroup.graphql.plugin.client.generator
 import com.expediagroup.graphql.client.converter.ScalarConverter
 import com.tschuchort.compiletesting.KotlinCompilation
 import com.tschuchort.compiletesting.SourceFile
-import graphql.schema.idl.SchemaParser
-import graphql.schema.idl.TypeDefinitionRegistry
 import org.junit.jupiter.params.provider.Arguments
 import java.io.File
 import java.util.UUID
@@ -52,17 +50,12 @@ internal fun locateTestFiles(directory: File): Pair<List<File>, Map<String, File
     return queries to expectedFiles
 }
 
-internal fun testSchema(): TypeDefinitionRegistry {
-    val schemaFileStream = ClassLoader.getSystemClassLoader().getResourceAsStream("testSchema.graphql") ?: throw RuntimeException("unable to locate test schema")
-    return schemaFileStream.use {
-        SchemaParser().parse(schemaFileStream)
-    }
-}
+internal const val TEST_SCHEMA_PATH = "testSchema.graphql"
 
 internal fun verifyClientGeneration(config: GraphQLClientGeneratorConfig, testDirectory: File) {
     val (queries, expectedFiles) = locateTestFiles(testDirectory)
 
-    val generator = GraphQLClientGenerator(testSchema(), config)
+    val generator = GraphQLClientGenerator(TEST_SCHEMA_PATH, config)
     val fileSpecs = generator.generate(queries)
     assertTrue(fileSpecs.isNotEmpty())
     assertEquals(expectedFiles.size, fileSpecs.size)

plugins/graphql-kotlin-gradle-plugin/src/main/kotlin/com/expediagroup/graphql/plugin/gradle/actions/GenerateClientAction.kt

@@ -35,11 +35,11 @@ abstract class GenerateClientAction : WorkAction<GenerateClientParameters> {
         val allowDeprecated = parameters.allowDeprecated.get()
         val customScalarMap = parameters.customScalars.get().map { GraphQLScalar(it.scalar, it.type, it.converter) }
         val serializer = GraphQLSerializer.valueOf(parameters.serializer.get().name)
-        val schemaFile = parameters.schemaFile.get()
+        val schemaPath = parameters.schemaPath.get()
         val queryFiles = parameters.queryFiles.get()
         val targetDirectory = parameters.targetDirectory.get()
 
-        generateClient(targetPackage, allowDeprecated, customScalarMap, serializer, schemaFile, queryFiles).forEach {
+        generateClient(targetPackage, allowDeprecated, customScalarMap, serializer, schemaPath, queryFiles).forEach {
             it.writeTo(targetDirectory)
         }
     }

plugins/graphql-kotlin-gradle-plugin/src/main/kotlin/com/expediagroup/graphql/plugin/gradle/parameters/GenerateClientParameters.kt

@@ -36,8 +36,8 @@ interface GenerateClientParameters : WorkParameters {
     val customScalars: ListProperty<GraphQLScalar>
     /** Type of JSON serializer that will be used to generate the data classes. */
     val serializer: Property<GraphQLSerializer>
-    /** GraphQL schema file that will be used to generate client code. */
-    val schemaFile: Property<File>
+    /** GraphQL schema file path that will be used to generate client code. */
+    val schemaPath: Property<String>
     /** List of query files that will be processed to generate HTTP clients. */
     val queryFiles: ListProperty<File>
     /** Directory where to save the generated source files. */

plugins/graphql-kotlin-gradle-plugin/src/main/kotlin/com/expediagroup/graphql/plugin/gradle/tasks/AbstractGenerateClientTask.kt

@@ -146,14 +146,11 @@ abstract class AbstractGenerateClientTask : DefaultTask() {
     fun generateGraphQLClientAction() {
         logger.debug("generating GraphQL client")
 
-        val graphQLSchema = when {
-            schemaFile.isPresent -> schemaFile.get().asFile
-            schemaFileName.isPresent -> File(schemaFileName.get())
+        val graphQLSchemaPath = when {
+            schemaFile.isPresent -> schemaFile.get().asFile.path
+            schemaFileName.isPresent -> schemaFileName.get()
             else -> throw RuntimeException("schema not available")
         }
-        if (!graphQLSchema.isFile) {
-            throw RuntimeException("specified schema file does not exist")
-        }
 
         val targetPackage = packageName.orNull ?: throw RuntimeException("package not specified")
         val targetQueryFiles: List<File> = when {
@@ -174,7 +171,7 @@ abstract class AbstractGenerateClientTask : DefaultTask() {
             throw RuntimeException("failed to generate generated source directory = $targetDirectory")
         }
 
-        logConfiguration(graphQLSchema, targetQueryFiles)
+        logConfiguration(graphQLSchemaPath, targetQueryFiles)
         val workQueue: WorkQueue = getWorkerExecutor().classLoaderIsolation { workerSpec: ClassLoaderWorkerSpec ->
             workerSpec.classpath.from(pluginClasspath)
             logger.debug("worker classpath: \n${workerSpec.classpath.files.joinToString("\n")}")
@@ -185,17 +182,17 @@ abstract class AbstractGenerateClientTask : DefaultTask() {
             parameters.allowDeprecated.set(allowDeprecatedFields)
             parameters.customScalars.set(customScalars)
             parameters.serializer.set(serializer)
-            parameters.schemaFile.set(graphQLSchema)
+            parameters.schemaPath.set(graphQLSchemaPath)
             parameters.queryFiles.set(targetQueryFiles)
             parameters.targetDirectory.set(targetDirectory)
         }
         workQueue.await()
         logger.debug("successfully generated GraphQL HTTP client")
     }
 
-    private fun logConfiguration(schema: File, queryFiles: List<File>) {
+    private fun logConfiguration(schemaPath: String, queryFiles: List<File>) {
         logger.debug("GraphQL Client generator configuration:")
-        logger.debug("  schema file = ${schema.path}")
+        logger.debug("  schema file = $schemaPath")
         logger.debug("  queries")
         queryFiles.forEach {
             logger.debug("    - ${it.name}")

plugins/graphql-kotlin-gradle-plugin/src/main/kotlin/com/expediagroup/graphql/plugin/gradle/tasks/GraphQLDownloadSDLTask.kt

@@ -83,7 +83,7 @@ abstract class GraphQLDownloadSDLTask : DefaultTask() {
     }
 
     /**
-     * Download schema in SDL format from the specified endpoint and sve it locally in the target output file.
+     * Download schema in SDL format from the specified endpoint and save it locally in the target output file.
      */
     @TaskAction
     fun downloadSDLAction() {

plugins/graphql-kotlin-maven-plugin/src/main/kotlin/com/expediagroup/graphql/plugin/maven/GenerateClientAbstractMojo.kt

@@ -17,8 +17,8 @@
 package com.expediagroup.graphql.plugin.maven
 
 import com.expediagroup.graphql.plugin.client.generateClient
-import com.expediagroup.graphql.plugin.client.generator.GraphQLSerializer
 import com.expediagroup.graphql.plugin.client.generator.GraphQLScalar
+import com.expediagroup.graphql.plugin.client.generator.GraphQLSerializer
 import org.apache.maven.plugin.AbstractMojo
 import org.apache.maven.plugins.annotations.Parameter
 import org.apache.maven.project.MavenProject
@@ -39,7 +39,7 @@ abstract class GenerateClientAbstractMojo : AbstractMojo() {
      * GraphQL schema file that will be used to generate client code.
      */
     @Parameter(defaultValue = "\${graphql.schemaFile}", name = "schemaFile")
-    private var schemaFile: File? = null
+    private var schemaFile: String? = null
 
     /**
      * Target package name for generated code.
@@ -99,17 +99,18 @@ abstract class GenerateClientAbstractMojo : AbstractMojo() {
 
     override fun execute() {
         log.debug("generating GraphQL client")
-        val graphQLSchemaFile = schemaFile ?: File(project.build.directory, "schema.graphql")
-        validateGraphQLSchemaExists(graphQLSchemaFile)
+
+        val schemaPath = schemaFile ?: File(project.build.directory, "schema.graphql").path
+
         val targetQueryFiles: List<File> = locateQueryFiles(queryFiles, queryFileDirectory)
 
         if (!outputDirectory.isDirectory && !outputDirectory.mkdirs()) {
             throw RuntimeException("failed to generate generated source directory")
         }
 
-        logConfiguration(graphQLSchemaFile, targetQueryFiles)
+        logConfiguration(schemaPath, targetQueryFiles)
         val customGraphQLScalars = customScalars.map { GraphQLScalar(it.scalar, it.type, it.converter) }
-        generateClient(packageName, allowDeprecatedFields, customGraphQLScalars, serializer, graphQLSchemaFile, targetQueryFiles).forEach {
+        generateClient(packageName, allowDeprecatedFields, customGraphQLScalars, serializer, schemaPath, targetQueryFiles).forEach {
             it.writeTo(outputDirectory)
         }
 
@@ -125,17 +126,11 @@ abstract class GenerateClientAbstractMojo : AbstractMojo() {
         return targetQueryFiles
     }
 
-    private fun validateGraphQLSchemaExists(graphQLSchemaFile: File) {
-        if (!graphQLSchemaFile.isFile) {
-            throw RuntimeException("specified GraphQL schema is not a file, ${graphQLSchemaFile.path}")
-        }
-    }
-
     abstract fun configureProjectWithGeneratedSources(mavenProject: MavenProject, generatedSourcesDirectory: File)
 
-    private fun logConfiguration(graphQLSchemaFile: File, queryFiles: List<File>) {
+    private fun logConfiguration(graphQLSchemaFilePath: String, queryFiles: List<File>) {
         log.debug("GraphQL Client generator configuration:")
-        log.debug("  schema file = ${graphQLSchemaFile.path}")
+        log.debug("  schema file = $graphQLSchemaFilePath")
         log.debug("  queries")
         queryFiles.forEach {
             log.debug("    - ${it.name}")