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

package/cjs/base-java-visitor.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseJavaVisitor = exports.SCALAR_TO_WRITER_METHOD = void 0;
+const imports_js_1 = require("./imports.js");
+const visitor_plugin_common_1 = require("@graphql-codegen/visitor-plugin-common");
+const plugin_helpers_1 = require("@graphql-codegen/plugin-helpers");
+const java_common_1 = require("@graphql-codegen/java-common");
+const graphql_1 = require("graphql");
+exports.SCALAR_TO_WRITER_METHOD = {
+    ID: 'writeString',
+    String: 'writeString',
+    Int: 'writeInt',
+    Boolean: 'writeBoolean',
+    Float: 'writeDouble',
+};
+function isTypeNode(type) {
+    return type && !!type.kind;
+}
+class BaseJavaVisitor extends visitor_plugin_common_1.BaseVisitor {
+    constructor(_schema, rawConfig, additionalConfig) {
+        super(rawConfig, {
+            ...additionalConfig,
+            scalars: (0, visitor_plugin_common_1.buildScalars)(_schema, { ID: 'String' }, java_common_1.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 graphql_1.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 = (0, visitor_plugin_common_1.getBaseTypeNode)(type);
+            schemaType = this._schema.getType(baseTypeNode.name.value);
+            isNonNull = type.kind === graphql_1.Kind.NON_NULL_TYPE;
+        }
+        else {
+            schemaType = this._schema.getType((0, plugin_helpers_1.getBaseType)(type).name);
+            isNonNull = (0, graphql_1.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 ((0, graphql_1.isScalarType)(schemaType)) {
+            const scalar = this.scalars[schemaType.name] || 'Object';
+            if (imports_js_1.Imports[scalar]) {
+                this._imports.add(imports_js_1.Imports[scalar]);
+            }
+            typeToUse = scalar;
+        }
+        else if ((0, graphql_1.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 ((0, graphql_1.isNonNullType)(type)) {
+            return this.getListTypeWrapped(toWrap, type.ofType);
+        }
+        if ((0, graphql_1.isListType)(type)) {
+            const child = this.getListTypeWrapped(toWrap, type.ofType);
+            this._imports.add(imports_js_1.Imports.List);
+            return `List<${child}>`;
+        }
+        return toWrap;
+    }
+    getListTypeNodeWrapped(toWrap, type) {
+        if (type.kind === graphql_1.Kind.NON_NULL_TYPE) {
+            return this.getListTypeNodeWrapped(toWrap, type.type);
+        }
+        if (type.kind === graphql_1.Kind.LIST_TYPE) {
+            const child = this.getListTypeNodeWrapped(toWrap, type.type);
+            this._imports.add(imports_js_1.Imports.List);
+            return `List<${child}>`;
+        }
+        return toWrap;
+    }
+}
+exports.BaseJavaVisitor = BaseJavaVisitor;

package/cjs/custom-type-class.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomTypeClassVisitor = void 0;
+const graphql_1 = require("graphql");
+const base_java_visitor_js_1 = require("./base-java-visitor.js");
+const visitor_plugin_common_1 = require("@graphql-codegen/visitor-plugin-common");
+const imports_js_1 = require("./imports.js");
+const java_common_1 = require("@graphql-codegen/java-common");
+const filteredScalars = ['String', 'Float', 'Int', 'Boolean'];
+class CustomTypeClassVisitor extends base_java_visitor_js_1.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_js_1.Imports[name] || null,
+            };
+        }
+        return {
+            className: name.substring(lastIndex + 1),
+            importFrom: name,
+        };
+    }
+    additionalContent() {
+        this._imports.add(imports_js_1.Imports.ScalarType);
+        this._imports.add(imports_js_1.Imports.Class);
+        this._imports.add(imports_js_1.Imports.Override);
+        this._imports.add(imports_js_1.Imports.Generated);
+        const allTypes = this._schema.getTypeMap();
+        const enumValues = Object.keys(allTypes)
+            .filter(t => (0, graphql_1.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 (0, visitor_plugin_common_1.indentMultiline)(`${uppercaseName} {
+  @Override
+  public String typeName() {
+    return "${scalarType.name}";
+  }
+
+  @Override
+  public Class javaType() {
+    return ${javaType.className}.class;
+  }
+}`);
+        })
+            .join(',\n\n');
+        return new java_common_1.JavaDeclarationBlock()
+            .annotate([`Generated("Apollo GraphQL")`])
+            .access('public')
+            .asKind('enum')
+            .withName('CustomType')
+            .implements(['ScalarType'])
+            .withBlock(enumValues).string;
+    }
+    getPackage() {
+        return this.config.typePackage;
+    }
+}
+exports.CustomTypeClassVisitor = CustomTypeClassVisitor;

package/cjs/field-arguments.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.visitFieldArguments = void 0;
+const imports_js_1 = require("./imports.js");
+const plugin_helpers_1 = require("@graphql-codegen/plugin-helpers");
+function visitFieldArguments(selection, imports) {
+    if (!selection.arguments || selection.arguments.length === 0) {
+        return 'null';
+    }
+    imports.add(imports_js_1.Imports.UnmodifiableMapBuilder);
+    imports.add(imports_js_1.Imports.String);
+    imports.add(imports_js_1.Imports.Object);
+    return (0, plugin_helpers_1.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}"`,
+        },
+    });
+}
+exports.visitFieldArguments = visitFieldArguments;

