@graphql-codegen/java-apollo-android 2.2.13 → 2.3.0-alpha-29eb1293b.0

package/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/cjs/plugin.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.plugin = void 0;
+const plugin_helpers_1 = require("@graphql-codegen/plugin-helpers");
+const graphql_1 = require("graphql");
+const input_type_visitor_js_1 = require("./input-type-visitor.js");
+const operation_visitor_js_1 = require("./operation-visitor.js");
+const file_type_js_1 = require("./file-type.js");
+const custom_type_class_js_1 = require("./custom-type-class.js");
+const plugin = (schema, documents, config) => {
+    const allAst = (0, graphql_1.concatAST)(documents.map(v => v.document));
+    const allFragments = [
+        ...allAst.definitions.filter(d => d.kind === graphql_1.Kind.FRAGMENT_DEFINITION).map(fragmentDef => ({
+            node: fragmentDef,
+            name: fragmentDef.name.value,
+            onType: fragmentDef.typeCondition.name.value,
+            isExternal: false,
+        })),
+        ...(config.externalFragments || []),
+    ];
+    let visitor;
+    switch (config.fileType) {
+        case file_type_js_1.FileType.FRAGMENT:
+        case file_type_js_1.FileType.OPERATION: {
+            visitor = new operation_visitor_js_1.OperationVisitor(schema, config, allFragments);
+            break;
+        }
+        case file_type_js_1.FileType.INPUT_TYPE: {
+            visitor = new input_type_visitor_js_1.InputTypeVisitor(schema, config);
+            break;
+        }
+        case file_type_js_1.FileType.CUSTOM_TYPES: {
+            visitor = new custom_type_class_js_1.CustomTypeClassVisitor(schema, config);
+            break;
+        }
+    }
+    if (!visitor) {
+        return { content: '' };
+    }
+    const visitResult = (0, plugin_helpers_1.oldVisit)(allAst, visitor);
+    const additionalContent = visitor.additionalContent();
+    const imports = visitor.getImports();
+    return {
+        prepend: [`package ${visitor.getPackage()};\n`, ...imports],
+        content: '\n' + [...visitResult.definitions.filter(a => a && typeof a === 'string'), additionalContent].join('\n'),
+    };
+};
+exports.plugin = plugin;

package/cjs/preset.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preset = void 0;
+const graphql_1 = require("graphql");
+const path_1 = require("path");
+const file_type_js_1 = require("./file-type.js");
+const change_case_all_1 = require("change-case-all");
+const packageNameToDirectory = (packageName) => {
+    return `./${packageName.split('.').join('/')}/`;
+};
+exports.preset = {
+    buildGeneratesSection: options => {
+        const outDir = options.baseOutputDir;
+        const inputTypesAst = [];
+        (0, graphql_1.visit)(options.schema, {
+            InputObjectTypeDefinition: {
+                enter(node) {
+                    inputTypesAst.push(node);
+                },
+            },
+        });
+        const inputTypesDocumentNode = { kind: graphql_1.Kind.DOCUMENT, definitions: inputTypesAst };
+        const allAst = (0, graphql_1.concatAST)(options.documents.map(v => v.document));
+        const operationsAst = allAst.definitions.filter(d => d.kind === graphql_1.Kind.OPERATION_DEFINITION);
+        const fragments = allAst.definitions.filter(d => d.kind === graphql_1.Kind.FRAGMENT_DEFINITION);
+        const externalFragments = fragments.map(frag => ({
+            isExternal: true,
+            importFrom: frag.name.value,
+            name: frag.name.value,
+            onType: frag.typeCondition.name.value,
+            node: frag,
+        }));
+        return [
+            {
+                filename: (0, path_1.join)(outDir, packageNameToDirectory(options.config.typePackage), 'CustomType.java'),
+                plugins: options.plugins,
+                pluginMap: options.pluginMap,
+                config: {
+                    ...options.config,
+                    fileType: file_type_js_1.FileType.CUSTOM_TYPES,
+                },
+                schema: options.schema,
+                documents: [],
+            },
+            ...inputTypesDocumentNode.definitions.map((ast) => {
+                const document = { kind: graphql_1.Kind.DOCUMENT, definitions: [ast] };
+                return {
+                    filename: (0, path_1.join)(outDir, packageNameToDirectory(options.config.typePackage), ast.name.value + '.java'),
+                    plugins: options.plugins,
+                    pluginMap: options.pluginMap,
+                    config: {
+                        ...options.config,
+                        fileType: file_type_js_1.FileType.INPUT_TYPE,
+                        skipDocumentsValidation: true,
+                    },
+                    schema: options.schema,
+                    documents: [{ document, location: '' }],
+                };
+            }),
+            ...operationsAst.map((ast) => {
+                const fileName = ast.name.value.toLowerCase().endsWith(ast.operation)
+                    ? ast.name.value
+                    : `${ast.name.value}${(0, change_case_all_1.pascalCase)(ast.operation)}`;
+                const document = { kind: graphql_1.Kind.DOCUMENT, definitions: [ast] };
+                return {
+                    filename: (0, path_1.join)(outDir, packageNameToDirectory(options.config.package), fileName + '.java'),
+                    plugins: options.plugins,
+                    pluginMap: options.pluginMap,
+                    config: {
+                        ...options.config,
+                        fileType: file_type_js_1.FileType.OPERATION,
+                        externalFragments,
+                    },
+                    schema: options.schema,
+                    documents: [{ document, location: '' }],
+                };
+            }),
+            ...fragments.map((ast) => {
+                const document = { kind: graphql_1.Kind.DOCUMENT, definitions: [ast] };
+                return {
+                    filename: (0, path_1.join)(outDir, packageNameToDirectory(options.config.fragmentPackage), ast.name.value + '.java'),
+                    plugins: options.plugins,
+                    pluginMap: options.pluginMap,
+                    config: {
+                        ...options.config,
+                        fileType: file_type_js_1.FileType.FRAGMENT,
+                        externalFragments,
+                    },
+                    schema: options.schema,
+                    documents: [{ document, location: '' }],
+                };
+            }),
+        ];
+    },
+};

