Skip to content

Commit 5db6066

Browse files
kobylynskyikobylynskyi
authored
Use upper bounded wildcard for interface methods returning list #145 (#147)
* Use upper bounded wildcard for interface methods returning list #145 * Delete Foo1.java.txt * Delete Bar1.java.txt * Delete Foo.java.txt
1 parent 3b3f979 commit 5db6066

22 files changed

+609
-264
lines changed

‎src/main/java/com/kobylynskyi/graphql/codegen/GraphQLCodegen.java‎

Lines changed: 32 additions & 28 deletions
Original file line numberDiff line numberDiff line change
@@ -3,9 +3,11 @@
33
import com.kobylynskyi.graphql.codegen.mapper.*;
44
import com.kobylynskyi.graphql.codegen.model.DefaultMappingConfigValues;
55
import com.kobylynskyi.graphql.codegen.model.MappingConfig;
6+
import com.kobylynskyi.graphql.codegen.model.MappingContext;
67
import com.kobylynskyi.graphql.codegen.model.definitions.*;
78
import com.kobylynskyi.graphql.codegen.supplier.MappingConfigSupplier;
8-
import graphql.language.*;
9+
import graphql.language.FieldDefinition;
10+
import graphql.language.ScalarTypeExtensionDefinition;
911
import lombok.Getter;
1012
import lombok.Setter;
1113

@@ -101,102 +103,104 @@ public List<File> generate() throws Exception {
101103
}
102104

103105
private List<File> processDefinitions(ExtendedDocument document) {
106+
MappingContext context = new MappingContext(mappingConfig, document,
107+
document.getTypeNames(), document.getInterfaceNames());
108+
104109
List<File> generatedFiles = new ArrayList<>();
105-
Set<String> typeNames = document.getTypeNames();
106110
for (ExtendedObjectTypeDefinition extendedObjectTypeDefinition : document.getTypeDefinitions()) {
107-
generatedFiles.addAll(generateType(extendedObjectTypeDefinition, document, typeNames));
111+
generatedFiles.addAll(generateType(context, extendedObjectTypeDefinition));
108112
}
109113
for (ExtendedObjectTypeDefinition extendedObjectTypeDefinition : document.getTypeDefinitions()) {
110-
generateFieldResolver(extendedObjectTypeDefinition.getFieldDefinitions(), extendedObjectTypeDefinition.getName())
114+
generateFieldResolver(context, extendedObjectTypeDefinition.getFieldDefinitions(), extendedObjectTypeDefinition.getName())
111115
.ifPresent(generatedFiles::add);
112116
}
113117
for (ExtendedObjectTypeDefinition extendedObjectTypeDefinition : document.getOperationDefinitions()) {
114-
generatedFiles.addAll(generateOperation(extendedObjectTypeDefinition));
118+
generatedFiles.addAll(generateOperation(context, extendedObjectTypeDefinition));
115119
}
116120
for (ExtendedInputObjectTypeDefinition extendedInputObjectTypeDefinition : document.getInputDefinitions()) {
117-
generatedFiles.add(generateInput(extendedInputObjectTypeDefinition));
121+
generatedFiles.add(generateInput(context, extendedInputObjectTypeDefinition));
118122
}
119123
for (ExtendedEnumTypeDefinition extendedEnumTypeDefinition : document.getEnumDefinitions()) {
120-
generatedFiles.add(generateEnum(extendedEnumTypeDefinition));
124+
generatedFiles.add(generateEnum(context, extendedEnumTypeDefinition));
121125
}
122126
for (ExtendedUnionTypeDefinition extendedUnionTypeDefinition : document.getUnionDefinitions()) {
123-
generatedFiles.add(generateUnion(extendedUnionTypeDefinition));
127+
generatedFiles.add(generateUnion(context, extendedUnionTypeDefinition));
124128
}
125129
for (ExtendedInterfaceTypeDefinition extendedInterfaceTypeDefinition : document.getInterfaceDefinitions()) {
126-
generatedFiles.add(generateInterface(extendedInterfaceTypeDefinition));
130+
generatedFiles.add(generateInterface(context, extendedInterfaceTypeDefinition));
127131
}
128132
for (ExtendedInterfaceTypeDefinition definition : document.getInterfaceDefinitions()) {
129-
generateFieldResolver(definition.getFieldDefinitions(), definition.getName())
133+
generateFieldResolver(context, definition.getFieldDefinitions(), definition.getName())
130134
.ifPresent(generatedFiles::add);
131135
}
132136
System.out.println(String.format("Generated %d definition classes in folder %s",
133137
generatedFiles.size(), outputDir.getAbsolutePath()));
134138
return generatedFiles;
135139
}
136140

