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

package/{index.mjs → esm/operation-visitor.js}

@@ -1,372 +1,14 @@
-import { getBaseType, oldVisit } from '@graphql-codegen/plugin-helpers';
-import { GraphQLObjectType, Kind, isNonNullType, isScalarType, isInputObjectType, isListType, isEnumType, print, isObjectType, isInterfaceType, isUnionType, GraphQLString, concatAST, visit } from 'graphql';
-import { BaseVisitor, buildScalars, getBaseTypeNode, indent, indentMultiline } from '@graphql-codegen/visitor-plugin-common';
-import { JAVA_SCALARS, JavaDeclarationBlock, buildPackageNameFromPath } from '@graphql-codegen/java-common';
+import { BaseJavaVisitor, SCALAR_TO_WRITER_METHOD } from './base-java-visitor.js';
+import { indent, indentMultiline, getBaseTypeNode } from '@graphql-codegen/visitor-plugin-common';
+import { buildPackageNameFromPath, JavaDeclarationBlock } from '@graphql-codegen/java-common';
+import { getBaseType } from '@graphql-codegen/plugin-helpers';
+import { print, Kind, isNonNullType, isScalarType, isEnumType, isUnionType, isInterfaceType, isObjectType, isInputObjectType, GraphQLString, isListType, } from 'graphql';
+import { Imports } from './imports.js';
 import { createHash } from 'crypto';
 import pluralize from 'pluralize';
+import { visitFieldArguments } from './field-arguments.js';
 import { camelCase, pascalCase } from 'change-case-all';
-import { join } from 'path';
-
-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',
-};
-
-const SCALAR_TO_WRITER_METHOD = {
-    ID: 'writeString',
-    String: 'writeString',
-    Int: 'writeInt',
-    Boolean: 'writeBoolean',
-    Float: 'writeDouble',
-};
-function isTypeNode(type) {
-    return type && !!type.kind;
-}
-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;
-    }
-}
-
-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;
-    }
-}
-
-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}"`,
-        },
-    });
-}
-
-class OperationVisitor extends BaseJavaVisitor {
+export class OperationVisitor extends BaseJavaVisitor {
     constructor(_schema, rawConfig, _availableFragments) {
         super(_schema, rawConfig, {
             package: rawConfig.package || buildPackageNameFromPath(process.cwd()),
@@ -1131,202 +773,3 @@ ${variables
         return cls;
     }
 }
-
-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 = {}));
-
-const filteredScalars = ['String', 'Float', 'Int', 'Boolean'];
-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;
-    }
-}
-
-const plugin = (schema, documents, config) => {
-    const allAst = concatAST(documents.map(v => v.document));
-    const allFragments = [
-        ...allAst.definitions.filter(d => d.kind === 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 FileType.FRAGMENT:
-        case FileType.OPERATION: {
-            visitor = new OperationVisitor(schema, config, allFragments);
-            break;
-        }
-        case FileType.INPUT_TYPE: {
-            visitor = new InputTypeVisitor(schema, config);
-            break;
-        }
-        case FileType.CUSTOM_TYPES: {
-            visitor = new CustomTypeClassVisitor(schema, config);
-            break;
-        }
-    }
-    if (!visitor) {
-        return { content: '' };
-    }
-    const visitResult = 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'),
-    };
-};
-
-const packageNameToDirectory = (packageName) => {
-    return `./${packageName.split('.').join('/')}/`;
-};
-const preset = {
-    buildGeneratesSection: options => {
-        const outDir = options.baseOutputDir;
-        const inputTypesAst = [];
-        visit(options.schema, {
-            InputObjectTypeDefinition: {
-                enter(node) {
-                    inputTypesAst.push(node);
-                },
-            },
-        });
-        const inputTypesDocumentNode = { kind: Kind.DOCUMENT, definitions: inputTypesAst };
-        const allAst = concatAST(options.documents.map(v => v.document));
-        const operationsAst = allAst.definitions.filter(d => d.kind === Kind.OPERATION_DEFINITION);
-        const fragments = allAst.definitions.filter(d => d.kind === 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: join(outDir, packageNameToDirectory(options.config.typePackage), 'CustomType.java'),
-                plugins: options.plugins,
-                pluginMap: options.pluginMap,
-                config: {
-                    ...options.config,
-                    fileType: FileType.CUSTOM_TYPES,
-                },
-                schema: options.schema,
-                documents: [],
-            },
-            ...inputTypesDocumentNode.definitions.map((ast) => {
-                const document = { kind: Kind.DOCUMENT, definitions: [ast] };
-                return {
-                    filename: join(outDir, packageNameToDirectory(options.config.typePackage), ast.name.value + '.java'),
-                    plugins: options.plugins,
-                    pluginMap: options.pluginMap,
-                    config: {
-                        ...options.config,
-                        fileType: 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}${pascalCase(ast.operation)}`;
-                const document = { kind: Kind.DOCUMENT, definitions: [ast] };
-                return {
-                    filename: join(outDir, packageNameToDirectory(options.config.package), fileName + '.java'),
-                    plugins: options.plugins,
-                    pluginMap: options.pluginMap,
-                    config: {
-                        ...options.config,
-                        fileType: FileType.OPERATION,
-                        externalFragments,
-                    },
-                    schema: options.schema,
-                    documents: [{ document, location: '' }],
-                };
-            }),
-            ...fragments.map((ast) => {
-                const document = { kind: Kind.DOCUMENT, definitions: [ast] };
-                return {
-                    filename: join(outDir, packageNameToDirectory(options.config.fragmentPackage), ast.name.value + '.java'),
-                    plugins: options.plugins,
-                    pluginMap: options.pluginMap,
-                    config: {
-                        ...options.config,
-                        fileType: FileType.FRAGMENT,
-                        externalFragments,
-                    },
-                    schema: options.schema,
-                    documents: [{ document, location: '' }],
-                };
-            }),
-        ];
-    },
-};
-
-export { plugin, preset };

package/esm/plugin.js

@@ -0,0 +1,44 @@
+import { oldVisit } from '@graphql-codegen/plugin-helpers';
+import { concatAST, Kind } from 'graphql';
+import { InputTypeVisitor } from './input-type-visitor.js';
+import { OperationVisitor } from './operation-visitor.js';
+import { FileType } from './file-type.js';
+import { CustomTypeClassVisitor } from './custom-type-class.js';
+export const plugin = (schema, documents, config) => {
+    const allAst = concatAST(documents.map(v => v.document));
+    const allFragments = [
+        ...allAst.definitions.filter(d => d.kind === 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 FileType.FRAGMENT:
+        case FileType.OPERATION: {
+            visitor = new OperationVisitor(schema, config, allFragments);
+            break;
+        }
+        case FileType.INPUT_TYPE: {
+            visitor = new InputTypeVisitor(schema, config);
+            break;
+        }
+        case FileType.CUSTOM_TYPES: {
+            visitor = new CustomTypeClassVisitor(schema, config);
+            break;
+        }
+    }
+    if (!visitor) {
+        return { content: '' };
+    }
+    const visitResult = 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'),
+    };
+};