package/cjs/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/visitor-config.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/esm/base-java-visitor.js

@@ -0,0 +1,110 @@
+import { Imports } from './imports.js';
+import { BaseVisitor, getBaseTypeNode, buildScalars } from '@graphql-codegen/visitor-plugin-common';
+import { getBaseType } from '@graphql-codegen/plugin-helpers';
+import { JAVA_SCALARS } from '@graphql-codegen/java-common';
+import { isScalarType, isInputObjectType, Kind, isNonNullType, isListType, GraphQLObjectType, } from 'graphql';
+export const SCALAR_TO_WRITER_METHOD = {
+    ID: 'writeString',
+    String: 'writeString',
+    Int: 'writeInt',
+    Boolean: 'writeBoolean',
+    Float: 'writeDouble',
+};
+function isTypeNode(type) {
+    return type && !!type.kind;
+}
+export class BaseJavaVisitor extends BaseVisitor {
+    constructor(_schema, rawConfig, additionalConfig) {
+        super(rawConfig, {
+            ...additionalConfig,
+            scalars: buildScalars(_schema, { ID: 'String' }, JAVA_SCALARS),
+        });
+        this._schema = _schema;
+        this._imports = new Set();
+    }
+    getPackage() {
+        return '';
+    }
+    additionalContent() {
+        return '';
+    }
+    getImports() {
+        return Array.from(this._imports).map(imp => `import ${imp};`);
+    }
+    getImplementingTypes(node) {
+        const allTypesMap = this._schema.getTypeMap();
+        const implementingTypes = [];
+        for (const graphqlType of Object.values(allTypesMap)) {
+            if (graphqlType instanceof GraphQLObjectType) {
+                const allInterfaces = graphqlType.getInterfaces();
+                if (allInterfaces.find(int => int.name === node.name)) {
+                    implementingTypes.push(graphqlType.name);
+                }
+            }
+        }
+        return implementingTypes;
+    }
+    transformType(type) {
+        let schemaType;
+        let isNonNull;
+        if (isTypeNode(type)) {
+            const baseTypeNode = getBaseTypeNode(type);
+            schemaType = this._schema.getType(baseTypeNode.name.value);
+            isNonNull = type.kind === Kind.NON_NULL_TYPE;
+        }
+        else {
+            schemaType = this._schema.getType(getBaseType(type).name);
+            isNonNull = isNonNullType(type);
+        }
+        const javaType = this.getJavaClass(schemaType);
+        const annotation = isNonNull ? 'Nonnull' : 'Nullable';
+        const typeToUse = isTypeNode(type)
+            ? this.getListTypeNodeWrapped(javaType, type)
+            : this.getListTypeWrapped(javaType, type);
+        return {
+            baseType: schemaType.name,
+            javaType,
+            isNonNull,
+            annotation,
+            typeToUse,
+        };
+    }
+    // Replaces a GraphQL type with a Java class
+    getJavaClass(schemaType) {
+        let typeToUse = schemaType.name;
+        if (isScalarType(schemaType)) {
+            const scalar = this.scalars[schemaType.name] || 'Object';
+            if (Imports[scalar]) {
+                this._imports.add(Imports[scalar]);
+            }
+            typeToUse = scalar;
+        }
+        else if (isInputObjectType(schemaType)) {
+            // Make sure to import it if it's in use
+            this._imports.add(`${this.config.typePackage}.${schemaType.name}`);
+        }
+        return typeToUse;
+    }
+    getListTypeWrapped(toWrap, type) {
+        if (isNonNullType(type)) {
+            return this.getListTypeWrapped(toWrap, type.ofType);
+        }
+        if (isListType(type)) {
+            const child = this.getListTypeWrapped(toWrap, type.ofType);
+            this._imports.add(Imports.List);
+            return `List<${child}>`;
+        }
+        return toWrap;
+    }
+    getListTypeNodeWrapped(toWrap, type) {
+        if (type.kind === Kind.NON_NULL_TYPE) {
+            return this.getListTypeNodeWrapped(toWrap, type.type);
+        }
+        if (type.kind === Kind.LIST_TYPE) {
+            const child = this.getListTypeNodeWrapped(toWrap, type.type);
+            this._imports.add(Imports.List);
+            return `List<${child}>`;
+        }
+        return toWrap;
+    }
+}