137-
private File generateUnion(ExtendedUnionTypeDefinition definition) {
138-
Map<String, Object> dataModel = UnionDefinitionToDataModelMapper.map(mappingConfig, definition);
141+
private File generateUnion(MappingContext mappingContext, ExtendedUnionTypeDefinition definition) {
142+
Map<String, Object> dataModel = UnionDefinitionToDataModelMapper.map(mappingContext, definition);
139143
return GraphQLCodegenFileCreator.generateFile(FreeMarkerTemplatesRegistry.unionTemplate, dataModel, outputDir);
140144
}
141145

142-
private File generateInterface(ExtendedInterfaceTypeDefinition definition) {
143-
Map<String, Object> dataModel = InterfaceDefinitionToDataModelMapper.map(mappingConfig, definition);
146+
private File generateInterface(MappingContext mappingContext, ExtendedInterfaceTypeDefinition definition) {
147+
Map<String, Object> dataModel = InterfaceDefinitionToDataModelMapper.map(mappingContext, definition);
144148
return GraphQLCodegenFileCreator.generateFile(FreeMarkerTemplatesRegistry.interfaceTemplate, dataModel, outputDir);
145149
}
146150

147-
private List<File> generateOperation(ExtendedObjectTypeDefinition definition) {
151+
private List<File> generateOperation(MappingContext mappingContext, ExtendedObjectTypeDefinition definition) {
148152
List<File> generatedFiles = new ArrayList<>();
149153
List<String> fieldNames = definition.getFieldDefinitions().stream().map(FieldDefinition::getName).collect(toList());
150154
if (Boolean.TRUE.equals(mappingConfig.getGenerateApis())) {
151155
for (ExtendedFieldDefinition operationDef : definition.getFieldDefinitions()) {
152-
Map<String, Object> dataModel = FieldDefinitionsToResolverDataModelMapper.mapRootTypeField(mappingConfig, operationDef, definition.getName(), fieldNames);
156+
Map<String, Object> dataModel = FieldDefinitionsToResolverDataModelMapper.mapRootTypeField(mappingContext, operationDef, definition.getName(), fieldNames);
153157
generatedFiles.add(GraphQLCodegenFileCreator.generateFile(FreeMarkerTemplatesRegistry.operationsTemplate, dataModel, outputDir));
154158
}
155159
// We need to generate a root object to workaround https://github.com/facebook/relay/issues/112
156-
Map<String, Object> dataModel = FieldDefinitionsToResolverDataModelMapper.mapRootTypeFields(mappingConfig, definition);
160+
Map<String, Object> dataModel = FieldDefinitionsToResolverDataModelMapper.mapRootTypeFields(mappingContext, definition);
157161
generatedFiles.add(GraphQLCodegenFileCreator.generateFile(FreeMarkerTemplatesRegistry.operationsTemplate, dataModel, outputDir));
158162
}
159163

160164
if (Boolean.TRUE.equals(mappingConfig.getGenerateRequests())) {
161165
// generate request objects for graphql operations
162166
for (ExtendedFieldDefinition operationDef : definition.getFieldDefinitions()) {
163-
Map<String, Object> requestDataModel = FieldDefinitionToRequestDataModelMapper.map(mappingConfig, operationDef, definition.getName(), fieldNames);
167+
Map<String, Object> requestDataModel = FieldDefinitionToRequestDataModelMapper.map(mappingContext, operationDef, definition.getName(), fieldNames);
164168
generatedFiles.add(GraphQLCodegenFileCreator.generateFile(FreeMarkerTemplatesRegistry.requestTemplate, requestDataModel, outputDir));
165169
}
166170
}
167171
return generatedFiles;
168172
}
169173

170-
private List<File> generateType(ExtendedObjectTypeDefinition definition, ExtendedDocument document, Set<String> typeNames) {
174+
private List<File> generateType(MappingContext mappingContext, ExtendedObjectTypeDefinition definition) {
171175
List<File> generatedFiles = new ArrayList<>();
172-
Map<String, Object> dataModel = TypeDefinitionToDataModelMapper.map(mappingConfig, definition, document);
176+
Map<String, Object> dataModel = TypeDefinitionToDataModelMapper.map(mappingContext, definition);
173177
generatedFiles.add(GraphQLCodegenFileCreator.generateFile(FreeMarkerTemplatesRegistry.typeTemplate, dataModel, outputDir));
174178

175179
if (Boolean.TRUE.equals(mappingConfig.getGenerateRequests())) {
176-
Map<String, Object> responseProjDataModel = TypeDefinitionToDataModelMapper.mapResponseProjection(mappingConfig, definition, document, typeNames);
180+
Map<String, Object> responseProjDataModel = TypeDefinitionToDataModelMapper.mapResponseProjection(mappingContext, definition);
177181
generatedFiles.add(GraphQLCodegenFileCreator.generateFile(FreeMarkerTemplatesRegistry.responseProjectionTemplate, responseProjDataModel, outputDir));
178182
}
179183
return generatedFiles;
180184
}
181185

182-
private Optional<File> generateFieldResolver(List<ExtendedFieldDefinition> fieldDefinitions, String definitionName) {
186+
private Optional<File> generateFieldResolver(MappingContext mappingContext, List<ExtendedFieldDefinition> fieldDefinitions, String definitionName) {
183187
List<ExtendedFieldDefinition> fieldDefsWithResolvers = fieldDefinitions.stream()
184-
.filter(fieldDef -> FieldDefinitionToParameterMapper.generateResolversForField(mappingConfig, fieldDef, definitionName))
188+
.filter(fieldDef -> FieldDefinitionToParameterMapper.generateResolversForField(mappingContext, fieldDef, definitionName))
185189
.collect(toList());
186190
if (!fieldDefsWithResolvers.isEmpty()) {
187-
Map<String, Object> dataModel = FieldDefinitionsToResolverDataModelMapper.mapToTypeResolver(mappingConfig, fieldDefsWithResolvers, definitionName);
191+
Map<String, Object> dataModel = FieldDefinitionsToResolverDataModelMapper.mapToTypeResolver(mappingContext, fieldDefsWithResolvers, definitionName);
188192
return Optional.of(GraphQLCodegenFileCreator.generateFile(FreeMarkerTemplatesRegistry.operationsTemplate, dataModel, outputDir));
189193
}
190194
return Optional.empty();
191195
}
192196

193-
private File generateInput(ExtendedInputObjectTypeDefinition definition) {
194-
Map<String, Object> dataModel = InputDefinitionToDataModelMapper.map(mappingConfig, definition);
197+
private File generateInput(MappingContext mappingContext, ExtendedInputObjectTypeDefinition definition) {
198+
Map<String, Object> dataModel = InputDefinitionToDataModelMapper.map(mappingContext, definition);
195199
return GraphQLCodegenFileCreator.generateFile(FreeMarkerTemplatesRegistry.typeTemplate, dataModel, outputDir);
196200
}
197201

198-
private File generateEnum(ExtendedEnumTypeDefinition definition) {
199-
Map<String, Object> dataModel = EnumDefinitionToDataModelMapper.map(mappingConfig, definition);
202+
private File generateEnum(MappingContext mappingContext, ExtendedEnumTypeDefinition definition) {
203+
Map<String, Object> dataModel = EnumDefinitionToDataModelMapper.map(mappingContext, definition);
200204
return GraphQLCodegenFileCreator.generateFile(FreeMarkerTemplatesRegistry.enumTemplate, dataModel, outputDir);
201205
}
202206

‎src/main/java/com/kobylynskyi/graphql/codegen/mapper/DefaultValueMapper.java‎

Lines changed: 9 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -1,14 +1,14 @@
11
package com.kobylynskyi.graphql.codegen.mapper;
22

3-
import com.kobylynskyi.graphql.codegen.model.MappingConfig;
3+
import com.kobylynskyi.graphql.codegen.model.MappingContext;
44
import graphql.language.*;
55

66
import java.util.List;
77
import java.util.stream.Collectors;
88

99
public class DefaultValueMapper {
1010

11-
public static String map(MappingConfig mappingConfig, Value<?> defaultValue, Type<?> graphQLType) {
11+
public static String map(MappingContext mappingContext, Value<?> defaultValue, Type<?> graphQLType) {
1212
if (defaultValue instanceof NullValue) {
1313
return mapNullValue();
1414
}
@@ -25,13 +25,13 @@ public static String map(MappingConfig mappingConfig, Value<?> defaultValue, Typ
2525
return mapString((StringValue) defaultValue);
2626
}
2727
if (defaultValue instanceof EnumValue) {
28-
return mapEnum(mappingConfig, graphQLType, (EnumValue) defaultValue);
28+
return mapEnum(mappingContext, graphQLType, (EnumValue) defaultValue);
2929
}
3030
if (defaultValue instanceof ObjectValue) {
3131
return mapObject((ObjectValue) defaultValue);
3232
}
3333
if (defaultValue instanceof ArrayValue) {
34-
return mapArray(mappingConfig, (ArrayValue) defaultValue, graphQLType);
34+
return mapArray(mappingContext, (ArrayValue) defaultValue, graphQLType);
3535
}
3636
// no default value, or not a known type
3737
return null;
@@ -57,14 +57,14 @@ private static String mapString(StringValue defaultValue) {
5757
return "\"" + defaultValue.getValue() + "\"";
5858
}
5959

60-
private static String mapEnum(MappingConfig mappingConfig, Type<?> graphQLType, EnumValue defaultValue) {
60+
private static String mapEnum(MappingContext mappingContext, Type<?> graphQLType, EnumValue defaultValue) {
6161
if (graphQLType instanceof TypeName) {
6262
String typeName = ((TypeName) graphQLType).getName();
63-
typeName = MapperUtils.getClassNameWithPrefixAndSuffix(mappingConfig, typeName);
63+
typeName = MapperUtils.getClassNameWithPrefixAndSuffix(mappingContext, typeName);
6464
return typeName + "." + defaultValue.getName();
6565
}
6666
if (graphQLType instanceof NonNullType) {
67-
return mapEnum(mappingConfig, ((NonNullType) graphQLType).getType(), defaultValue);
67+
return mapEnum(mappingContext, ((NonNullType) graphQLType).getType(), defaultValue);
6868
}
6969
throw new IllegalArgumentException("Unexpected Enum default value for list type");
7070
}
@@ -74,7 +74,7 @@ private static String mapObject(ObjectValue defaultValue) {
7474
return null;
7575
}
7676

77-
private static String mapArray(MappingConfig mappingConfig, ArrayValue defaultValue, Type<?> graphQLType) {
77+
private static String mapArray(MappingContext mappingContext, ArrayValue defaultValue, Type<?> graphQLType) {
7878
if (!(graphQLType instanceof ListType)) {
7979
throw new IllegalArgumentException("Unexpected array default value for non-list type");
8080
}
@@ -84,7 +84,7 @@ private static String mapArray(MappingConfig mappingConfig, ArrayValue defaultVa
8484
}
8585
Type<?> elementType = ((ListType) graphQLType).getType();
8686
return values.stream()
87-
.map(v -> map(mappingConfig, v, elementType))
87+
.map(v -> map(mappingContext, v, elementType))
8888
.collect(Collectors.joining(", ", "java.util.Arrays.asList(", ")"));
8989
}
9090
}

‎src/main/java/com/kobylynskyi/graphql/codegen/mapper/EnumDefinitionToDataModelMapper.java‎

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,7 @@
11
package com.kobylynskyi.graphql.codegen.mapper;
22

33
import com.kobylynskyi.graphql.codegen.model.EnumValueDefinition;
4-
import com.kobylynskyi.graphql.codegen.model.MappingConfig;
4+
import com.kobylynskyi.graphql.codegen.model.MappingContext;
55
import com.kobylynskyi.graphql.codegen.model.definitions.ExtendedEnumTypeDefinition;
66
import graphql.language.Comment;
77
import graphql.language.Directive;
@@ -22,15 +22,15 @@ public class EnumDefinitionToDataModelMapper {
2222
/**
2323
* Map field definition to a Freemarker data model
2424
*
25-
* @param mappingConfig Global mapping configuration
26-
* @param definition Definition of enum type including base definition and its extensions
25+
* @param mappingContext Global mapping context
26+
* @param definition Definition of enum type including base definition and its extensions
2727
* @return Freemarker data model of the GraphQL enum
2828
*/
29-
public static Map<String, Object> map(MappingConfig mappingConfig, ExtendedEnumTypeDefinition definition) {
29+
public static Map<String, Object> map(MappingContext mappingContext, ExtendedEnumTypeDefinition definition) {
3030
Map<String, Object> dataModel = new HashMap<>();
3131
// type/enum/input/interface/union classes do not require any imports
32-
dataModel.put(PACKAGE, MapperUtils.getModelPackageName(mappingConfig));
33-
dataModel.put(CLASS_NAME, MapperUtils.getClassNameWithPrefixAndSuffix(mappingConfig, definition));
32+
dataModel.put(PACKAGE, MapperUtils.getModelPackageName(mappingContext));
33+
dataModel.put(CLASS_NAME, MapperUtils.getClassNameWithPrefixAndSuffix(mappingContext, definition));
3434
dataModel.put(JAVA_DOC, definition.getJavaDoc());
3535
dataModel.put(FIELDS, map(definition.getValueDefinitions()));
3636
return dataModel;

0 commit comments

Comments
 (0)