Handle java-reserved names in client generated classes #237

src/main/java/com/kobylynskyi/graphql/codegen/mapper/FieldDefinitionToParameterMapper.java

@@ -69,6 +69,7 @@ private static ParameterDefinition mapField(MappingContext mappingContext, Exten
                                                 String parentTypeName) {
         ParameterDefinition parameter = new ParameterDefinition();
         parameter.setName(MapperUtils.capitalizeIfRestricted(fieldDef.getName()));
+        parameter.setOriginalName(fieldDef.getName());
         parameter.setType(getJavaType(mappingContext, fieldDef.getType(), fieldDef.getName(), parentTypeName).getName());
         parameter.setAnnotations(getAnnotations(mappingContext, fieldDef.getType(), fieldDef.getName(), parentTypeName, false));
         parameter.setJavaDoc(fieldDef.getJavaDoc());
@@ -88,11 +89,11 @@ private static ProjectionParameterDefinition mapProjectionField(MappingContext m
                                                                     ExtendedFieldDefinition fieldDef,
                                                                     ExtendedDefinition<?, ?> parentTypeDef) {
         ProjectionParameterDefinition parameter = new ProjectionParameterDefinition();
-        parameter.setName(MapperUtils.capitalizeIfRestricted(fieldDef.getName()));
-        parameter.setMethodName(parameter.getName());
+        parameter.setName(fieldDef.getName());
+        parameter.setMethodName(MapperUtils.capitalizeMethodNameIfRestricted(parameter.getName()));
         String nestedType = getNestedTypeName(fieldDef.getType());
         if (mappingContext.getTypesUnionsInterfacesNames().contains(nestedType)) {
-            parameter.setType(nestedType + mappingContext.getResponseProjectionSuffix());
+            parameter.setType(Utils.capitalize(nestedType + mappingContext.getResponseProjectionSuffix()));
         }
         if (!Utils.isEmpty(fieldDef.getInputValueDefinitions())) {
             parameter.setParametrizedInputClassName(

src/main/java/com/kobylynskyi/graphql/codegen/mapper/FieldDefinitionsToResolverDataModelMapper.java

@@ -139,7 +139,8 @@ private static OperationDefinition map(MappingContext mappingContext, ExtendedFi
         String javaType = GraphqlTypeToJavaTypeMapper.getJavaType(
                 mappingContext, resolvedField.getType(), resolvedField.getName(), parentTypeName).getName();
         OperationDefinition operation = new OperationDefinition();
-        operation.setName(resolvedField.getName());
+        operation.setName(MapperUtils.capitalizeIfRestricted(resolvedField.getName()));
+        operation.setOriginalName(resolvedField.getName());
         operation.setType(GraphqlTypeToJavaTypeMapper.wrapIntoAsyncIfRequired(mappingContext, javaType, parentTypeName));
         operation.setAnnotations(GraphqlTypeToJavaTypeMapper.getAnnotations(mappingContext,
                 resolvedField.getType(), resolvedField.getName(), parentTypeName, false));
@@ -158,7 +159,7 @@ private static List<ParameterDefinition> getOperationParameters(MappingContext m
         if (!Utils.isGraphqlOperation(parentTypeName)) {
             String parentObjectParamType = GraphqlTypeToJavaTypeMapper.getJavaType(mappingContext, new TypeName(parentTypeName));
             String parentObjectParamName = MapperUtils.capitalizeIfRestricted(Utils.uncapitalize(parentObjectParamType));
-            parameters.add(new ParameterDefinition(parentObjectParamType, parentObjectParamName, null, emptyList(), emptyList(), resolvedField.isDeprecated()));
+            parameters.add(new ParameterDefinition(parentObjectParamType, parentObjectParamName, parentObjectParamName, null, emptyList(), emptyList(), resolvedField.isDeprecated()));
         }
 
         // 2. Next parameters are input values

src/main/java/com/kobylynskyi/graphql/codegen/mapper/InputValueDefinitionToParameterMapper.java

@@ -47,6 +47,7 @@ public static List<ParameterDefinition> map(MappingContext mappingContext, List<
     private static ParameterDefinition map(MappingContext mappingContext, InputValueDefinition inputValueDefinition, String parentTypeName) {
         ParameterDefinition parameter = new ParameterDefinition();
         parameter.setName(MapperUtils.capitalizeIfRestricted(inputValueDefinition.getName()));
+        parameter.setOriginalName(inputValueDefinition.getName());
         parameter.setType(getJavaType(mappingContext, inputValueDefinition.getType()));
         parameter.setDefaultValue(DefaultValueMapper.map(mappingContext, inputValueDefinition.getDefaultValue(), inputValueDefinition.getType()));
         parameter.setAnnotations(getAnnotations(mappingContext, inputValueDefinition.getType(), inputValueDefinition.getName(), parentTypeName, false));

src/main/java/com/kobylynskyi/graphql/codegen/mapper/MapperUtils.java

@@ -24,7 +24,7 @@
 import java.util.function.Function;
 import java.util.stream.Collectors;
 
-class MapperUtils {
+public class MapperUtils {
 
     private static final Set<String> JAVA_RESTRICTED_KEYWORDS = new HashSet<>(Arrays.asList(
             "abstract", "assert", "boolean", "break", "byte", "case", "catch", "char", "class", "const", "continue",
@@ -33,25 +33,48 @@ class MapperUtils {
             "private", "protected", "public", "return", "short", "static", "strictfp", "super", "switch",
             "synchronized", "this", "throw", "throws", "transient", "true", "try", "void", "volatile", "while"));
 
+    private static final Set<String> JAVA_RESTRICTED_METHOD_NAMES = new HashSet<>(Arrays.asList(
+            "getClass", "notify", "notifyAll", "wait"));
+
     private MapperUtils() {
     }
 
     /**
      * Capitalize field name if it is Java-restricted.
      * Examples:
-     * * class -> Class
-     * * int -> Int
+     * * 'class' becomes 'Class'
+     * * 'int' becomes 'Int'
      *
      * @param fieldName any string
      * @return capitalized value if it is restricted in Java, same value as parameter otherwise
      */
-    static String capitalizeIfRestricted(String fieldName) {
+    public static String capitalizeIfRestricted(String fieldName) {
         if (JAVA_RESTRICTED_KEYWORDS.contains(fieldName)) {
             return Utils.capitalize(fieldName);
         }
         return fieldName;
     }
 
+    /**
+     * Capitalize method name if it is Java-restricted.
+     * Examples:
+     * * 'getClass' becomes 'GetClass'
+     * * 'wait' becomes 'Wait'
+     * * 'this' becomes 'This'
+     *
+     * @param methodName any string
+     * @return capitalized value if it is restricted in Java, same value as parameter otherwise
+     */
+    public static String capitalizeMethodNameIfRestricted(String methodName) {
+        if (JAVA_RESTRICTED_KEYWORDS.contains(methodName)) {
+            return Utils.capitalize(methodName);
+        }
+        if (JAVA_RESTRICTED_METHOD_NAMES.contains(methodName)) {
+            return Utils.capitalize(methodName);
+        }
+        return methodName;
+    }
+
     /**
      * Generates a model class name including prefix and suffix (if any)
      *

src/main/java/com/kobylynskyi/graphql/codegen/mapper/RequestResponseDefinitionToDataModelMapper.java

@@ -25,6 +25,7 @@
 import static com.kobylynskyi.graphql.codegen.model.DataModelFields.FIELDS;
 import static com.kobylynskyi.graphql.codegen.model.DataModelFields.GENERATED_INFO;
 import static com.kobylynskyi.graphql.codegen.model.DataModelFields.JAVA_DOC;
+import static com.kobylynskyi.graphql.codegen.model.DataModelFields.METHOD_NAME;
 import static com.kobylynskyi.graphql.codegen.model.DataModelFields.OPERATION_NAME;
 import static com.kobylynskyi.graphql.codegen.model.DataModelFields.OPERATION_TYPE;
 import static com.kobylynskyi.graphql.codegen.model.DataModelFields.PACKAGE;
@@ -118,6 +119,7 @@ public static Map<String, Object> mapResponse(MappingContext mappingContext,
         dataModel.put(JAVA_DOC, operationDef.getJavaDoc());
         dataModel.put(DEPRECATED, operationDef.isDeprecated());
         dataModel.put(OPERATION_NAME, operationDef.getName());
+        dataModel.put(METHOD_NAME, MapperUtils.capitalizeMethodNameIfRestricted(operationDef.getName()));
         dataModel.put(RETURN_TYPE_NAME, javaType);
         dataModel.put(GENERATED_INFO, mappingContext.getGeneratedInformation());
         return dataModel;
@@ -277,7 +279,7 @@ private static ProjectionParameterDefinition getChildDefinition(MappingContext m
         ProjectionParameterDefinition parameter = new ProjectionParameterDefinition();
         parameter.setName("...on " + childName);
         parameter.setMethodName("on" + childName);
-        parameter.setType(childName + mappingContext.getResponseProjectionSuffix());
+        parameter.setType(Utils.capitalize(childName + mappingContext.getResponseProjectionSuffix()));
         return parameter;
     }
 

src/main/java/com/kobylynskyi/graphql/codegen/model/DataModelFields.java

@@ -24,6 +24,7 @@ public final class DataModelFields {
     public static final String ANNOTATIONS = "annotations";
     public static final String OPERATION_TYPE = "operationType";
     public static final String OPERATION_NAME = "operationName";
+    public static final String METHOD_NAME = "methodName";
     public static final String RETURN_TYPE_NAME = "returnTypeName";
     public static final String GENERATED_INFO = "generatedInfo";
 

src/main/java/com/kobylynskyi/graphql/codegen/model/OperationDefinition.java

@@ -10,7 +10,14 @@
  */
 public class OperationDefinition {
 
+    /**
+     * Normalized name using {@link com.kobylynskyi.graphql.codegen.mapper.MapperUtils#capitalizeIfRestricted(String) MapperUtils.capitalizeIfRestricted() }
+     */
     private String name;
+    /**
+     * Original name that appears in GraphQL schema
+     */
+    private String originalName;
     private String type;
     private List<String> annotations = new ArrayList<>();
     private List<ParameterDefinition> parameters = new ArrayList<>();
@@ -25,6 +32,14 @@ public void setName(String name) {
         this.name = name;
     }
 
+    public String getOriginalName() {
+        return originalName;
+    }
+
+    public void setOriginalName(String originalName) {
+        this.originalName = originalName;
+    }
+
     public String getType() {
         return type;
     }

src/main/java/com/kobylynskyi/graphql/codegen/model/ParameterDefinition.java

@@ -15,10 +15,17 @@
 public class ParameterDefinition {
 
     public static final ParameterDefinition DATA_FETCHING_ENVIRONMENT = new ParameterDefinition(
-            DataFetchingEnvironment.class.getName(), "env", null, emptyList(), emptyList(), false);
+            DataFetchingEnvironment.class.getName(), "env", "env", null, emptyList(), emptyList(), false);
 
     private String type;
+    /**
+     * Normalized name using {@link com.kobylynskyi.graphql.codegen.mapper.MapperUtils#capitalizeIfRestricted(String) MapperUtils.capitalizeIfRestricted() }
+     */
     private String name;
+    /**
+     * Original name that appears in GraphQL schema
+     */
+    private String originalName;
     private String defaultValue;
     private List<String> annotations = new ArrayList<>();
     private List<String> javaDoc = new ArrayList<>();
@@ -27,12 +34,11 @@ public class ParameterDefinition {
     public ParameterDefinition() {
     }
 
-    public ParameterDefinition(String type, String name, String defaultValue,
-                               List<String> annotations,
-                               List<String> javaDoc,
-                               boolean deprecated) {
+    public ParameterDefinition(String type, String name, String originalName, String defaultValue,
+                               List<String> annotations, List<String> javaDoc, boolean deprecated) {
         this.type = type;
         this.name = name;
+        this.originalName = originalName;
         this.defaultValue = defaultValue;
         this.annotations = annotations;
         this.javaDoc = javaDoc;
@@ -55,6 +61,14 @@ public void setName(String name) {
         this.name = name;
     }
 
+    public String getOriginalName() {
+        return originalName;
+    }
+
+    public void setOriginalName(String originalName) {
+        this.originalName = originalName;
+    }
+
     public String getDefaultValue() {
         return defaultValue;
     }

src/main/resources/templates/javaClassGraphqlParametrizedInput.ftl

@@ -103,7 +103,7 @@ public class ${className} implements GraphQLParametrizedInput {
 <#if fields?has_content>
 <#list fields as field>
         if (${field.name} != null) {
-            joiner.add("${field.name}: " + GraphQLRequestSerializer.getEntry(${field.name}));
+            joiner.add("${field.originalName}: " + GraphQLRequestSerializer.getEntry(${field.name}));
         }
 </#list>
 </#if>

src/main/resources/templates/javaClassGraphqlRequest.ftl

@@ -49,7 +49,7 @@ public class ${className} implements GraphQLOperationRequest {
     @Deprecated
 </#if>
     public void set${field.name?cap_first}(${field.type} ${field.name}) {
-        this.input.put("${field.name}", ${field.name});
+        this.input.put("${field.originalName}", ${field.name});
     }
 
 </#list>

src/main/resources/templates/javaClassGraphqlResponse.ftl

@@ -38,7 +38,7 @@ public class ${className} extends GraphQLResult<Map<String, ${returnTypeName}>>
 <#if deprecated>
     @Deprecated
 </#if>
-    public ${returnTypeName} ${operationName}() {
+    public ${returnTypeName} ${methodName}() {
         Map<String, ${returnTypeName}> data = getData();
         return data != null ? data.get(OPERATION_NAME) : null;
     }

src/main/resources/templates/javaClassGraphqlResponseProjection.ftl

@@ -52,7 +52,7 @@ public class ${className} extends GraphQLResponseProjection {
 
 <#if field.parametrizedInputClassName?has_content>
     public ${className} ${field.methodName}(${field.parametrizedInputClassName} input<#if field.type?has_content>, ${field.type} subProjection</#if>) {
-        return ${field.name}(null, input<#if field.type?has_content>, subProjection</#if>);
+        return ${field.methodName}(null, input<#if field.type?has_content>, subProjection</#if>);
     }
 
     public ${className} ${field.methodName}(String alias, ${field.parametrizedInputClassName} input<#if field.type?has_content>, ${field.type} subProjection</#if>) {

src/main/resources/templates/javaClassGraphqlType.ftl

@@ -127,12 +127,12 @@ public class ${className} implements java.io.Serializable<#if implements?has_con
 <#list fields as field>
         if (${field.name} != null) {
 <#if toStringForRequest>
-            joiner.add("${field.name}: " + GraphQLRequestSerializer.getEntry(${field.name}));
+            joiner.add("${field.originalName}: " + GraphQLRequestSerializer.getEntry(${field.name}));
 <#else>
 <#if field.type == "String">
-            joiner.add("${field.name}: \"" + ${field.name} + "\"");
+            joiner.add("${field.originalName}: \"" + ${field.name} + "\"");
 <#else>
-            joiner.add("${field.name}: " + ${field.name});
+            joiner.add("${field.originalName}: " + ${field.name});
 </#if>
 </#if>
         }

src/test/java/com/kobylynskyi/graphql/codegen/GraphQLCodegenRestrictedWordsTest.java

@@ -0,0 +1,64 @@
+package com.kobylynskyi.graphql.codegen;
+
+import com.kobylynskyi.graphql.codegen.model.MappingConfig;
+import com.kobylynskyi.graphql.codegen.utils.Utils;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.io.File;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Objects;
+
+import static com.kobylynskyi.graphql.codegen.TestUtils.assertSameTrimmedContent;
+import static java.util.Collections.singletonList;
+import static java.util.stream.Collectors.toList;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class GraphQLCodegenRestrictedWordsTest {
+
+    private final File outputBuildDir = new File("build/generated");
+    private final File outputJavaClassesDir = new File("build/generated/com/kobylynskyi/graphql/codegen/prot");
+
+    private MappingConfig mappingConfig;
+
+    @BeforeEach
+    void init() {
+        mappingConfig = new MappingConfig();
+        mappingConfig.setPackageName("com.kobylynskyi.graphql.codegen.prot");
+        mappingConfig.setGenerateClient(true);
+        mappingConfig.setGenerateBuilder(true);
+        mappingConfig.setGenerateEqualsAndHashCode(true);
+        mappingConfig.setGenerateToString(true);
+        mappingConfig.setGenerateModelsForRootTypes(true);
+        mappingConfig.setApiNameSuffix("API");
+    }
+
+    @AfterEach
+    void cleanup() {
+        Utils.deleteDir(outputBuildDir);
+    }
+
+    @Test
+    void generate() throws Exception {
+        new GraphQLCodegen(singletonList("src/test/resources/schemas/restricted-words.graphqls"),
+                outputBuildDir, mappingConfig, TestUtils.getStaticGeneratedInfo()).generate();
+
+        File[] files = Objects.requireNonNull(outputJavaClassesDir.listFiles());
+        List<String> generatedFileNames = Arrays.stream(files).map(File::getName).sorted().collect(toList());
+        assertEquals(Arrays.asList("CaseQueryAPI.java", "CaseQueryRequest.java", "CaseQueryResponse.java",
+                "Char.java", "CharResponseProjection.java", "NativeQueryAPI.java", "NativeQueryRequest.java",
+                "NativeQueryResponse.java", "PrivateQueryAPI.java", "PrivateQueryRequest.java",
+                "PrivateQueryResponse.java", "Query.java", "QueryAPI.java", "QueryCaseParametrizedInput.java",
+                "QueryPrivateParametrizedInput.java", "QueryResolver.java", "QueryResponseProjection.java",
+                "Synchronized.java", "SynchronizedResponseProjection.java"), generatedFileNames);
+
+        for (File file : files) {
+            assertSameTrimmedContent(
+                    new File(String.format("src/test/resources/expected-classes/restricted-words/%s.txt", file.getName())),
+                    file);
+        }
+    }
+
+}

src/test/resources/expected-classes/restricted-words/CaseQueryAPI.java.txt

@@ -0,0 +1,12 @@
+package com.kobylynskyi.graphql.codegen.prot;
+
+
+@javax.annotation.Generated(
+    value = "com.kobylynskyi.graphql.codegen.GraphQLCodegen",
+    date = "2020-12-31T23:59:59-0500"
+)
+public interface CaseQueryAPI {
+
+    String Case(java.util.List<Char> Final) throws Exception;
+
+}