package/esm/custom-type-class.js

@@ -0,0 +1,65 @@
+import { isScalarType } from 'graphql';
+import { BaseJavaVisitor } from './base-java-visitor.js';
+import { indentMultiline } from '@graphql-codegen/visitor-plugin-common';
+import { Imports } from './imports.js';
+import { JavaDeclarationBlock } from '@graphql-codegen/java-common';
+const filteredScalars = ['String', 'Float', 'Int', 'Boolean'];
+export class CustomTypeClassVisitor extends BaseJavaVisitor {
+    constructor(schema, rawConfig) {
+        super(schema, rawConfig, {
+            typePackage: rawConfig.typePackage || 'type',
+        });
+    }
+    extract(name) {
+        const lastIndex = name.lastIndexOf('.');
+        if (lastIndex === -1) {
+            return {
+                className: name,
+                importFrom: Imports[name] || null,
+            };
+        }
+        return {
+            className: name.substring(lastIndex + 1),
+            importFrom: name,
+        };
+    }
+    additionalContent() {
+        this._imports.add(Imports.ScalarType);
+        this._imports.add(Imports.Class);
+        this._imports.add(Imports.Override);
+        this._imports.add(Imports.Generated);
+        const allTypes = this._schema.getTypeMap();
+        const enumValues = Object.keys(allTypes)
+            .filter(t => isScalarType(allTypes[t]) && !filteredScalars.includes(t))
+            .map(t => allTypes[t])
+            .map(scalarType => {
+            const uppercaseName = scalarType.name.toUpperCase();
+            const javaType = this.extract(this.scalars[scalarType.name] || 'String');
+            if (javaType.importFrom) {
+                this._imports.add(javaType.importFrom);
+            }
+            return indentMultiline(`${uppercaseName} {
+  @Override
+  public String typeName() {
+    return "${scalarType.name}";
+  }
+
+  @Override
+  public Class javaType() {
+    return ${javaType.className}.class;
+  }
+}`);
+        })
+            .join(',\n\n');
+        return new JavaDeclarationBlock()
+            .annotate([`Generated("Apollo GraphQL")`])
+            .access('public')
+            .asKind('enum')
+            .withName('CustomType')
+            .implements(['ScalarType'])
+            .withBlock(enumValues).string;
+    }
+    getPackage() {
+        return this.config.typePackage;
+    }
+}

package/esm/field-arguments.js

