Issue #199: code would not compile if the GraphQL schema is too big

etienne-sf · etienne-sf · commit 8ad0f4607044 · 2023-09-23T11:42:56.000+02:00
diff --git a/TODO.md b/TODO.md
@@ -1,58 +1,20 @@
 Here are the next tasks listed, as a TODO list:
 
-## TODO list for the 2.x branch
-* Document it, then release it
-
 ## TODO list for the 1.x branch
-* Issue #184: Unable to use custom scalars upgrade from 1.18.9 to 1.18.10 (Or 2.0RC1)
+* #184 et #198: issues with custom scalars which type is not in the plugin dependencies
+* Add an option to add the Serializable interface for generated POJOs
+    * ==> Done. Answer to the related issue to do, when released
 * Idea #183: replace hard coded fields by maps. This would save memory for objects with lots of field (4000 fields in the identified use case)
-* Add or correct the URL in the README and in the wiki's home.
 * [Gradle] issue #14 : build is not compatible with the `--configuration-cache` gradle parameter (experimental feature)
 * `DirectiveRegistryInitializer`:
     * separate it from each schema (e.g.: allGraphQlCases client)
     * initialize it only once (not at each creation of a GraphQLRequest)
 * Tutorial: add the documentation about the application.yml file
     * Especially: `spring.main.web-application-type = none`
-* Execute FieldTest.test_Issue1114_checkGenerateCode() (in plugin-locic, com.graphql_java_generator.plugin.language)
-* Remove Deprecated getStringContentXxx methods in InputParameter
-* Subscription: the client remain active after a `Connection refused` (even if the main thread stops)
-* When using Web Sockets for the graphql-transport-ws protocol, the Web Socket can be tested with the Ping/Pong messages
-* When using Web Sockets, it should be closed when the last subscription is unsubscribed. Issues :
-    * Be sure that no subscription is starting at the same time (probability is low, but...)
-    * update the RequestExecutionSpringReactiveImpl.webSocketHandler ?  Or mark the webSocketHandler as completed ?
-    * A way could be that the webSocketHandler marks itself as completed (in a synchronized method), and closes the session, so that RequestExecutionSpringReactiveImpl knows that it needs to open a new one.
+* Execute FieldTest.test_Issue1114_checkGenerateCode() (in plugin-logic, com.graphql_java_generator.plugin.language)
 * add a _HowTo compile page_ on the wiki (to build the plugin project, Java 9 or latter is needed, even if the built plugin is compatible with Java 8)
-* Check if spring-boot-starter-security is really needed. It should be added when a project needs OAuth2.
 * @EnableGraphQLRepositories: replace the string (that contains the package name) by a class (so that when changing a package name, the code is still valid)