package/cjs/file-type.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileType = void 0;
+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 = exports.FileType || (exports.FileType = {}));

package/cjs/imports.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Imports = void 0;
+exports.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/cjs/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./plugin.js"), exports);
+tslib_1.__exportStar(require("./preset.js"), exports);

package/cjs/input-type-visitor.js

@@ -0,0 +1,187 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InputTypeVisitor = void 0;
+const visitor_plugin_common_1 = require("@graphql-codegen/visitor-plugin-common");
+const java_common_1 = require("@graphql-codegen/java-common");
+const graphql_1 = require("graphql");
+const imports_js_1 = require("./imports.js");
+const base_java_visitor_js_1 = require("./base-java-visitor.js");
+class InputTypeVisitor extends base_java_visitor_js_1.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_js_1.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_js_1.Imports[type.annotation]);
+            return {
+                name: f.name.value,
+                type: actualType,
+                annotations: type.isNonNull ? [type.annotation] : [],
+            };
+        }), [], 'public');
+    }
+    getFieldWriterCall(field, listItemCall = false) {
+        const baseType = (0, visitor_plugin_common_1.getBaseTypeNode)(field.type);
+        const schemaType = this._schema.getType(baseType.name.value);
+        const isNonNull = field.type.kind === graphql_1.Kind.NON_NULL_TYPE;
+        let writerMethod = null;
+        if ((0, graphql_1.isScalarType)(schemaType)) {
+            writerMethod = base_java_visitor_js_1.SCALAR_TO_WRITER_METHOD[schemaType.name] || 'writeCustom';
+        }
+        else if ((0, graphql_1.isInputObjectType)(schemaType)) {
+            return listItemCall
+                ? `writeObject($item.marshaller())`
+                : `writeObject("${field.name.value}", ${field.name.value}.value != null ? ${field.name.value}.value.marshaller() : null)`;
+        }
+        else if ((0, graphql_1.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_js_1.Imports.Input);
+        const typeToUse = this.getJavaClass(this._schema.getType((0, visitor_plugin_common_1.getBaseTypeNode)(field.type).name.value));
+        const isNonNull = field.type.kind === graphql_1.Kind.NON_NULL_TYPE;
+        const name = field.kind === graphql_1.Kind.INPUT_VALUE_DEFINITION ? field.name.value : field.variable.name.value;
+        if (isNonNull) {
+            this._imports.add(imports_js_1.Imports.Nonnull);
+            return `@Nonnull ${typeToUse} ${name}`;
+        }
+        if (wrapWith) {
+            return typeof wrapWith === 'function' ? `${wrapWith(typeToUse)} ${name}` : `${wrapWith}<${typeToUse}> ${name}`;
+        }
+        if (applyNullable) {
+            this._imports.add(imports_js_1.Imports.Nullable);
+        }
+        return `${applyNullable ? '@Nullable ' : ''}${typeToUse} ${name}`;
+    }
+    buildFieldsMarshaller(field) {
+        const isNonNull = field.type.kind === graphql_1.Kind.NON_NULL_TYPE;
+        const isArray = field.type.kind === graphql_1.Kind.LIST_TYPE ||
+            (field.type.kind === graphql_1.Kind.NON_NULL_TYPE && field.type.type.kind === graphql_1.Kind.LIST_TYPE);
+        const call = this.getFieldWriterCall(field, isArray);
+        const baseTypeNode = (0, visitor_plugin_common_1.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 = (0, visitor_plugin_common_1.indent)(`writer.${call};`);
+        }
+        if (isNonNull) {
+            return result;
+        }
+        return (0, visitor_plugin_common_1.indentMultiline)(`if(${field.name.value}.defined) {
+${(0, visitor_plugin_common_1.indentMultiline)(result)}
+}`);
+    }
+    buildMarshallerOverride(fields) {
+        this._imports.add(imports_js_1.Imports.Override);
+        this._imports.add(imports_js_1.Imports.IOException);
+        this._imports.add(imports_js_1.Imports.InputFieldWriter);
+        this._imports.add(imports_js_1.Imports.InputFieldMarshaller);
+        const allMarshallers = fields.map(field => (0, visitor_plugin_common_1.indentMultiline)(this.buildFieldsMarshaller(field), 2));
+        return (0, visitor_plugin_common_1.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 === graphql_1.Kind.LIST_TYPE ||
+                (field.type.kind === graphql_1.Kind.NON_NULL_TYPE && field.type.type.kind === graphql_1.Kind.LIST_TYPE);
+            const fieldType = this.getFieldWithTypePrefix(field, v => (!isArray ? `Input<${v}>` : `Input<List<${v}>>`));
+            const isNonNull = field.type.kind === graphql_1.Kind.NON_NULL_TYPE;
+            return `private ${fieldType}${isNonNull ? '' : ' = Input.absent()'};`;
+        })
+            .map(s => (0, visitor_plugin_common_1.indent)(s));
+        const setters = fields
+            .map(field => {
+            const isArray = field.type.kind === graphql_1.Kind.LIST_TYPE ||
+                (field.type.kind === graphql_1.Kind.NON_NULL_TYPE && field.type.type.kind === graphql_1.Kind.LIST_TYPE);
+            const fieldType = this.getFieldWithTypePrefix(field, isArray ? 'List' : null);
+            const isNonNull = field.type.kind === graphql_1.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 => (0, visitor_plugin_common_1.indentMultiline)(s));
+        const nonNullFields = fields
+            .filter(f => f.type.kind === graphql_1.Kind.NON_NULL_TYPE)
+            .map(nnField => {
+            this._imports.add(imports_js_1.Imports.Utils);
+            return (0, visitor_plugin_common_1.indent)(`Utils.checkNotNull(${nnField.name.value}, "${nnField.name.value} == null");`, 1);
+        });
+        const ctor = '\n' + (0, visitor_plugin_common_1.indent)(`${builderClassName}() {}`);
+        const buildFn = (0, visitor_plugin_common_1.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 (0, visitor_plugin_common_1.indentMultiline)(new java_common_1.JavaDeclarationBlock()
+            .withName(builderClassName)
+            .access('public')
+            .final()
+            .static()
+            .withBlock(body)
+            .asKind('class').string);
+    }
+    InputObjectTypeDefinition(node) {
+        const className = node.name.value;
+        this._imports.add(imports_js_1.Imports.InputType);
+        this._imports.add(imports_js_1.Imports.Generated);
+        const cls = new java_common_1.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;
+    }
+}
+exports.InputTypeVisitor = InputTypeVisitor;