@@ -0,0 +1,32 @@
+import { Imports } from './imports.js';
+import { oldVisit } from '@graphql-codegen/plugin-helpers';
+export function visitFieldArguments(selection, imports) {
+    if (!selection.arguments || selection.arguments.length === 0) {
+        return 'null';
+    }
+    imports.add(Imports.UnmodifiableMapBuilder);
+    imports.add(Imports.String);
+    imports.add(Imports.Object);
+    return oldVisit(selection, {
+        leave: {
+            Field: (node) => {
+                return (`new UnmodifiableMapBuilder<String, Object>(${node.arguments.length})` + node.arguments.join('') + '.build()');
+            },
+            Argument: (node) => {
+                return `.put("${node.name.value}", ${node.value})`;
+            },
+            ObjectValue: (node) => {
+                return `new UnmodifiableMapBuilder<String, Object>(${node.fields.length})` + node.fields.join('') + '.build()';
+            },
+            ObjectField: (node) => {
+                return `.put("${node.name.value}", ${node.value})`;
+            },
+            Variable: (node) => {
+                return `new UnmodifiableMapBuilder<String, Object>(2).put("kind", "Variable").put("variableName", "${node.name.value}").build()`;
+            },
+            StringValue: (node) => `"${node.value}"`,
+            IntValue: (node) => `"${node.value}"`,
+            FloatValue: (node) => `"${node.value}"`,
+        },
+    });
+}

package/esm/file-type.js

@@ -0,0 +1,7 @@
+export var FileType;
+(function (FileType) {
+    FileType[FileType["INPUT_TYPE"] = 0] = "INPUT_TYPE";
+    FileType[FileType["OPERATION"] = 1] = "OPERATION";
+    FileType[FileType["FRAGMENT"] = 2] = "FRAGMENT";
+    FileType[FileType["CUSTOM_TYPES"] = 3] = "CUSTOM_TYPES";
+})(FileType || (FileType = {}));

package/esm/imports.js

@@ -0,0 +1,42 @@
+export const Imports = {
+    // Primitives
+    String: 'java.lang.String',
+    Boolean: 'java.lang.Boolean',
+    Integer: 'java.lang.Integer',
+    Object: 'java.lang.Object',
+    Float: 'java.lang.Float',
+    Long: 'java.lang.Long',
+    // Java Base
+    Class: 'java.lang.Class',
+    Arrays: 'java.util.Arrays',
+    List: 'java.util.List',
+    IOException: 'java.io.IOException',
+    Collections: 'java.util.Collections',
+    LinkedHashMap: 'java.util.LinkedHashMap',
+    Map: 'java.util.Map',
+    // Annotations
+    Nonnull: 'javax.annotation.Nonnull',
+    Nullable: 'javax.annotation.Nullable',
+    Override: 'java.lang.Override',
+    Generated: 'javax.annotation.Generated',
+    // Apollo Android
+    ScalarType: 'com.apollographql.apollo.api.ScalarType',
+    GraphqlFragment: 'com.apollographql.apollo.api.GraphqlFragment',
+    Operation: 'com.apollographql.apollo.api.Operation',
+    OperationName: 'com.apollographql.apollo.api.OperationName',
+    Mutation: 'com.apollographql.apollo.api.Mutation',
+    Query: 'com.apollographql.apollo.api.Query',
+    Subscription: 'com.apollographql.apollo.api.Subscription',
+    ResponseField: 'com.apollographql.apollo.api.ResponseField',
+    ResponseFieldMapper: 'com.apollographql.apollo.api.ResponseFieldMapper',
+    ResponseFieldMarshaller: 'com.apollographql.apollo.api.ResponseFieldMarshaller',
+    ResponseReader: 'com.apollographql.apollo.api.ResponseReader',
+    ResponseWriter: 'com.apollographql.apollo.api.ResponseWriter',
+    FragmentResponseFieldMapper: 'com.apollographql.apollo.api.FragmentResponseFieldMapper',
+    UnmodifiableMapBuilder: 'com.apollographql.apollo.api.internal.UnmodifiableMapBuilder',
+    Utils: 'com.apollographql.apollo.api.internal.Utils',
+    InputType: 'com.apollographql.apollo.api.InputType',
+    Input: 'com.apollographql.apollo.api.Input',
+    InputFieldMarshaller: 'com.apollographql.apollo.api.InputFieldMarshaller',
+    InputFieldWriter: 'com.apollographql.apollo.api.InputFieldWriter',
+};

package/esm/index.js

@@ -0,0 +1,2 @@
+export * from './plugin.js';
+export * from './preset.js';

package/esm/input-type-visitor.js

