When using GraphQL federation, external parties can extend types and … (#866)

docs/codegen-options.md

@@ -60,6 +60,9 @@ See [DirectiveAnnotationsMapping](#option-directiveannotationsmapping)* |
 | `generateSealedInterfaces`                            | Boolean                                                               | false                                                  | This applies to generated interfaces on unions and interfaces. If true, generate sealed interfaces, else generate normal ones. It is only supported in Kotlin. |
 | `typesAsInterfaces`                                   | Set(String)                                                           | Empty                                                  | Types that must generated as interfaces should be defined here in format: `TypeName` or `@directive`. E.g.: `User`, `@asInterface`. |
 | `useObjectMapperForRequestSerialization`              | Set(String)                                                           | Empty                                                  | Fields that require serialization using `com.fasterxml.jackson.databind.ObjectMapper#writeValueAsString(Object)`. Values should be defined here in the following format: `GraphqlObjectName.fieldName` or `GraphqlTypeName`. If just type is specified, then all fields of this type will be serialized using ObjectMapper. E.g.: `["Person.createdDateTime", ZonedDateTime"]` |
+| `supportUnknownFields`                                | Boolean                                                               | false                                                  | Specifies whether api classes should support unknown fields during serialization or deserialization. If `true`, classes will include a property of type [`java.util.Map<String,Object>`](https://docs.oracle.com/javase/8/docs/api/index.html?java/util/Map.html) that will store unknown fields.|
+| `unknownFieldsPropertyName`                           | String                                                                | userDefinedFields                                      | Specifies the name of the property to be included in api classes to support unknown fields during serialization or deserialization|
+
 
 ### Option `graphqlSchemas`
 

plugins/gradle/example-client-kotlin/build.gradle

@@ -65,4 +65,5 @@ task graphqlCodegenKotlinService(type: GraphQLCodegenGradleTask) {
                                   "       com.fasterxml.jackson.annotation.JsonSubTypes.Type(value = DroidTO::class, name = \"Droid\")))"],
     ]
     modelNameSuffix = "TO"
+    supportUnknownFields = true
 }
\ No newline at end of file

plugins/gradle/example-server/build.gradle

@@ -48,6 +48,9 @@ graphqlCodegen {
     }
     modelNameSuffix = "TO"
     generateApis = true
+    supportUnknownFields = true
+    unknownFieldsPropertyName = "additionalFields"
+
 }
 
 repositories {

plugins/gradle/example-server/src/main/java/io/github/kobylynskyi/product/Application.java

@@ -6,6 +6,7 @@ import org.springframework.boot.autoconfigure.SpringBootApplication;
 @SpringBootApplication
 public class Application {
 
+
     public static void main(String[] args) {
         SpringApplication.run(Application.class, args);
     }

plugins/gradle/graphql-java-codegen-gradle-plugin/src/main/java/io/github/kobylynskyi/graphql/codegen/gradle/GraphQLCodegenGradleTask.java

@@ -106,6 +106,9 @@ public class GraphQLCodegenGradleTask extends DefaultTask implements GraphQLCode
     private Boolean initializeNullableTypes = MappingConfigConstants.DEFAULT_INITIALIZE_NULLABLE_TYPES;
     private Boolean generateSealedInterfaces = MappingConfigConstants.DEFAULT_GENERATE_SEALED_INTERFACES;
 
+    private Boolean supportUnknownFields = MappingConfigConstants.DEFAULT_SUPPORT_UNKNOWN_FIELDS;
+    private String unknownFieldsPropertyName = MappingConfigConstants.DEFAULT_UNKNOWN_FIELDS_PROPERTY_NAME;
+
     public GraphQLCodegenGradleTask() {
         setGroup("codegen");
         setDescription("Generates Java POJOs and interfaces based on GraphQL schemas");
@@ -182,6 +185,9 @@ public class GraphQLCodegenGradleTask extends DefaultTask implements GraphQLCode
         mappingConfig.setGenerateModelOpenClasses(generateModelOpenClasses);
         mappingConfig.setInitializeNullableTypes(initializeNullableTypes);
 
+        mappingConfig.setSupportUnknownFields(isSupportUnknownFields());
+        mappingConfig.setUnknownFieldsPropertyName(getUnknownFieldsPropertyName());
+
         instantiateCodegen(mappingConfig).generate();
     }
 
@@ -869,4 +875,28 @@ public class GraphQLCodegenGradleTask extends DefaultTask implements GraphQLCode
     public void setGenerateSealedInterfaces(Boolean generateSealedInterfaces) {
         this.generateSealedInterfaces = generateSealedInterfaces;
     }
+
+    @Input
+    @Optional
+    @Override
+    public Boolean isSupportUnknownFields() {
+        return supportUnknownFields;
+    }
+
+    public void setSupportUnknownFields(boolean supportUnknownFields) {
+        this.supportUnknownFields = supportUnknownFields;
+    }
+
+    @Input
+    @Optional
+    @Override
+    public String getUnknownFieldsPropertyName() {
+        return unknownFieldsPropertyName;
+    }
+
+    public void setUnknownFieldsPropertyName(String unknownFieldsPropertyName) {
+        this.unknownFieldsPropertyName = unknownFieldsPropertyName;
+    }
+    
+
 }

plugins/maven/graphql-java-codegen-maven-plugin/src/main/java/io/github/kobylynskyi/graphql/codegen/GraphQLCodegenMojo.java

@@ -200,6 +200,12 @@ public class GraphQLCodegenMojo extends AbstractMojo implements GraphQLCodegenCo
     @Parameter
     private String[] configurationFiles;
 
+    @Parameter(defaultValue = MappingConfigConstants.DEFAULT_SUPPORT_UNKNOWN_FIELDS_STRING)
+    private boolean supportUnknownFields;
+
+    @Parameter(defaultValue = MappingConfigConstants.DEFAULT_UNKNOWN_FIELDS_PROPERTY_NAME)
+    private String unknownFieldsPropertyName;
+
     /**
      * The project being built.
      */
@@ -276,6 +282,9 @@ public class GraphQLCodegenMojo extends AbstractMojo implements GraphQLCodegenCo
         mappingConfig.setInitializeNullableTypes(isInitializeNullableTypes());
         mappingConfig.setGenerateSealedInterfaces(isGenerateSealedInterfaces());
 
+        mappingConfig.setSupportUnknownFields(isSupportUnknownFields());
+        mappingConfig.setUnknownFieldsPropertyName(getUnknownFieldsPropertyName());
+
         try {
             instantiateCodegen(mappingConfig).generate();
         } catch (Exception e) {
@@ -629,6 +638,24 @@ public class GraphQLCodegenMojo extends AbstractMojo implements GraphQLCodegenCo
         return configurationFiles;
     }
 
+    @Override
+    public Boolean isSupportUnknownFields() {
+        return supportUnknownFields;
+    }
+
+    public void setSupportUnknownFields(boolean supportUnknownFields) {
+        this.supportUnknownFields = supportUnknownFields;
+    }
+
+    @Override
+    public String getUnknownFieldsPropertyName() {
+        return unknownFieldsPropertyName;
+    }
+
+    public void setUnknownFieldsPropertyName(String unknownFieldsPropertyName) {
+        this.unknownFieldsPropertyName = unknownFieldsPropertyName;
+    }
+
     private static Map<String, List<String>> convertToListsMap(Map<String, Properties> sourceMap) {
         if (sourceMap == null) {
             return new HashMap<>();

plugins/sbt/graphql-java-codegen-sbt-plugin/src/main/scala/io/github/dreamylost/graphql/codegen/GraphQLCodegenKeys.scala

@@ -135,4 +135,7 @@ trait GraphQLCodegenKeys {
   //some others for sbt
   val generateCodegenTargetPath = settingKey[File]("Where to store generated files and add the generated code to the classpath, so that they can be referenced.")
 
+  val supportUnknownFields = settingKey[Boolean]("supportUnknownFields")
+  val unknownFieldsPropertyName = settingKey[String]("unknownFieldsPropertyName")
+
 }

plugins/sbt/graphql-java-codegen-sbt-plugin/src/main/scala/io/github/dreamylost/graphql/codegen/GraphQLCodegenPlugin.scala

@@ -117,7 +117,10 @@ class GraphQLCodegenPlugin(configuration: Configuration, private[codegen] val co
     // parent interfaces configs:
     parentInterfaces := parentInterfacesConfig,
     generateAllMethodInProjection := MappingConfigConstants.DEFAULT_GENERATE_ALL_METHOD,
-    responseProjectionMaxDepth := MappingConfigConstants.DEFAULT_RESPONSE_PROJECTION_MAX_DEPTH
+    responseProjectionMaxDepth := MappingConfigConstants.DEFAULT_RESPONSE_PROJECTION_MAX_DEPTH,
+
+    supportUnknownFields := MappingConfigConstants.DEFAULT_SUPPORT_UNKNOWN_FIELDS,
+    unknownFieldsPropertyName := MappingConfigConstants.DEFAULT_UNKNOWN_FIELDS_PROPERTY_NAME
   )
 
   private def getMappingConfig(): Def.Initialize[MappingConfig] = Def.setting {
@@ -172,6 +175,10 @@ class GraphQLCodegenPlugin(configuration: Configuration, private[codegen] val co
     mappingConfig.setGeneratedLanguage((generatedLanguage in GraphQLCodegenConfig).value)
     mappingConfig.setGenerateModelOpenClasses((generateModelOpenClasses in GraphQLCodegenConfig).value)
     mappingConfig.setGenerateJacksonTypeIdResolver((generateJacksonTypeIdResolver in GraphQLCodegenConfig).value);
+
+    mappingConfig.setSupportUnknownFields((supportUnknownFields in GraphQLCodegenConfig).value)
+    mappingConfig.setUnknownFieldsPropertyName((unknownFieldsPropertyName in GraphQLCodegenConfig).value)
+
     mappingConfig
   }
 

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

 package com.kobylynskyi.graphql.codegen.mapper;
 
 import com.kobylynskyi.graphql.codegen.model.MappingContext;
+import com.kobylynskyi.graphql.codegen.model.ParameterDefinition;
 import com.kobylynskyi.graphql.codegen.model.builders.JavaDocBuilder;
 import com.kobylynskyi.graphql.codegen.model.definitions.ExtendedInputObjectTypeDefinition;
 
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 
 import static com.kobylynskyi.graphql.codegen.model.DataModelFields.ANNOTATIONS;
-import static com.kobylynskyi.graphql.codegen.model.DataModelFields.INITIALIZE_NULLABLE_TYPES;
 import static com.kobylynskyi.graphql.codegen.model.DataModelFields.BUILDER;
 import static com.kobylynskyi.graphql.codegen.model.DataModelFields.CLASS_NAME;
 import static com.kobylynskyi.graphql.codegen.model.DataModelFields.ENUM_IMPORT_IT_SELF_IN_SCALA;
@@ -18,18 +19,21 @@ import static com.kobylynskyi.graphql.codegen.model.DataModelFields.GENERATED_AN
 import static com.kobylynskyi.graphql.codegen.model.DataModelFields.GENERATED_INFO;
 import static com.kobylynskyi.graphql.codegen.model.DataModelFields.GENERATE_MODEL_OPEN_CLASSES;
 import static com.kobylynskyi.graphql.codegen.model.DataModelFields.IMMUTABLE_MODELS;
+import static com.kobylynskyi.graphql.codegen.model.DataModelFields.INITIALIZE_NULLABLE_TYPES;
 import static com.kobylynskyi.graphql.codegen.model.DataModelFields.JAVA_DOC;
 import static com.kobylynskyi.graphql.codegen.model.DataModelFields.NAME;
 import static com.kobylynskyi.graphql.codegen.model.DataModelFields.PACKAGE;
+import static com.kobylynskyi.graphql.codegen.model.DataModelFields.SUPPORT_UNKNOWN_FIELDS;
 import static com.kobylynskyi.graphql.codegen.model.DataModelFields.TO_STRING;
 import static com.kobylynskyi.graphql.codegen.model.DataModelFields.TO_STRING_FOR_REQUEST;
+import static com.kobylynskyi.graphql.codegen.model.DataModelFields.UNKNOWN_FIELDS_PROPERTY_NAME;
 
 /**
  * Map input type definition to a Freemarker data model
  *
  * @author kobylynskyi
  */
-public class InputDefinitionToDataModelMapper {
+public class InputDefinitionToDataModelMapper implements UnknownFieldsSupport {
 
     private final AnnotationsMapper annotationsMapper;
     private final DataModelMapper dataModelMapper;
@@ -50,14 +54,17 @@ public class InputDefinitionToDataModelMapper {
      * @return Freemarker data model of the GraphQL type
      */
     public Map<String, Object> map(MappingContext mappingContext, ExtendedInputObjectTypeDefinition definition) {
+        List<ParameterDefinition> fields = inputValueDefinitionToParameterMapper
+                .map(mappingContext, definition.getValueDefinitions(), definition.getName());
+        createUnknownFields(mappingContext).ifPresent(fields::add);
+
         Map<String, Object> dataModel = new HashMap<>();
         // type/enum/input/interface/union classes do not require any imports
         dataModel.put(PACKAGE, DataModelMapper.getModelPackageName(mappingContext));
         dataModel.put(CLASS_NAME, dataModelMapper.getModelClassNameWithPrefixAndSuffix(mappingContext, definition));
         dataModel.put(JAVA_DOC, JavaDocBuilder.build(definition));
         dataModel.put(NAME, definition.getName());
-        dataModel.put(FIELDS, inputValueDefinitionToParameterMapper
-                .map(mappingContext, definition.getValueDefinitions(), definition.getName()));
+        dataModel.put(FIELDS, fields);
         dataModel.put(ANNOTATIONS, annotationsMapper.getAnnotations(mappingContext, definition));
         dataModel.put(BUILDER, mappingContext.getGenerateBuilder());
         dataModel.put(EQUALS_AND_HASH_CODE, mappingContext.getGenerateEqualsAndHashCode());
@@ -69,6 +76,8 @@ public class InputDefinitionToDataModelMapper {
         dataModel.put(ENUM_IMPORT_IT_SELF_IN_SCALA, mappingContext.getEnumImportItSelfInScala());
         dataModel.put(GENERATE_MODEL_OPEN_CLASSES, mappingContext.isGenerateModelOpenClasses());
         dataModel.put(INITIALIZE_NULLABLE_TYPES, mappingContext.isInitializeNullableTypes());
+        dataModel.put(SUPPORT_UNKNOWN_FIELDS, mappingContext.isSupportUnknownFields());
+        dataModel.put(UNKNOWN_FIELDS_PROPERTY_NAME, mappingContext.getUnknownFieldsPropertyName());
         return dataModel;
     }
 

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

@@ -33,15 +33,17 @@ import static com.kobylynskyi.graphql.codegen.model.DataModelFields.INITIALIZE_N
 import static com.kobylynskyi.graphql.codegen.model.DataModelFields.JAVA_DOC;
 import static com.kobylynskyi.graphql.codegen.model.DataModelFields.PACKAGE;
 import static com.kobylynskyi.graphql.codegen.model.DataModelFields.PARENT_INTERFACE_PROPERTIES;
+import static com.kobylynskyi.graphql.codegen.model.DataModelFields.SUPPORT_UNKNOWN_FIELDS;
 import static com.kobylynskyi.graphql.codegen.model.DataModelFields.TO_STRING;
 import static com.kobylynskyi.graphql.codegen.model.DataModelFields.TO_STRING_FOR_REQUEST;
+import static com.kobylynskyi.graphql.codegen.model.DataModelFields.UNKNOWN_FIELDS_PROPERTY_NAME;
 
 /**
  * Map type definition to a Freemarker data model
  *
  * @author kobylynskyi
  */
-public class TypeDefinitionToDataModelMapper {
+public class TypeDefinitionToDataModelMapper implements UnknownFieldsSupport {
 
     private final GraphQLTypeMapper graphQLTypeMapper;
     private final AnnotationsMapper annotationsMapper;
@@ -106,6 +108,8 @@ public class TypeDefinitionToDataModelMapper {
         dataModel.put(GENERATE_MODEL_OPEN_CLASSES, mappingContext.isGenerateModelOpenClasses());
         dataModel.put(INITIALIZE_NULLABLE_TYPES, mappingContext.isInitializeNullableTypes());
         dataModel.put(GENERATE_SEALED_INTERFACES, mappingContext.isGenerateSealedInterfaces());
+        dataModel.put(SUPPORT_UNKNOWN_FIELDS, mappingContext.isSupportUnknownFields());
+        dataModel.put(UNKNOWN_FIELDS_PROPERTY_NAME, mappingContext.getUnknownFieldsPropertyName());
         return dataModel;
     }
 
@@ -132,6 +136,12 @@ public class TypeDefinitionToDataModelMapper {
                 .flatMap(Collection::stream)
                 .forEach(paramDef -> allParameters
                         .merge(paramDef.getName(), paramDef, TypeDefinitionToDataModelMapper::merge));
+
+
+        createUnknownFields(mappingContext).ifPresent(
+                unknownFields -> allParameters.put(mappingContext.getUnknownFieldsPropertyName(), unknownFields)
+        );
+
         return allParameters.values();
     }
 

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

+package com.kobylynskyi.graphql.codegen.mapper;
+
+import com.kobylynskyi.graphql.codegen.model.MappingContext;
+import com.kobylynskyi.graphql.codegen.model.ParameterDefinition;
+
+import java.util.Arrays;
+import java.util.Optional;
+
+/**
+ * Utility interface that provides convenience methods to handle unknown fields during the marshaling
+ * and unmarshalling of a JSON document
+ *
+ * @author aldib
+ */
+public interface UnknownFieldsSupport {
+
+    /**
+     * Creates an instance of {@link ParameterDefinition} that can be used to generate
+     * a field of type {@link java.util.Map} to store unknown fields during the marshaling
+     * and unmarshalling of a JSON document
+     *
+     * @param mappingContext The context of the mapping process.
+     * @return If {@link MappingContext#isSupportUnknownFields()} is true, it returns a monad containing
+     *         the instance of {@link ParameterDefinition}. {@link Optional#empty()} otherwise.
+     */
+    default Optional<ParameterDefinition> createUnknownFields(MappingContext mappingContext) {
+        if (mappingContext.isSupportUnknownFields()) {
+            ParameterDefinition unknownFields = new ParameterDefinition();
+            unknownFields.setName(mappingContext.getUnknownFieldsPropertyName());
+            unknownFields.setOriginalName(mappingContext.getUnknownFieldsPropertyName());
+            unknownFields.setType("java.util.Map<String, Object>");
+            unknownFields.setAnnotations(Arrays.asList(
+                    "com.fasterxml.jackson.annotation.JsonAnyGetter",
+                    "com.fasterxml.jackson.annotation.JsonAnySetter"
+            ));
+            return Optional.of(unknownFields);
+        }
+        return Optional.empty();
+    }
+}

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

@@ -38,6 +38,8 @@ public final class DataModelFields {
     public static final String GENERATE_MODEL_OPEN_CLASSES = "generateModelOpenClasses";
     public static final String INITIALIZE_NULLABLE_TYPES = "initializeNullableTypes";
     public static final String GENERATE_SEALED_INTERFACES = "generateSealedInterfaces";
+    public static final String SUPPORT_UNKNOWN_FIELDS = "supportUnknownFields";
+    public static final String UNKNOWN_FIELDS_PROPERTY_NAME = "unknownFieldsPropertyName";
 
     private DataModelFields() {
     }

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

@@ -461,4 +461,22 @@ public interface GraphQLCodegenConfiguration {
      */
     Boolean isGenerateSealedInterfaces();
 
+    /*
+     * Specifies whether api classes should support unknown fields during serialization or deserialization.
+     *
+     * @return <b>true</b> classes will include a property of type {@link java.util.Map} that will store unknown fields.
+     * @see com.fasterxml.jackson.annotation.JsonAnyGetter
+     * @see com.fasterxml.jackson.annotation.JsonAnySetter
+     */
+    Boolean isSupportUnknownFields();
+
+    /**
+     * Specifies the name of the property to be included in api classes to support unknown
+     * fields during serialization or deserialization
+     *
+     * @return The name of the property to store unknown fields
+     */
+    String getUnknownFieldsPropertyName();
+
+
 }

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

@@ -39,6 +39,7 @@ public class MappingConfig implements GraphQLCodegenConfiguration, Combinable<Ma
     private String apiReturnListType;
     private String subscriptionReturnType;
     private RelayConfig relayConfig = new RelayConfig();
+    private String unknownFieldsPropertyName;
 
     // various toggles
     private Boolean generateApis;
@@ -54,6 +55,7 @@ public class MappingConfig implements GraphQLCodegenConfiguration, Combinable<Ma
     private Boolean generateApisWithThrowsException;
     private Boolean addGeneratedAnnotation;
     private Boolean generateJacksonTypeIdResolver;
+    private Boolean supportUnknownFields;
 
     // field resolvers configs:
     private Set<String> fieldsWithResolvers = new HashSet<>();
@@ -191,6 +193,10 @@ public class MappingConfig implements GraphQLCodegenConfiguration, Combinable<Ma
                 GraphQLCodegenConfiguration::isInitializeNullableTypes);
         generateSealedInterfaces = getValueOrDefaultToThis(source,
                 GraphQLCodegenConfiguration::isGenerateSealedInterfaces);
+        supportUnknownFields = getValueOrDefaultToThis(source,
+                GraphQLCodegenConfiguration::isSupportUnknownFields);
+        unknownFieldsPropertyName = getValueOrDefaultToThis(source,
+                GraphQLCodegenConfiguration::getUnknownFieldsPropertyName);
     }
 
     private <T> T getValueOrDefaultToThis(MappingConfig source, Function<MappingConfig, T> getValueFunction) {
@@ -649,6 +655,24 @@ public class MappingConfig implements GraphQLCodegenConfiguration, Combinable<Ma
         return generatedLanguage;
     }
 
+    @Override
+    public String getUnknownFieldsPropertyName() {
+        return unknownFieldsPropertyName;
+    }
+
+    public void setUnknownFieldsPropertyName(String unknownFieldsPropertyName) {
+        this.unknownFieldsPropertyName = unknownFieldsPropertyName;
+    }
+
+    @Override
+    public Boolean isSupportUnknownFields() {
+        return supportUnknownFields;
+    }
+
+    public void setSupportUnknownFields(Boolean supportUnknownFields) {
+        this.supportUnknownFields = supportUnknownFields;
+    }
+
     public void setGeneratedLanguage(GeneratedLanguage generatedLanguage) {
         this.generatedLanguage = generatedLanguage;
     }

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

@@ -75,6 +75,9 @@ public class MappingConfigConstants {
     public static final boolean DEFAULT_GENERATE_SEALED_INTERFACES = false;
     public static final String DEFAULT_GENERATE_SEALED_INTERFACES_STRING = "false";
 
+    public static final boolean DEFAULT_SUPPORT_UNKNOWN_FIELDS = false;
+    public static final String DEFAULT_SUPPORT_UNKNOWN_FIELDS_STRING = "false";
+    public static final String DEFAULT_UNKNOWN_FIELDS_PROPERTY_NAME = "userDefinedFields";
 
     private MappingConfigConstants() {
     }

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

@@ -108,6 +108,12 @@ public class MappingConfigDefaultValuesInitializer {
         if (mappingConfig.isGenerateSealedInterfaces() == null) {
             mappingConfig.setGenerateSealedInterfaces(MappingConfigConstants.DEFAULT_GENERATE_SEALED_INTERFACES);
         }
+        if (mappingConfig.isSupportUnknownFields() == null) {
+            mappingConfig.setSupportUnknownFields(MappingConfigConstants.DEFAULT_SUPPORT_UNKNOWN_FIELDS);
+        }
+        if (mappingConfig.getUnknownFieldsPropertyName() == null) {
+            mappingConfig.setUnknownFieldsPropertyName(MappingConfigConstants.DEFAULT_UNKNOWN_FIELDS_PROPERTY_NAME);
+        }
     }
 
 }

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

@@ -62,6 +62,8 @@ public class MappingContext implements GraphQLCodegenConfiguration {
         return config.isInitializeNullableTypes();
     }
 
+
+
     @Override
     public Boolean isGenerateSealedInterfaces() {
         return config.isGenerateSealedInterfaces();
@@ -307,6 +309,16 @@ public class MappingContext implements GraphQLCodegenConfiguration {
         return config.getTypesAsInterfaces();
     }
 
+    @Override
+    public Boolean isSupportUnknownFields() {
+        return config.isSupportUnknownFields();
+    }
+
+    @Override
+    public String getUnknownFieldsPropertyName() {
+        return config.getUnknownFieldsPropertyName();
+    }
+
     public ExtendedDocument getDocument() {
         return document;
     }

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

@@ -53,6 +53,25 @@ class GraphQLCodegenDefaultsTest {
         }
     }
 
+    @Test
+    void generate_UnkonwnFields() throws Exception {
+        mappingConfig.setSupportUnknownFields(true);
+        mappingConfig.setUnknownFieldsPropertyName("userDefinedFields");
+
+        new JavaGraphQLCodegen(singletonList("src/test/resources/schemas/defaults.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(asList("InputWithDefaults.java", "MyEnum.java", "SomeObject.java"), generatedFileNames);
+
+        for (File file : files) {
+            assertSameTrimmedContent(new File(String.format("src/test/resources/expected-classes/unknown-fields/%s.txt",
+                            file.getName())),
+                    file);
+        }
+    }
+
     @Test
     void generate_CheckFiles_WithPrefixSuffix() throws Exception {
         mappingConfig.setModelNameSuffix("TO");

src/test/resources/expected-classes/unknown-fields/InputWithDefaults.java.txt

+package com.kobylynskyi.graphql.testdefaults;
+
+
+/**
+ * This input has all possible types
+ */
+@javax.annotation.Generated(
+    value = "com.kobylynskyi.graphql.codegen.GraphQLCodegen",
+    date = "2020-12-31T23:59:59-0500"
+)
+public class InputWithDefaults implements java.io.Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    private Double floatVal = 1.23;
+    private Boolean booleanVal = false;
+    private Integer intVal = 42;
+    private String stringVal = "my-default";
+    private MyEnum enumVal = MyEnum.ONE;
+    @javax.validation.constraints.NotNull
+    private MyEnum nonNullEnumVal = MyEnum.TWO;
+    private SomeObject objectWithNullDefault = null;
+    private SomeObject objectWithNonNullDefault;
+    private java.util.List<Integer> intList = java.util.Arrays.asList(1, 2, 3);
+    private java.util.List<Integer> intListEmptyDefault = java.util.Collections.emptyList();
+    @javax.validation.constraints.NotNull
+    private java.util.List<SomeObject> objectListEmptyDefault = java.util.Collections.emptyList();
+    @com.fasterxml.jackson.annotation.JsonAnyGetter
+    @com.fasterxml.jackson.annotation.JsonAnySetter
+    private java.util.Map<String, Object> userDefinedFields;
+
+    public InputWithDefaults() {
+    }
+
+    public InputWithDefaults(Double floatVal, Boolean booleanVal, Integer intVal, String stringVal, MyEnum enumVal, MyEnum nonNullEnumVal, SomeObject objectWithNullDefault, SomeObject objectWithNonNullDefault, java.util.List<Integer> intList, java.util.List<Integer> intListEmptyDefault, java.util.List<SomeObject> objectListEmptyDefault, java.util.Map<String, Object> userDefinedFields) {
+        this.floatVal = floatVal;
+        this.booleanVal = booleanVal;
+        this.intVal = intVal;
+        this.stringVal = stringVal;
+        this.enumVal = enumVal;
+        this.nonNullEnumVal = nonNullEnumVal;
+        this.objectWithNullDefault = objectWithNullDefault;
+        this.objectWithNonNullDefault = objectWithNonNullDefault;
+        this.intList = intList;
+        this.intListEmptyDefault = intListEmptyDefault;
+        this.objectListEmptyDefault = objectListEmptyDefault;
+        this.userDefinedFields = userDefinedFields;
+    }
+
+    public Double getFloatVal() {
+        return floatVal;
+    }
+    public void setFloatVal(Double floatVal) {
+        this.floatVal = floatVal;
+    }
+
+    public Boolean getBooleanVal() {
+        return booleanVal;
+    }
+    public void setBooleanVal(Boolean booleanVal) {
+        this.booleanVal = booleanVal;
+    }
+
+    public Integer getIntVal() {
+        return intVal;
+    }
+    public void setIntVal(Integer intVal) {
+        this.intVal = intVal;
+    }
+
+    public String getStringVal() {
+        return stringVal;
+    }
+    public void setStringVal(String stringVal) {
+        this.stringVal = stringVal;
+    }
+
+    public MyEnum getEnumVal() {
+        return enumVal;
+    }
+    public void setEnumVal(MyEnum enumVal) {
+        this.enumVal = enumVal;
+    }
+
+    public MyEnum getNonNullEnumVal() {
+        return nonNullEnumVal;
+    }
+    public void setNonNullEnumVal(MyEnum nonNullEnumVal) {
+        this.nonNullEnumVal = nonNullEnumVal;
+    }
+
+    public SomeObject getObjectWithNullDefault() {
+        return objectWithNullDefault;
+    }
+    public void setObjectWithNullDefault(SomeObject objectWithNullDefault) {
+        this.objectWithNullDefault = objectWithNullDefault;
+    }
+
+    public SomeObject getObjectWithNonNullDefault() {
+        return objectWithNonNullDefault;
+    }
+    public void setObjectWithNonNullDefault(SomeObject objectWithNonNullDefault) {
+        this.objectWithNonNullDefault = objectWithNonNullDefault;
+    }
+
+    public java.util.List<Integer> getIntList() {
+        return intList;
+    }
+    public void setIntList(java.util.List<Integer> intList) {
+        this.intList = intList;
+    }
+
+    public java.util.List<Integer> getIntListEmptyDefault() {
+        return intListEmptyDefault;
+    }
+    public void setIntListEmptyDefault(java.util.List<Integer> intListEmptyDefault) {
+        this.intListEmptyDefault = intListEmptyDefault;
+    }
+
+    public java.util.List<SomeObject> getObjectListEmptyDefault() {
+        return objectListEmptyDefault;
+    }
+    public void setObjectListEmptyDefault(java.util.List<SomeObject> objectListEmptyDefault) {
+        this.objectListEmptyDefault = objectListEmptyDefault;
+    }
+
+    public java.util.Map<String, Object> getUserDefinedFields() {
+        return userDefinedFields;
+    }
+    public void setUserDefinedFields(java.util.Map<String, Object> userDefinedFields) {
+        this.userDefinedFields = userDefinedFields;
+    }
+
+
+
+    public static InputWithDefaults.Builder builder() {
+        return new InputWithDefaults.Builder();
+    }
+
+    public static class Builder {
+
+        private Double floatVal = 1.23;
+        private Boolean booleanVal = false;
+        private Integer intVal = 42;
+        private String stringVal = "my-default";
+        private MyEnum enumVal = MyEnum.ONE;
+        private MyEnum nonNullEnumVal = MyEnum.TWO;
+        private SomeObject objectWithNullDefault = null;
+        private SomeObject objectWithNonNullDefault;
+        private java.util.List<Integer> intList = java.util.Arrays.asList(1, 2, 3);
+        private java.util.List<Integer> intListEmptyDefault = java.util.Collections.emptyList();
+        private java.util.List<SomeObject> objectListEmptyDefault = java.util.Collections.emptyList();
+        private java.util.Map<String, Object> userDefinedFields;
+
+        public Builder() {
+        }
+
+        public Builder setFloatVal(Double floatVal) {
+            this.floatVal = floatVal;
+            return this;
+        }
+
+        public Builder setBooleanVal(Boolean booleanVal) {
+            this.booleanVal = booleanVal;
+            return this;
+        }
+
+        public Builder setIntVal(Integer intVal) {
+            this.intVal = intVal;
+            return this;
+        }
+
+        public Builder setStringVal(String stringVal) {
+            this.stringVal = stringVal;
+            return this;
+        }
+
+        public Builder setEnumVal(MyEnum enumVal) {
+            this.enumVal = enumVal;
+            return this;
+        }
+
+        public Builder setNonNullEnumVal(MyEnum nonNullEnumVal) {
+            this.nonNullEnumVal = nonNullEnumVal;
+            return this;
+        }
+
+        public Builder setObjectWithNullDefault(SomeObject objectWithNullDefault) {
+            this.objectWithNullDefault = objectWithNullDefault;
+            return this;
+        }
+
+        public Builder setObjectWithNonNullDefault(SomeObject objectWithNonNullDefault) {
+            this.objectWithNonNullDefault = objectWithNonNullDefault;
+            return this;
+        }
+
+        public Builder setIntList(java.util.List<Integer> intList) {
+            this.intList = intList;
+            return this;
+        }
+
+        public Builder setIntListEmptyDefault(java.util.List<Integer> intListEmptyDefault) {
+            this.intListEmptyDefault = intListEmptyDefault;
+            return this;
+        }
+
+        public Builder setObjectListEmptyDefault(java.util.List<SomeObject> objectListEmptyDefault) {
+            this.objectListEmptyDefault = objectListEmptyDefault;
+            return this;
+        }
+
+        public Builder setUserDefinedFields(java.util.Map<String, Object> userDefinedFields) {
+            this.userDefinedFields = userDefinedFields;
+            return this;
+        }
+
+
+        public InputWithDefaults build() {
+            return new InputWithDefaults(floatVal, booleanVal, intVal, stringVal, enumVal, nonNullEnumVal, objectWithNullDefault, objectWithNonNullDefault, intList, intListEmptyDefault, objectListEmptyDefault, userDefinedFields);
+        }
+
+    }
+}
\ No newline at end of file

src/test/resources/expected-classes/unknown-fields/MyEnum.java.txt

+package com.kobylynskyi.graphql.testdefaults;
+
+@javax.annotation.Generated(
+    value = "com.kobylynskyi.graphql.codegen.GraphQLCodegen",
+    date = "2020-12-31T23:59:59-0500"
+)
+public enum MyEnum {
+
+    ONE("ONE"),
+    TWO("TWO"),
+    THREE("THREE");
+
+    private final String graphqlName;
+
+    private MyEnum(String graphqlName) {
+        this.graphqlName = graphqlName;
+    }
+
+    @Override
+    public String toString() {
+        return this.graphqlName;
+    }
+
+}
\ No newline at end of file

src/test/resources/expected-classes/unknown-fields/SomeObject.java.txt

+package com.kobylynskyi.graphql.testdefaults;
+
+
+@javax.annotation.Generated(
+    value = "com.kobylynskyi.graphql.codegen.GraphQLCodegen",
+    date = "2020-12-31T23:59:59-0500"
+)
+public class SomeObject implements java.io.Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    @javax.validation.constraints.NotNull
+    private String name;
+    @com.fasterxml.jackson.annotation.JsonAnyGetter
+    @com.fasterxml.jackson.annotation.JsonAnySetter
+    private java.util.Map<String, Object> userDefinedFields;
+
+    public SomeObject() {
+    }
+
+    public SomeObject(String name, java.util.Map<String, Object> userDefinedFields) {
+        this.name = name;
+        this.userDefinedFields = userDefinedFields;
+    }
+
+    public String getName() {
+        return name;
+    }
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public java.util.Map<String, Object> getUserDefinedFields() {
+        return userDefinedFields;
+    }
+    public void setUserDefinedFields(java.util.Map<String, Object> userDefinedFields) {
+        this.userDefinedFields = userDefinedFields;
+    }
+
+
+
+    public static SomeObject.Builder builder() {
+        return new SomeObject.Builder();
+    }
+
+    public static class Builder {
+
+        private String name;
+        private java.util.Map<String, Object> userDefinedFields;
+
+        public Builder() {
+        }
+
+        public Builder setName(String name) {
+            this.name = name;
+            return this;
+        }
+
+        public Builder setUserDefinedFields(java.util.Map<String, Object> userDefinedFields) {
+            this.userDefinedFields = userDefinedFields;
+            return this;
+        }
+
+
+        public SomeObject build() {
+            return new SomeObject(name, userDefinedFields);
+        }
+
+    }
+}
\ No newline at end of file