-* Check comment of the executor method. The line below is wrong:
-    * the request contains the full string that <B><U>follows</U></B> the query/mutation/subscription keyword.<BR/>
-* Add an option to add the Serializable interface for generated POJOs
-* [Done in the plugin, waiting for the graphql PR acceptance] Publish a PR to have a per request cache, in graphql-java-spring 
-    * Done. Waiting for the PR to be accepted (and then a new release)
-    * In the meantime: the graphql-java-spring is forked within the graphql-maven-plugin project
-* Remove the SubscriptionClientWebSocket class
-* Allow to control the list of schema files, and their order (necessary to properly manage the extend keyword)
-* Add a description of the GraphQL mojo
-* Waiting for [issue 2055](https://github.com/graphql-java/graphql-java/issues/2055) to be solved. Some test cases can then be run again (see the allGraphQLCases.graphqls file)
-* [server side] Check graphql-java correction for issue 1844 (Directive values of type 'EnumValue' are not supported yet), waiting for graphql-java v16 release
+* Add a description for the GraphQL mojo
 * enum values may currently not be a java keyword (seems to be a graphql-java limitation). issue to raise in the graphql-java project
 * Document generateJPAAnnotation 
 
-## TODO List for 2.0 version:
-* Rename the QueryExecutor (and its implementations) into RequestExecutor
-* Remove the query/mutation/subscription Response type (currently deprecated)
-* copyRuntimeSources: false should be the default value (change to be done in the tutorial and the client-dependency)
-* separateUtilityClasses: true should be the default value
-* Add a generateDeprecatedRequestResponse plugin parameter. Default value to true (no more XxxxResponse would be generated). With a value of true, the XxxxResponse would still be generated for compatibility with old code.
-* Remove the `graphql-java-runtime`, and put the runtime in either the `graphql-java-server-dependencies` or `graphql-java-client-dependencies`
-
-
-Investigate DTO for database mapping (done in the Gradle and Maven tutorials):
-https://stackoverflow.com/questions/60456804/how-to-use-graphql-with-jpa-if-schema-is-different-to-database-structure
-https://stackoverflow.com/questions/58801227/graphql-tools-map-entity-type-to-graphql-type/58809449#58809449
-
-
-Tutorials:
-- https://www.howtographql.com/
-- dev zone
-
diff --git a/graphql-java-client-runtime/src/main/java/com/graphql_java_generator/client/GraphqlClientUtils.java b/graphql-java-client-runtime/src/main/java/com/graphql_java_generator/client/GraphqlClientUtils.java
@@ -37,6 +37,14 @@ public class GraphqlClientUtils {
 	/** A singleton without Spring */
 	public static GraphqlClientUtils graphqlClientUtils = new GraphqlClientUtils();
 
+	/**
+	 * graphqlTypeMappingImplementations will contain the GraphQLTypeMapping.getJavaClass(String) method for each schema
+	 * used in this execution. This map is used to avoid to dynamically find this method, each time it has to be called.
+	 * 
+	 * @see #getClass(String, String, String)
+	 */
+	private static Map<String, Method> graphqlTypeMappingGetJavaClassImplementations = new HashMap<>();
+
 	Pattern graphqlNamePattern = Pattern.compile("^[_A-Za-z][_0-9A-Za-z]*$");
 
 	GraphqlUtils graphqlUtils = new GraphqlUtils();
@@ -49,13 +57,13 @@ public class GraphqlClientUtils {
 
 	public GraphqlClientUtils() {
 		// Add of all predefined scalars
-		scalars.add(String.class);
-		scalars.add(int.class);
-		scalars.add(Integer.class);
-		scalars.add(float.class);
-		scalars.add(Float.class);
-		scalars.add(boolean.class);
-		scalars.add(Boolean.class);
+		this.scalars.add(String.class);
+		this.scalars.add(int.class);
+		this.scalars.add(Integer.class);
+		this.scalars.add(float.class);
+		this.scalars.add(Float.class);
+		this.scalars.add(boolean.class);
+		this.scalars.add(Boolean.class);
 	}
 
 	/**
@@ -71,7 +79,7 @@ public void checkName(String graphqlIdentifier) throws GraphQLRequestPreparation
 		if (graphqlIdentifier == null) {
 			throw new NullPointerException("A GraphQL identifier may not be null");
 		}
-		Matcher m = graphqlNamePattern.matcher(graphqlIdentifier);
+		Matcher m = this.graphqlNamePattern.matcher(graphqlIdentifier);
 		if (!m.matches()) {
 			throw new GraphQLRequestPreparationException("'" + graphqlIdentifier + "' is not a valid GraphQL name");
 		}
@@ -201,15 +209,16 @@ public boolean isScalar(AccessibleObject fieldOrMethod) throws GraphQLRequestPre
 	 * @return
 	 */
 	public Class<?> getClass(String packageName, String graphQLTypeName, String schema) {
+		String graphQLTypeMappingClassname;
 
 		// First case, the simplest: standard GraphQL type
-		if ("Boolean".equals(graphQLTypeName) || "boolean".equals(graphQLTypeName))
+		if ("Boolean".equals(graphQLTypeName) || "boolean".equals(graphQLTypeName)) //$NON-NLS-1$ //$NON-NLS-2$
 			return Boolean.class;
-		else if ("Integer".equals(graphQLTypeName) || "Int".equals(graphQLTypeName))
+		else if ("Integer".equals(graphQLTypeName) || "Int".equals(graphQLTypeName)) //$NON-NLS-1$ //$NON-NLS-2$
 			return Integer.class;
-		else if ("String".equals(graphQLTypeName) || "UUID".equals(graphQLTypeName))
+		else if ("String".equals(graphQLTypeName) || "UUID".equals(graphQLTypeName)) //$NON-NLS-1$ //$NON-NLS-2$
 			return String.class;
-		else if ("Float".equals(graphQLTypeName) || "Double".equals(graphQLTypeName))
+		else if ("Float".equals(graphQLTypeName) || "Double".equals(graphQLTypeName)) //$NON-NLS-1$ //$NON-NLS-2$
 			return Double.class;
 
 		// Then custom scalars
@@ -223,23 +232,57 @@ else if ("Float".equals(graphQLTypeName) || "Double".equals(graphQLTypeName))
 
 		// Then other GraphQL types. This types should be linked to a generated java class. So we search for a class of
 		// this name in the given package.
+		// lookup the java class corresponding to the graphql type from the generated GraphQLTypeMapping
 		try {
-			// lookup the java class corresponding to the graphql type from the generated GraphQLTypeMapping
-			return (Class<?>) getClass().getClassLoader().loadClass(packageName + ".GraphQLTypeMapping")
-					.getMethod("getJavaClass", String.class).invoke(null, graphQLTypeName);
-		} catch (ClassNotFoundException e) {
-			// If GraphqlTypeMapping does not exist (in some tests), fallback to using the type name.
-			final String className = packageName + "." + GraphqlUtils.graphqlUtils.getJavaName(graphQLTypeName);
+			return (Class<?>) getGetJavaClassMethod(packageName).invoke(null, graphQLTypeName);
+		} catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
+			throw new RuntimeException("Error while calling GraphQLTypeMapping.getJavaClass(\"" + packageName //$NON-NLS-1$
+					+ "\"): ClassNotFoundException (" + e.getMessage() + ")", e); //$NON-NLS-1$ //$NON-NLS-2$
+		}
+	}
+
+	/**
+	 * This method loads tries to load the GraphQLTypeMapping.getJavaClass(String) method in the
+	 * {@link #graphqlTypeMappingGetJavaClassImplementations} map, and return it, so that this method is loaded only
+	 * once for each GraphQL schema managed in this execution.
+	 * 
+	 * @param packageName
+	 * @return
+	 */
+	private Method getGetJavaClassMethod(String packageName) {
+		Method ret = graphqlTypeMappingGetJavaClassImplementations.get(packageName);
+
+		if (ret == null) {
+			String graphQLTypeMappingClassname1 = packageName + ".GraphQLTypeMapping"; //$NON-NLS-1$
+			String graphQLTypeMappingClassname2 = packageName + ".util.GraphQLTypeMapping"; //$NON-NLS-1$
+
+			// Let's find the GraphQLTypeMapping class.
+			Class<?> clazz;
+			try {
+				clazz = getClass().getClassLoader().loadClass(graphQLTypeMappingClassname1);
+			} catch (ClassNotFoundException e) {
+				try {
+					clazz = getClass().getClassLoader().loadClass(graphQLTypeMappingClassname2);
+				} catch (ClassNotFoundException e1) {
+					throw new RuntimeException(
+							"ClassNotFoundException: could find neither '" + graphQLTypeMappingClassname1 //$NON-NLS-1$
+									+ "' class nor '" + graphQLTypeMappingClassname2 + "' class"); //$NON-NLS-1$ //$NON-NLS-2$
+				}
+			}
+
+			// let's find its getJavaClass method
 			try {
-				return getClass().getClassLoader().loadClass(className);
-			} catch (ClassNotFoundException ex) {
-				throw new RuntimeException(
-						"Could not load class '" + className + "' for type '" + graphQLTypeName + "'", e);
+				ret = clazz.getMethod("getJavaClass", String.class); //$NON-NLS-1$
+			} catch (NoSuchMethodException | SecurityException e) {
+				throw new RuntimeException(e.getClass().getSimpleName()
+						+ ": could find the 'getJavaClass' method in the " + clazz.getName() + " class"); //$NON-NLS-1$ //$NON-NLS-2$
 			}
-		} catch (ClassCastException | NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
-			throw new RuntimeException("Could not get the class for type '" + graphQLTypeName + "' from '"
-					+ (packageName + ".GraphQLTypeMapping") + "'", e);
+
+			// Let's store it, to avoid to have to find it again, latter on.
+			graphqlTypeMappingGetJavaClassImplementations.put(packageName, ret);
 		}
+
+		return ret;
 	}
 
 	/**
diff --git a/graphql-java-client-runtime/src/test/java/com/graphql_java_generator/domain/client/allGraphQLCases/GraphQLTypeMapping.java b/graphql-java-client-runtime/src/test/java/com/graphql_java_generator/domain/client/allGraphQLCases/GraphQLTypeMapping.java
@@ -0,0 +1,17 @@
+/** Generated by the default template from graphql-java-generator */
+package com.graphql_java_generator.domain.client.allGraphQLCases;
+
+import com.graphql_java_generator.util.GraphqlUtils;
+
+public class GraphQLTypeMapping {
+
+	public static Class<?> getJavaClass(String typeName) {
+		try {
+			return GraphQLTypeMapping.class.getClassLoader().loadClass(GraphQLTypeMapping.class.getPackage().getName()
+					+ "." + GraphqlUtils.graphqlUtils.getJavaName(typeName));
+		} catch (ClassNotFoundException e) {
+			throw new RuntimeException("Internal test error: could not load the '"
+					+ GraphQLTypeMapping.class.getPackage().getName() + "." + typeName + "' class", e);
+		}
+	}
+}
diff --git a/graphql-java-client-runtime/src/test/java/com/graphql_java_generator/domain/client/forum/GraphQLTypeMapping.java b/graphql-java-client-runtime/src/test/java/com/graphql_java_generator/domain/client/forum/GraphQLTypeMapping.java
@@ -0,0 +1,17 @@
+/** Generated by the default template from graphql-java-generator */
+package com.graphql_java_generator.domain.client.forum;
+
+import com.graphql_java_generator.util.GraphqlUtils;
+
+public class GraphQLTypeMapping {
+
+	public static Class<?> getJavaClass(String typeName) {
+		try {
+			return GraphQLTypeMapping.class.getClassLoader().loadClass(GraphQLTypeMapping.class.getPackage().getName()
+					+ "." + GraphqlUtils.graphqlUtils.getJavaName(typeName));
+		} catch (ClassNotFoundException e) {
+			throw new RuntimeException("Internal test error: could not load the '"
+					+ GraphQLTypeMapping.class.getPackage().getName() + "." + typeName + "' class", e);
+		}
+	}
+}
diff --git a/graphql-java-client-runtime/src/test/java/com/graphql_java_generator/domain/client/starwars/GraphQLTypeMapping.java b/graphql-java-client-runtime/src/test/java/com/graphql_java_generator/domain/client/starwars/GraphQLTypeMapping.java
@@ -0,0 +1,17 @@
+/** Generated by the default template from graphql-java-generator */
+package com.graphql_java_generator.domain.client.starwars;
+
+import com.graphql_java_generator.util.GraphqlUtils;
+
+public class GraphQLTypeMapping {
+
+	public static Class<?> getJavaClass(String typeName) {
+		try {
+			return GraphQLTypeMapping.class.getClassLoader().loadClass(GraphQLTypeMapping.class.getPackage().getName()
+					+ "." + GraphqlUtils.graphqlUtils.getJavaName(typeName));
+		} catch (ClassNotFoundException e) {
+			throw new RuntimeException("Internal test error: could not load the '"
+					+ GraphQLTypeMapping.class.getPackage().getName() + "." + typeName + "' class", e);
+		}
+	}
+}
diff --git a/graphql-maven-plugin-logic/src/main/java/com/graphql_java_generator/plugin/CodeTemplate.java b/graphql-maven-plugin-logic/src/main/java/com/graphql_java_generator/plugin/CodeTemplate.java
@@ -38,6 +38,7 @@ public enum CodeTemplate {
 	SUBSCRIPTION(CodeTemplateScope.CLIENT, "templates/client_subscription_type.vm.java"), //
 	SUBSCRIPTION_EXECUTOR(CodeTemplateScope.CLIENT, "templates/client_subscription_executor.vm.java"), //
 	TYPE_MAPPING(CodeTemplateScope.CLIENT, "templates/client_type_mapping.vm.java"), //
+	TYPE_MAPPING_CSV(CodeTemplateScope.CLIENT, "templates/client_type_mapping.vm.csv"), // //$NON-NLS-1$
 
 	// Server files (alphabetic order)
 	BATCH_LOADER_DELEGATE_IMPL(CodeTemplateScope.SERVER, "templates/server_BatchLoaderDelegateImpl.vm.java"), //
diff --git a/graphql-maven-plugin-logic/src/main/java/com/graphql_java_generator/plugin/generate_code/GenerateCodeGenerator.java b/graphql-maven-plugin-logic/src/main/java/com/graphql_java_generator/plugin/generate_code/GenerateCodeGenerator.java
@@ -188,6 +188,9 @@ private int generateClientFiles() throws IOException {
 						resolveTemplate(CodeTemplate.SUBSCRIPTION), true);
 			}
 
+			logger.debug("Generating client side mapping from graphql type to java type"); //$NON-NLS-1$
+			i += generateClientTypeMapping();
+
 			// Generation of the query/mutation/subscription executor classes
 			logger.debug("Generating query executors");
 			i += generateTargetFile(generateCodeDocumentParser.getQueryType(), "executor",
@@ -253,9 +256,6 @@ private int generateClientFiles() throws IOException {
 			i += generateSpringAutoConfigurationDeclaration();
 		}
 
-		logger.debug("Generating client side mapping from graphql type to java type");
-		i += generateClientTypeMapping();
-
 		return i;
 	}
 
@@ -268,10 +268,20 @@ private int generateClientTypeMapping() {
 		VelocityContext context = getVelocityContext();
 		context.put("types", generateCodeDocumentParser.getTypes());
 
-		generateOneFile(getJavaFile("GraphQLTypeMapping", false), "generating GraphQLTypeMapping", context,
+		generateOneFile(getJavaFile("GraphQLTypeMapping", true), "generating GraphQLTypeMapping", context,
 				resolveTemplate(CodeTemplate.TYPE_MAPPING));
 
-		return 1;
+		// Generation of the typeMapping.csv file
+		String relativePath = "typeMapping" //$NON-NLS-1$
+				+ ((this.configuration.getSpringBeanSuffix() == null) ? "" : this.configuration.getSpringBeanSuffix())
+				+ ".csv";
+		File targetFile = new File(this.configuration.getTargetResourceFolder(), relativePath);
+		logger.debug("Generating typeMapping.csv into {}", targetFile); //$NON-NLS-1$
+		targetFile.getParentFile().mkdirs();
+		generateOneFile(targetFile, "Generating typeMapping.csv", context, //$NON-NLS-1$
+				resolveTemplate(CodeTemplate.TYPE_MAPPING_CSV));
+
+		return 2;
 	}
 
 	/**
diff --git a/graphql-maven-plugin-logic/src/main/resources/templates/client_type_mapping.vm.csv b/graphql-maven-plugin-logic/src/main/resources/templates/client_type_mapping.vm.csv
@@ -0,0 +1,13 @@
+##
+## Velocity template for type GraphQLTypeMapping (client side).
+##
+## The generated file contains:
+## - one line par GraphQL type, that allows to build a map at runtime from the graphql type name to the java class
+##
+##
+## This template has these inputs:
+## types 	 			A map from graphql name to the java class
+##
+#foreach ($entry in $types.entrySet())
+${entry.key},${entry.value.classFullName}
+#end
diff --git a/graphql-maven-plugin-logic/src/main/resources/templates/client_type_mapping.vm.java b/graphql-maven-plugin-logic/src/main/resources/templates/client_type_mapping.vm.java
@@ -8,18 +8,60 @@
 ## This template has these inputs:
 ## types 	 			A map from graphql name to the java class
 ##
+##
+##
+##
+## Maven ignores the default value for springBeanSuffix, and replaces it by a null value. In this case, we replace the value by an empty String 
+#if (!${configuration.springBeanSuffix}) #set($springBeanSuffix="") #else #set($springBeanSuffix = ${configuration.springBeanSuffix}) #end
+##
+##
 /** Generated by the default template from graphql-java-generator */
-package ${configuration.packageName};
+package ${packageUtilName};
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.springframework.util.ClassUtils;
 
 public class GraphQLTypeMapping {
 
-	public static Class<?> getJavaClass(String typeName) {
-		switch(typeName) {
-			#foreach ($entry in $types.entrySet())
-			case "${entry.key}": return ${entry.value.classFullName}.class;
-			#end
-			default:
-				return null;
+	private final static Map<String, Class<?>> map = new HashMap<>();
+
+	static {
+		String line;
+		Class<?> clazz;
+		ClassLoader classLoader = GraphQLTypeMapping.class.getClassLoader();
+
+		final String RESOURCE_PATH = "typeMapping${springBeanSuffix}"
+				+ ".csv";
+
+		try (BufferedReader reader = new BufferedReader(
+				new InputStreamReader(classLoader.getResourceAsStream(RESOURCE_PATH)))) {
+			while ((line = reader.readLine()) != null) {
+				String[] keyValue = line.split(",");
+				if (keyValue.length != 2) {
+					throw new RuntimeException("Invalid line in typeMapping.csv: " + line);
+				}
+				try {
+					clazz = ClassUtils.forName(keyValue[1], classLoader);
+				} catch (Exception e) {
+					throw new RuntimeException("Error while looking for the class of the type '" + keyValue[0] + "': "
+							+ e.getClass().getSimpleName() + "-" + e.getMessage(), e);
+				}
+				map.put(keyValue[0], clazz);
+			} // while
+		} catch (NullPointerException e) {
+			throw new RuntimeException("NullPointerException while reading type mapping : " + RESOURCE_PATH);
+		} catch (IOException e) {
+			throw new RuntimeException("Error while reading type mapping (" + RESOURCE_PATH + "): " + e.getMessage(),
+					e);
 		}
 	}
+
+	public static Class<?> getJavaClass(String typeName) {
+		return map.get(typeName);
+	}
 }
diff --git a/graphql-maven-plugin-logic/src/test/java/graphql/mavenplugin_notscannedbyspring/AbstractCustomTemplatesSpringConfiguration.java b/graphql-maven-plugin-logic/src/test/java/graphql/mavenplugin_notscannedbyspring/AbstractCustomTemplatesSpringConfiguration.java
diff --git a/graphql-maven-plugin-samples/graphql-maven-plugin-samples-allGraphQLCases-client/src/test/java/org/allGraphQLCases/GraphQLTypeMappingTest.java b/graphql-maven-plugin-samples/graphql-maven-plugin-samples-allGraphQLCases-client/src/test/java/org/allGraphQLCases/GraphQLTypeMappingTest.java