@@ -0,0 +1,183 @@
+import { getBaseTypeNode, indent, indentMultiline } from '@graphql-codegen/visitor-plugin-common';
+import { JavaDeclarationBlock } from '@graphql-codegen/java-common';
+import { isScalarType, isInputObjectType, Kind, isEnumType, } from 'graphql';
+import { Imports } from './imports.js';
+import { BaseJavaVisitor, SCALAR_TO_WRITER_METHOD } from './base-java-visitor.js';
+export class InputTypeVisitor extends BaseJavaVisitor {
+    constructor(_schema, rawConfig) {
+        super(_schema, rawConfig, {
+            typePackage: rawConfig.typePackage || 'type',
+        });
+    }
+    getPackage() {
+        return this.config.typePackage;
+    }
+    addInputMembers(cls, fields) {
+        fields.forEach(field => {
+            const type = this.transformType(field.type);
+            const actualType = type.isNonNull ? type.typeToUse : `Input<${type.typeToUse}>`;
+            const annotations = type.isNonNull ? [type.annotation] : [];
+            this._imports.add(Imports[type.annotation]);
+            cls.addClassMember(field.name.value, actualType, null, annotations, 'private', { final: true });
+            cls.addClassMethod(field.name.value, actualType, `return this.${field.name.value};`, [], [type.annotation], 'public');
+        });
+    }
+    addInputCtor(cls, className, fields) {
+        const impl = fields.map(field => `this.${field.name.value} = ${field.name.value};`).join('\n');
+        cls.addClassMethod(className, null, impl, fields.map(f => {
+            const type = this.transformType(f.type);
+            const actualType = type.isNonNull ? type.typeToUse : `Input<${type.typeToUse}>`;
+            this._imports.add(Imports[type.annotation]);
+            return {
+                name: f.name.value,
+                type: actualType,
+                annotations: type.isNonNull ? [type.annotation] : [],
+            };
+        }), [], 'public');
+    }
+    getFieldWriterCall(field, listItemCall = false) {
+        const baseType = getBaseTypeNode(field.type);
+        const schemaType = this._schema.getType(baseType.name.value);
+        const isNonNull = field.type.kind === Kind.NON_NULL_TYPE;
+        let writerMethod = null;
+        if (isScalarType(schemaType)) {
+            writerMethod = SCALAR_TO_WRITER_METHOD[schemaType.name] || 'writeCustom';
+        }
+        else if (isInputObjectType(schemaType)) {
+            return listItemCall
+                ? `writeObject($item.marshaller())`
+                : `writeObject("${field.name.value}", ${field.name.value}.value != null ? ${field.name.value}.value.marshaller() : null)`;
+        }
+        else if (isEnumType(schemaType)) {
+            writerMethod = 'writeString';
+        }
+        return listItemCall
+            ? `${writerMethod}($item)`
+            : `${writerMethod}("${field.name.value}", ${field.name.value}${isNonNull ? '' : '.value'})`;
+    }
+    getFieldWithTypePrefix(field, wrapWith = null, applyNullable = false) {
+        this._imports.add(Imports.Input);
+        const typeToUse = this.getJavaClass(this._schema.getType(getBaseTypeNode(field.type).name.value));
+        const isNonNull = field.type.kind === Kind.NON_NULL_TYPE;
+        const name = field.kind === Kind.INPUT_VALUE_DEFINITION ? field.name.value : field.variable.name.value;
+        if (isNonNull) {
+            this._imports.add(Imports.Nonnull);
+            return `@Nonnull ${typeToUse} ${name}`;
+        }
+        if (wrapWith) {
+            return typeof wrapWith === 'function' ? `${wrapWith(typeToUse)} ${name}` : `${wrapWith}<${typeToUse}> ${name}`;
+        }
+        if (applyNullable) {
+            this._imports.add(Imports.Nullable);
+        }
+        return `${applyNullable ? '@Nullable ' : ''}${typeToUse} ${name}`;
+    }
+    buildFieldsMarshaller(field) {
+        const isNonNull = field.type.kind === Kind.NON_NULL_TYPE;
+        const isArray = field.type.kind === Kind.LIST_TYPE ||
+            (field.type.kind === Kind.NON_NULL_TYPE && field.type.type.kind === Kind.LIST_TYPE);
+        const call = this.getFieldWriterCall(field, isArray);
+        const baseTypeNode = getBaseTypeNode(field.type);
+        const listItemType = this.getJavaClass(this._schema.getType(baseTypeNode.name.value));
+        let result = '';
+        // TODO: Refactor
+        if (isArray) {
+            result = `writer.writeList("${field.name.value}", ${field.name.value}.value != null ? new InputFieldWriter.ListWriter() {
+  @Override
+  public void write(InputFieldWriter.ListItemWriter listItemWriter) throws IOException {
+    for (${listItemType} $item : ${field.name.value}.value) {
+      listItemWriter.${call};
+    }
+  }
+} : null);`;
+        }
+        else {
+            result = indent(`writer.${call};`);
+        }
+        if (isNonNull) {
+            return result;
+        }
+        return indentMultiline(`if(${field.name.value}.defined) {
+${indentMultiline(result)}
+}`);
+    }
+    buildMarshallerOverride(fields) {
+        this._imports.add(Imports.Override);
+        this._imports.add(Imports.IOException);
+        this._imports.add(Imports.InputFieldWriter);
+        this._imports.add(Imports.InputFieldMarshaller);
+        const allMarshallers = fields.map(field => indentMultiline(this.buildFieldsMarshaller(field), 2));
+        return indentMultiline(`@Override
+public InputFieldMarshaller marshaller() {
+  return new InputFieldMarshaller() {
+    @Override
+    public void marshal(InputFieldWriter writer) throws IOException {
+${allMarshallers.join('\n')}
+    }
+  };
+}`);
+    }
+    buildBuilderNestedClass(className, fields) {
+        const builderClassName = 'Builder';
+        const privateFields = fields
+            .map(field => {
+            const isArray = field.type.kind === Kind.LIST_TYPE ||
+                (field.type.kind === Kind.NON_NULL_TYPE && field.type.type.kind === Kind.LIST_TYPE);
+            const fieldType = this.getFieldWithTypePrefix(field, v => (!isArray ? `Input<${v}>` : `Input<List<${v}>>`));
+            const isNonNull = field.type.kind === Kind.NON_NULL_TYPE;
+            return `private ${fieldType}${isNonNull ? '' : ' = Input.absent()'};`;
+        })
+            .map(s => indent(s));
+        const setters = fields
+            .map(field => {
+            const isArray = field.type.kind === Kind.LIST_TYPE ||
+                (field.type.kind === Kind.NON_NULL_TYPE && field.type.type.kind === Kind.LIST_TYPE);
+            const fieldType = this.getFieldWithTypePrefix(field, isArray ? 'List' : null);
+            const isNonNull = field.type.kind === Kind.NON_NULL_TYPE;
+            return `\npublic ${builderClassName} ${field.name.value}(${isNonNull ? '' : '@Nullable '}${fieldType}) {
+  this.${field.name.value} = ${isNonNull ? field.name.value : `Input.fromNullable(${field.name.value})`};
+  return this;
+}`;
+        })
+            .map(s => indentMultiline(s));
+        const nonNullFields = fields
+            .filter(f => f.type.kind === Kind.NON_NULL_TYPE)
+            .map(nnField => {
+            this._imports.add(Imports.Utils);
+            return indent(`Utils.checkNotNull(${nnField.name.value}, "${nnField.name.value} == null");`, 1);
+        });
+        const ctor = '\n' + indent(`${builderClassName}() {}`);
+        const buildFn = indentMultiline(`public ${className} build() {
+${nonNullFields.join('\n')}
+  return new ${className}(${fields.map(f => f.name.value).join(', ')});
+}`);
+        const body = [...privateFields, ctor, ...setters, '', buildFn].join('\n');
+        return indentMultiline(new JavaDeclarationBlock()
+            .withName(builderClassName)
+            .access('public')
+            .final()
+            .static()
+            .withBlock(body)
+            .asKind('class').string);
+    }
+    InputObjectTypeDefinition(node) {
+        const className = node.name.value;
+        this._imports.add(Imports.InputType);
+        this._imports.add(Imports.Generated);
+        const cls = new JavaDeclarationBlock()
+            .annotate([`Generated("Apollo GraphQL")`])
+            .access('public')
+            .final()
+            .asKind('class')
+            .withName(className)
+            .implements(['InputType']);
+        this.addInputMembers(cls, node.fields);
+        this.addInputCtor(cls, className, node.fields);
+        cls.addClassMethod('builder', 'Builder', 'return new Builder();', [], [], 'public', { static: true });
+        const marshallerOverride = this.buildMarshallerOverride(node.fields);
+        const builderClass = this.buildBuilderNestedClass(className, node.fields);
+        const classBlock = [marshallerOverride, '', builderClass].join('\n');
+        cls.withBlock(classBlock);
+        return cls.string;
+    }
+}