@graphql-codegen/typescript-react-query 3.5.14 → 3.6.0-alpha-2fbcdb6d3.0

package/{fetcher-custom-mapper.d.ts → typings/fetcher-custom-mapper.d.ts}

@@ -1,7 +1,7 @@
-import { CustomFetch } from './config';
-import { FetcherRenderer } from './fetcher';
+import { CustomFetch } from './config.js';
+import { FetcherRenderer } from './fetcher.js';
 import { OperationDefinitionNode } from 'graphql';
-import { ReactQueryVisitor } from './visitor';
+import { ReactQueryVisitor } from './visitor.js';
 export declare class CustomMapperFetcher implements FetcherRenderer {
     private visitor;
     private _mapper;

package/{fetcher-fetch-hardcoded.d.ts → typings/fetcher-fetch-hardcoded.d.ts}

@@ -1,7 +1,7 @@
-import { FetcherRenderer } from './fetcher';
-import { HardcodedFetch } from './config';
+import { FetcherRenderer } from './fetcher.js';
+import { HardcodedFetch } from './config.js';
 import { OperationDefinitionNode } from 'graphql';
-import { ReactQueryVisitor } from './visitor';
+import { ReactQueryVisitor } from './visitor.js';
 export declare class HardcodedFetchFetcher implements FetcherRenderer {
     private visitor;
     private config;

package/{fetcher-fetch.d.ts → typings/fetcher-fetch.d.ts}

@@ -1,6 +1,6 @@
-import { FetcherRenderer } from './fetcher';
+import { FetcherRenderer } from './fetcher.js';
 import { OperationDefinitionNode } from 'graphql';
-import { ReactQueryVisitor } from './visitor';
+import { ReactQueryVisitor } from './visitor.js';
 export declare class FetchFetcher implements FetcherRenderer {
     private visitor;
     constructor(visitor: ReactQueryVisitor);

package/{fetcher-graphql-request.d.ts → typings/fetcher-graphql-request.d.ts}

@@ -1,6 +1,6 @@
-import { FetcherRenderer } from './fetcher';
+import { FetcherRenderer } from './fetcher.js';
 import { OperationDefinitionNode } from 'graphql';
-import { ReactQueryVisitor } from './visitor';
+import { ReactQueryVisitor } from './visitor.js';
 export declare class GraphQLRequestClientFetcher implements FetcherRenderer {
     private visitor;
     constructor(visitor: ReactQueryVisitor);

package/{index.d.ts → typings/index.d.ts}

@@ -1,6 +1,6 @@
 import { PluginFunction, PluginValidateFn, Types } from '@graphql-codegen/plugin-helpers';
-import { ReactQueryRawPluginConfig } from './config';
-import { ReactQueryVisitor } from './visitor';
+import { ReactQueryRawPluginConfig } from './config.js';
+import { ReactQueryVisitor } from './visitor.js';
 export declare const plugin: PluginFunction<ReactQueryRawPluginConfig, Types.ComplexPluginOutput>;
 export declare const validate: PluginValidateFn<any>;
 export { ReactQueryVisitor };

package/{visitor.d.ts → typings/visitor.d.ts}

@@ -1,7 +1,7 @@
 import { ClientSideBasePluginConfig, ClientSideBaseVisitor, LoadedFragment } from '@graphql-codegen/visitor-plugin-common';
 import { GraphQLSchema, OperationDefinitionNode } from 'graphql';
-import { FetcherRenderer } from './fetcher';
-import { ReactQueryRawPluginConfig } from './config';
+import { FetcherRenderer } from './fetcher.js';
+import { ReactQueryRawPluginConfig } from './config.js';
 import { Types } from '@graphql-codegen/plugin-helpers';
 export interface ReactQueryPluginConfig extends ClientSideBasePluginConfig {
     errorType: string;

package/index.js

@@ -1,592 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
-
-const graphql = require('graphql');
-const pluginHelpers = require('@graphql-codegen/plugin-helpers');
-const visitorPluginCommon = require('@graphql-codegen/visitor-plugin-common');
-const autoBind = _interopDefault(require('auto-bind'));
-const changeCaseAll = require('change-case-all');
-const path = require('path');
-
-function generateQueryVariablesSignature(hasRequiredVariables, operationVariablesTypes) {
-    return `variables${hasRequiredVariables ? '' : '?'}: ${operationVariablesTypes}`;
-}
-function generateInfiniteQueryKey(node, hasRequiredVariables) {
-    if (hasRequiredVariables)
-        return `['${node.name.value}.infinite', variables]`;
-    return `variables === undefined ? ['${node.name.value}.infinite'] : ['${node.name.value}.infinite', variables]`;
-}
-function generateInfiniteQueryKeyMaker(node, operationName, operationVariablesTypes, hasRequiredVariables) {
-    const signature = generateQueryVariablesSignature(hasRequiredVariables, operationVariablesTypes);
-    return `\nuseInfinite${operationName}.getKey = (${signature}) => ${generateInfiniteQueryKey(node, hasRequiredVariables)};\n`;
-}
-function generateQueryKey(node, hasRequiredVariables) {
-    if (hasRequiredVariables)
-        return `['${node.name.value}', variables]`;
-    return `variables === undefined ? ['${node.name.value}'] : ['${node.name.value}', variables]`;
-}
-function generateQueryKeyMaker(node, operationName, operationVariablesTypes, hasRequiredVariables) {
-    const signature = generateQueryVariablesSignature(hasRequiredVariables, operationVariablesTypes);
-    return `\nuse${operationName}.getKey = (${signature}) => ${generateQueryKey(node, hasRequiredVariables)};\n`;
-}
-function generateMutationKey(node) {
-    return `['${node.name.value}']`;
-}
-function generateMutationKeyMaker(node, operationName) {
-    return `\nuse${operationName}.getKey = () => ${generateMutationKey(node)};\n`;
-}
-
-class CustomMapperFetcher {
-    constructor(visitor, customFetcher) {
-        this.visitor = visitor;
-        if (typeof customFetcher === 'string') {
-            customFetcher = { func: customFetcher };
-        }
-        this._mapper = visitorPluginCommon.parseMapper(customFetcher.func);
-        this._isReactHook = customFetcher.isReactHook;
-    }
-    getFetcherFnName(operationResultType, operationVariablesTypes) {
-        return `${this._mapper.type}<${operationResultType}, ${operationVariablesTypes}>`;
-    }
-    generateFetcherImplementaion() {
-        if (this._mapper.isExternal) {
-            return visitorPluginCommon.buildMapperImport(this._mapper.source, [
-                {
-                    identifier: this._mapper.type,
-                    asDefault: this._mapper.default,
-                },
-            ], this.visitor.config.useTypeImports);
-        }
-        return null;
-    }
-    generateInfiniteQueryHook(node, documentVariableName, operationName, operationResultType, operationVariablesTypes, hasRequiredVariables) {
-        const variables = `variables${hasRequiredVariables ? '' : '?'}: ${operationVariablesTypes}`;
-        const hookConfig = this.visitor.queryMethodMap;
-        this.visitor.reactQueryHookIdentifiersInUse.add(hookConfig.infiniteQuery.hook);
-        this.visitor.reactQueryOptionsIdentifiersInUse.add(hookConfig.infiniteQuery.options);
-        const options = `options?: ${hookConfig.infiniteQuery.options}<${operationResultType}, TError, TData>`;
-        const typedFetcher = this.getFetcherFnName(operationResultType, operationVariablesTypes);
-        const implHookOuter = this._isReactHook ? `const query = ${typedFetcher}(${documentVariableName})` : '';
-        const impl = this._isReactHook
-            ? `(metaData) => query({...variables, ...(metaData.pageParam ?? {})})`
-            : `(metaData) => ${typedFetcher}(${documentVariableName}, {...variables, ...(metaData.pageParam ?? {})})()`;
-        return `export const useInfinite${operationName} = <
-      TData = ${operationResultType},
-      TError = ${this.visitor.config.errorType}
-    >(
-      ${variables},
-      ${options}
-    ) =>{
-    ${implHookOuter}
-    return ${hookConfig.infiniteQuery.hook}<${operationResultType}, TError, TData>(
-      ${generateInfiniteQueryKey(node, hasRequiredVariables)},
-      ${impl},
-      options
-    )};`;
-    }
-    generateQueryHook(node, documentVariableName, operationName, operationResultType, operationVariablesTypes, hasRequiredVariables) {
-        const variables = `variables${hasRequiredVariables ? '' : '?'}: ${operationVariablesTypes}`;
-        const hookConfig = this.visitor.queryMethodMap;
-        this.visitor.reactQueryHookIdentifiersInUse.add(hookConfig.query.hook);
-        this.visitor.reactQueryOptionsIdentifiersInUse.add(hookConfig.query.options);
-        const options = `options?: ${hookConfig.query.options}<${operationResultType}, TError, TData>`;
-        const typedFetcher = this.getFetcherFnName(operationResultType, operationVariablesTypes);
-        const impl = this._isReactHook
-            ? `${typedFetcher}(${documentVariableName}).bind(null, variables)`
-            : `${typedFetcher}(${documentVariableName}, variables)`;
-        return `export const use${operationName} = <
-      TData = ${operationResultType},
-      TError = ${this.visitor.config.errorType}
-    >(
-      ${variables},
-      ${options}
-    ) =>
-    ${hookConfig.query.hook}<${operationResultType}, TError, TData>(
-      ${generateQueryKey(node, hasRequiredVariables)},
-      ${impl},
-      options
-    );`;
-    }
-    generateMutationHook(node, documentVariableName, operationName, operationResultType, operationVariablesTypes, hasRequiredVariables) {
-        const variables = `variables?: ${operationVariablesTypes}`;
-        const hookConfig = this.visitor.queryMethodMap;
-        this.visitor.reactQueryHookIdentifiersInUse.add(hookConfig.mutation.hook);
-        this.visitor.reactQueryOptionsIdentifiersInUse.add(hookConfig.mutation.options);
-        const options = `options?: ${hookConfig.mutation.options}<${operationResultType}, TError, ${operationVariablesTypes}, TContext>`;
-        const typedFetcher = this.getFetcherFnName(operationResultType, operationVariablesTypes);
-        const impl = this._isReactHook
-            ? `${typedFetcher}(${documentVariableName})`
-            : `(${variables}) => ${typedFetcher}(${documentVariableName}, variables)()`;
-        return `export const use${operationName} = <
-      TError = ${this.visitor.config.errorType},
-      TContext = unknown
-    >(${options}) =>
-    ${hookConfig.mutation.hook}<${operationResultType}, TError, ${operationVariablesTypes}, TContext>(
-      ${generateMutationKey(node)},
-      ${impl},
-      options
-    );`;
-    }
-    generateFetcherFetch(node, documentVariableName, operationName, operationResultType, operationVariablesTypes, hasRequiredVariables) {
-        // We can't generate a fetcher field since we can't call react hooks outside of a React Fucntion Component
-        // Related: https://reactjs.org/docs/hooks-rules.html
-        if (this._isReactHook)
-            return '';
-        const variables = `variables${hasRequiredVariables ? '' : '?'}: ${operationVariablesTypes}`;
-        const typedFetcher = this.getFetcherFnName(operationResultType, operationVariablesTypes);
-        const impl = `${typedFetcher}(${documentVariableName}, variables, options)`;
-        return `\nuse${operationName}.fetcher = (${variables}, options?: RequestInit['headers']) => ${impl};`;
-    }
-}
-
-class FetchFetcher {
-    constructor(visitor) {
-        this.visitor = visitor;
-    }
-    generateFetcherImplementaion() {
-        return `
-function fetcher<TData, TVariables>(endpoint: string, requestInit: RequestInit, query: string, variables?: TVariables) {
-  return async (): Promise<TData> => {
-    const res = await fetch(endpoint, {
-      method: 'POST',
-      ...requestInit,
-      body: JSON.stringify({ query, variables }),
-    });
-
-    const json = await res.json();
-
-    if (json.errors) {
-      const { message } = json.errors[0];
-
-      throw new Error(message);
-    }
-
-    return json.data;
-  }
-}`;
-    }
-    generateInfiniteQueryHook(node, documentVariableName, operationName, operationResultType, operationVariablesTypes, hasRequiredVariables) {
-        const variables = generateQueryVariablesSignature(hasRequiredVariables, operationVariablesTypes);
-        const hookConfig = this.visitor.queryMethodMap;
-        this.visitor.reactQueryHookIdentifiersInUse.add(hookConfig.infiniteQuery.hook);
-        this.visitor.reactQueryOptionsIdentifiersInUse.add(hookConfig.infiniteQuery.options);
-        const options = `options?: ${hookConfig.query.options}<${operationResultType}, TError, TData>`;
-        return `export const useInfinite${operationName} = <
-      TData = ${operationResultType},
-      TError = ${this.visitor.config.errorType}
-    >(
-      dataSource: { endpoint: string, fetchParams?: RequestInit },
-      pageParamKey: keyof ${operationVariablesTypes},
-      ${variables},
-      ${options}
-    ) =>
-    ${hookConfig.infiniteQuery.hook}<${operationResultType}, TError, TData>(
-      ${generateInfiniteQueryKey(node, hasRequiredVariables)},
-      (metaData) => fetcher<${operationResultType}, ${operationVariablesTypes}>(dataSource.endpoint, dataSource.fetchParams || {}, ${documentVariableName}, {...variables, ...(metaData.pageParam ?? {})})(),
-      options
-    );`;
-    }
-    generateQueryHook(node, documentVariableName, operationName, operationResultType, operationVariablesTypes, hasRequiredVariables) {
-        const variables = generateQueryVariablesSignature(hasRequiredVariables, operationVariablesTypes);
-        const hookConfig = this.visitor.queryMethodMap;
-        this.visitor.reactQueryHookIdentifiersInUse.add(hookConfig.query.hook);
-        this.visitor.reactQueryOptionsIdentifiersInUse.add(hookConfig.query.options);
-        const options = `options?: ${hookConfig.query.options}<${operationResultType}, TError, TData>`;
-        return `export const use${operationName} = <
-      TData = ${operationResultType},
-      TError = ${this.visitor.config.errorType}
-    >(
-      dataSource: { endpoint: string, fetchParams?: RequestInit },
-      ${variables},
-      ${options}
-    ) =>
-    ${hookConfig.query.hook}<${operationResultType}, TError, TData>(
-      ${generateQueryKey(node, hasRequiredVariables)},
-      fetcher<${operationResultType}, ${operationVariablesTypes}>(dataSource.endpoint, dataSource.fetchParams || {}, ${documentVariableName}, variables),
-      options
-    );`;
-    }
-    generateMutationHook(node, documentVariableName, operationName, operationResultType, operationVariablesTypes, hasRequiredVariables) {
-        const variables = `variables?: ${operationVariablesTypes}`;
-        const hookConfig = this.visitor.queryMethodMap;
-        this.visitor.reactQueryHookIdentifiersInUse.add(hookConfig.mutation.hook);
-        this.visitor.reactQueryOptionsIdentifiersInUse.add(hookConfig.mutation.options);
-        const options = `options?: ${hookConfig.mutation.options}<${operationResultType}, TError, ${operationVariablesTypes}, TContext>`;
-        return `export const use${operationName} = <
-      TError = ${this.visitor.config.errorType},
-      TContext = unknown
-    >(
-      dataSource: { endpoint: string, fetchParams?: RequestInit },
-      ${options}
-    ) =>
-    ${hookConfig.mutation.hook}<${operationResultType}, TError, ${operationVariablesTypes}, TContext>(
-      ${generateMutationKey(node)},
-      (${variables}) => fetcher<${operationResultType}, ${operationVariablesTypes}>(dataSource.endpoint, dataSource.fetchParams || {}, ${documentVariableName}, variables)(),
-      options
-    );`;
-    }
-    generateFetcherFetch(node, documentVariableName, operationName, operationResultType, operationVariablesTypes, hasRequiredVariables) {
-        const variables = generateQueryVariablesSignature(hasRequiredVariables, operationVariablesTypes);
-        return `\nuse${operationName}.fetcher = (dataSource: { endpoint: string, fetchParams?: RequestInit }, ${variables}) => fetcher<${operationResultType}, ${operationVariablesTypes}>(dataSource.endpoint, dataSource.fetchParams || {}, ${documentVariableName}, variables);`;
-    }
-}
-
-class GraphQLRequestClientFetcher {
-    constructor(visitor) {
-        this.visitor = visitor;
-    }
-    generateFetcherImplementaion() {
-        return `
-function fetcher<TData, TVariables>(client: GraphQLClient, query: string, variables?: TVariables, headers?: RequestInit['headers']) {
-  return async (): Promise<TData> => client.request<TData, TVariables>(query, variables, headers);
-}`;
-    }
-    generateInfiniteQueryHook(node, documentVariableName, operationName, operationResultType, operationVariablesTypes, hasRequiredVariables) {
-        const variables = generateQueryVariablesSignature(hasRequiredVariables, operationVariablesTypes);
-        const typeImport = this.visitor.config.useTypeImports ? 'import type' : 'import';
-        this.visitor.imports.add(`${typeImport} { GraphQLClient } from 'graphql-request';`);
-        const hookConfig = this.visitor.queryMethodMap;
-        this.visitor.reactQueryHookIdentifiersInUse.add(hookConfig.infiniteQuery.hook);
-        this.visitor.reactQueryOptionsIdentifiersInUse.add(hookConfig.infiniteQuery.options);
-        const options = `options?: ${hookConfig.infiniteQuery.options}<${operationResultType}, TError, TData>`;
-        return `export const useInfinite${operationName} = <
-      TData = ${operationResultType},
-      TError = ${this.visitor.config.errorType}
-    >(
-      pageParamKey: keyof ${operationVariablesTypes},
-      client: GraphQLClient,
-      ${variables},
-      ${options},
-      headers?: RequestInit['headers']
-    ) =>
-    ${hookConfig.infiniteQuery.hook}<${operationResultType}, TError, TData>(
-      ${generateInfiniteQueryKey(node, hasRequiredVariables)},
-      (metaData) => fetcher<${operationResultType}, ${operationVariablesTypes}>(client, ${documentVariableName}, {...variables, ...(metaData.pageParam ?? {})}, headers)(),
-      options
-    );`;
-    }
-    generateQueryHook(node, documentVariableName, operationName, operationResultType, operationVariablesTypes, hasRequiredVariables) {
-        const variables = generateQueryVariablesSignature(hasRequiredVariables, operationVariablesTypes);
-        const typeImport = this.visitor.config.useTypeImports ? 'import type' : 'import';
-        this.visitor.imports.add(`${typeImport} { GraphQLClient } from 'graphql-request';`);
-        this.visitor.imports.add(`${typeImport} { RequestInit } from 'graphql-request/dist/types.dom';`);
-        const hookConfig = this.visitor.queryMethodMap;
-        this.visitor.reactQueryHookIdentifiersInUse.add(hookConfig.query.hook);
-        this.visitor.reactQueryOptionsIdentifiersInUse.add(hookConfig.query.options);
-        const options = `options?: ${hookConfig.query.options}<${operationResultType}, TError, TData>`;
-        return `export const use${operationName} = <
-      TData = ${operationResultType},
-      TError = ${this.visitor.config.errorType}
-    >(
-      client: GraphQLClient,
-      ${variables},
-      ${options},
-      headers?: RequestInit['headers']
-    ) =>
-    ${hookConfig.query.hook}<${operationResultType}, TError, TData>(
-      ${generateQueryKey(node, hasRequiredVariables)},
-      fetcher<${operationResultType}, ${operationVariablesTypes}>(client, ${documentVariableName}, variables, headers),
-      options
-    );`;
-    }
-    generateMutationHook(node, documentVariableName, operationName, operationResultType, operationVariablesTypes, hasRequiredVariables) {
-        const variables = `variables?: ${operationVariablesTypes}`;
-        const typeImport = this.visitor.config.useTypeImports ? 'import type' : 'import';
-        this.visitor.imports.add(`${typeImport} { GraphQLClient } from 'graphql-request';`);
-        const hookConfig = this.visitor.queryMethodMap;
-        this.visitor.reactQueryHookIdentifiersInUse.add(hookConfig.mutation.hook);
-        this.visitor.reactQueryOptionsIdentifiersInUse.add(hookConfig.mutation.options);
-        const options = `options?: ${hookConfig.mutation.options}<${operationResultType}, TError, ${operationVariablesTypes}, TContext>`;
-        return `export const use${operationName} = <
-      TError = ${this.visitor.config.errorType},
-      TContext = unknown
-    >(
-      client: GraphQLClient,
-      ${options},
-      headers?: RequestInit['headers']
-    ) =>
-    ${hookConfig.mutation.hook}<${operationResultType}, TError, ${operationVariablesTypes}, TContext>(
-      ${generateMutationKey(node)},
-      (${variables}) => fetcher<${operationResultType}, ${operationVariablesTypes}>(client, ${documentVariableName}, variables, headers)(),
-      options
-    );`;
-    }
-    generateFetcherFetch(node, documentVariableName, operationName, operationResultType, operationVariablesTypes, hasRequiredVariables) {
-        const variables = generateQueryVariablesSignature(hasRequiredVariables, operationVariablesTypes);
-        const typeImport = this.visitor.config.useTypeImports ? 'import type' : 'import';
-        this.visitor.imports.add(`${typeImport} { RequestInit } from 'graphql-request/dist/types.dom';`);
-        return `\nuse${operationName}.fetcher = (client: GraphQLClient, ${variables}, headers?: RequestInit['headers']) => fetcher<${operationResultType}, ${operationVariablesTypes}>(client, ${documentVariableName}, variables, headers);`;
-    }
-}
-
-class HardcodedFetchFetcher {
-    constructor(visitor, config) {
-        this.visitor = visitor;
-        this.config = config;
-    }
-    getEndpoint() {
-        try {
-            new URL(this.config.endpoint);
-            return JSON.stringify(this.config.endpoint);
-        }
-        catch (e) {
-            return `${this.config.endpoint} as string`;
-        }
-    }
-    getFetchParams() {
-        let fetchParamsPartial = '';
-        if (this.config.fetchParams) {
-            const fetchParamsString = typeof this.config.fetchParams === 'string' ? this.config.fetchParams : JSON.stringify(this.config.fetchParams);
-            fetchParamsPartial = `\n    ...(${fetchParamsString}),`;
-        }
-        return `    method: "POST",${fetchParamsPartial}`;
-    }
-    generateFetcherImplementaion() {
-        return `
-function fetcher<TData, TVariables>(query: string, variables?: TVariables) {
-  return async (): Promise<TData> => {
-    const res = await fetch(${this.getEndpoint()}, {
-${this.getFetchParams()}
-      body: JSON.stringify({ query, variables }),
-    });
-
-    const json = await res.json();
-
-    if (json.errors) {
-      const { message } = json.errors[0];
-
-      throw new Error(message);
-    }
-
-    return json.data;
-  }
-}`;
-    }
-    generateInfiniteQueryHook(node, documentVariableName, operationName, operationResultType, operationVariablesTypes, hasRequiredVariables) {
-        const variables = generateQueryVariablesSignature(hasRequiredVariables, operationVariablesTypes);
-        const hookConfig = this.visitor.queryMethodMap;
-        this.visitor.reactQueryHookIdentifiersInUse.add(hookConfig.infiniteQuery.hook);
-        this.visitor.reactQueryOptionsIdentifiersInUse.add(hookConfig.infiniteQuery.options);
-        const options = `options?: ${hookConfig.infiniteQuery.options}<${operationResultType}, TError, TData>`;
-        return `export const useInfinite${operationName} = <
-      TData = ${operationResultType},
-      TError = ${this.visitor.config.errorType}
-    >(
-      pageParamKey: keyof ${operationVariablesTypes},
-      ${variables},
-      ${options}
-    ) =>
-    ${hookConfig.infiniteQuery.hook}<${operationResultType}, TError, TData>(
-      ${generateInfiniteQueryKey(node, hasRequiredVariables)},
-      (metaData) => fetcher<${operationResultType}, ${operationVariablesTypes}>(${documentVariableName}, {...variables, ...(metaData.pageParam ?? {})})(),
-      options
-    );`;
-    }
-    generateQueryHook(node, documentVariableName, operationName, operationResultType, operationVariablesTypes, hasRequiredVariables) {
-        const variables = generateQueryVariablesSignature(hasRequiredVariables, operationVariablesTypes);
-        const hookConfig = this.visitor.queryMethodMap;
-        this.visitor.reactQueryHookIdentifiersInUse.add(hookConfig.query.hook);
-        this.visitor.reactQueryOptionsIdentifiersInUse.add(hookConfig.query.options);
-        const options = `options?: ${hookConfig.query.options}<${operationResultType}, TError, TData>`;
-        return `export const use${operationName} = <
-      TData = ${operationResultType},
-      TError = ${this.visitor.config.errorType}
-    >(
-      ${variables},
-      ${options}
-    ) =>
-    ${hookConfig.query.hook}<${operationResultType}, TError, TData>(
-      ${generateQueryKey(node, hasRequiredVariables)},
-      fetcher<${operationResultType}, ${operationVariablesTypes}>(${documentVariableName}, variables),
-      options
-    );`;
-    }
-    generateMutationHook(node, documentVariableName, operationName, operationResultType, operationVariablesTypes, hasRequiredVariables) {
-        const variables = `variables?: ${operationVariablesTypes}`;
-        const hookConfig = this.visitor.queryMethodMap;
-        this.visitor.reactQueryHookIdentifiersInUse.add(hookConfig.mutation.hook);
-        this.visitor.reactQueryOptionsIdentifiersInUse.add(hookConfig.mutation.options);
-        const options = `options?: ${hookConfig.mutation.options}<${operationResultType}, TError, ${operationVariablesTypes}, TContext>`;
-        return `export const use${operationName} = <
-      TError = ${this.visitor.config.errorType},
-      TContext = unknown
-    >(${options}) =>
-    ${hookConfig.mutation.hook}<${operationResultType}, TError, ${operationVariablesTypes}, TContext>(
-      ${generateMutationKey(node)},
-      (${variables}) => fetcher<${operationResultType}, ${operationVariablesTypes}>(${documentVariableName}, variables)(),
-      options
-    );`;
-    }
-    generateFetcherFetch(node, documentVariableName, operationName, operationResultType, operationVariablesTypes, hasRequiredVariables) {
-        const variables = generateQueryVariablesSignature(hasRequiredVariables, operationVariablesTypes);
-        return `\nuse${operationName}.fetcher = (${variables}) => fetcher<${operationResultType}, ${operationVariablesTypes}>(${documentVariableName}, variables);`;
-    }
-}
-
-class ReactQueryVisitor extends visitorPluginCommon.ClientSideBaseVisitor {
-    constructor(schema, fragments, rawConfig, documents) {
-        super(schema, fragments, rawConfig, {
-            documentMode: visitorPluginCommon.DocumentMode.string,
-            errorType: visitorPluginCommon.getConfigValue(rawConfig.errorType, 'unknown'),
-            exposeDocument: visitorPluginCommon.getConfigValue(rawConfig.exposeDocument, false),
-            exposeQueryKeys: visitorPluginCommon.getConfigValue(rawConfig.exposeQueryKeys, false),
-            exposeMutationKeys: visitorPluginCommon.getConfigValue(rawConfig.exposeMutationKeys, false),
-            exposeFetcher: visitorPluginCommon.getConfigValue(rawConfig.exposeFetcher, false),
-            addInfiniteQuery: visitorPluginCommon.getConfigValue(rawConfig.addInfiniteQuery, false),
-        });
-        this.rawConfig = rawConfig;
-        this.reactQueryHookIdentifiersInUse = new Set();
-        this.reactQueryOptionsIdentifiersInUse = new Set();
-        this.queryMethodMap = {
-            infiniteQuery: {
-                hook: 'useInfiniteQuery',
-                options: 'UseInfiniteQueryOptions',
-            },
-            query: {
-                hook: 'useQuery',
-                options: 'UseQueryOptions',
-            },
-            mutation: {
-                hook: 'useMutation',
-                options: 'UseMutationOptions',
-            },
-        };
-        this._externalImportPrefix = this.config.importOperationTypesFrom ? `${this.config.importOperationTypesFrom}.` : '';
-        this._documents = documents;
-        this.fetcher = this.createFetcher(rawConfig.fetcher || 'fetch');
-        autoBind(this);
-    }
-    get imports() {
-        return this._imports;
-    }
-    createFetcher(raw) {
-        if (raw === 'fetch') {
-            return new FetchFetcher(this);
-        }
-        if (typeof raw === 'object' && 'endpoint' in raw) {
-            return new HardcodedFetchFetcher(this, raw);
-        }
-        if (raw === 'graphql-request') {
-            return new GraphQLRequestClientFetcher(this);
-        }
-        return new CustomMapperFetcher(this, raw);
-    }
-    get hasOperations() {
-        return this._collectedOperations.length > 0;
-    }
-    getImports() {
-        const baseImports = super.getImports();
-        if (!this.hasOperations) {
-            return baseImports;
-        }
-        if (this.config.addInfiniteQuery) {
-            this.reactQueryOptionsIdentifiersInUse.add('QueryFunctionContext');
-        }
-        const hookAndTypeImports = [
-            ...Array.from(this.reactQueryHookIdentifiersInUse),
-            ...Array.from(this.reactQueryOptionsIdentifiersInUse).map(identifier => `${this.config.useTypeImports ? 'type ' : ''}${identifier}`),
-        ];
-        return [...baseImports, `import { ${hookAndTypeImports.join(', ')} } from 'react-query';`];
-    }
-    getFetcherImplementation() {
-        return this.fetcher.generateFetcherImplementaion();
-    }
-    _getHookSuffix(name, operationType) {
-        if (this.config.omitOperationSuffix) {
-            return '';
-        }
-        if (!this.config.dedupeOperationSuffix) {
-            return changeCaseAll.pascalCase(operationType);
-        }
-        if (name.includes('Query') || name.includes('Mutation') || name.includes('Subscription')) {
-            return '';
-        }
-        return changeCaseAll.pascalCase(operationType);
-    }
-    buildOperation(node, documentVariableName, operationType, operationResultType, operationVariablesTypes, hasRequiredVariables) {
-        var _a, _b;
-        const nodeName = (_b = (_a = node.name) === null || _a === void 0 ? void 0 : _a.value) !== null && _b !== void 0 ? _b : '';
-        const suffix = this._getHookSuffix(nodeName, operationType);
-        const operationName = this.convertName(nodeName, {
-            suffix,
-            useTypesPrefix: false,
-            useTypesSuffix: false,
-        });
-        operationResultType = this._externalImportPrefix + operationResultType;
-        operationVariablesTypes = this._externalImportPrefix + operationVariablesTypes;
-        if (operationType === 'Query') {
-            let query = this.fetcher.generateQueryHook(node, documentVariableName, operationName, operationResultType, operationVariablesTypes, hasRequiredVariables);
-            if (this.config.exposeDocument) {
-                query += `\nuse${operationName}.document = ${documentVariableName};\n`;
-            }
-            if (this.config.exposeQueryKeys) {
-                query += `\n${generateQueryKeyMaker(node, operationName, operationVariablesTypes, hasRequiredVariables)};\n`;
-            }
-            if (this.config.addInfiniteQuery) {
-                query += `\n${this.fetcher.generateInfiniteQueryHook(node, documentVariableName, operationName, operationResultType, operationVariablesTypes, hasRequiredVariables)}\n`;
-                if (this.config.exposeQueryKeys) {
-                    query += `\n${generateInfiniteQueryKeyMaker(node, operationName, operationVariablesTypes, hasRequiredVariables)};\n`;
-                }
-            }
-            // The reason we're looking at the private field of the CustomMapperFetcher to see if it's a react hook
-            // is to prevent calling generateFetcherFetch for each query since all the queries won't be able to generate
-            // a fetcher field anyways.
-            if (this.config.exposeFetcher && !this.fetcher._isReactHook) {
-                query += this.fetcher.generateFetcherFetch(node, documentVariableName, operationName, operationResultType, operationVariablesTypes, hasRequiredVariables);
-            }
-            return query;
-        }
-        if (operationType === 'Mutation') {
-            let query = this.fetcher.generateMutationHook(node, documentVariableName, operationName, operationResultType, operationVariablesTypes, hasRequiredVariables);
-            if (this.config.exposeMutationKeys) {
-                query += generateMutationKeyMaker(node, operationName);
-            }
-            if (this.config.exposeFetcher && !this.fetcher._isReactHook) {
-                query += this.fetcher.generateFetcherFetch(node, documentVariableName, operationName, operationResultType, operationVariablesTypes, hasRequiredVariables);
-            }
-            return query;
-        }
-        if (operationType === 'Subscription') {
-            // eslint-disable-next-line no-console
-            console.warn(`Plugin "typescript-react-query" does not support GraphQL Subscriptions at the moment! Ignoring "${node.name.value}"...`);
-        }
-        return null;
-    }
-}
-
-const plugin = (schema, documents, config) => {
-    const allAst = graphql.concatAST(documents.map(v => v.document));
-    const allFragments = [
-        ...allAst.definitions.filter(d => d.kind === graphql.Kind.FRAGMENT_DEFINITION).map(fragmentDef => ({
-            node: fragmentDef,
-            name: fragmentDef.name.value,
-            onType: fragmentDef.typeCondition.name.value,
-            isExternal: false,
-        })),
-        ...(config.externalFragments || []),
-    ];
-    const visitor = new ReactQueryVisitor(schema, allFragments, config, documents);
-    const visitorResult = pluginHelpers.oldVisit(allAst, { leave: visitor });
-    if (visitor.hasOperations) {
-        return {
-            prepend: [...visitor.getImports(), visitor.getFetcherImplementation()],
-            content: [visitor.fragments, ...visitorResult.definitions.filter(t => typeof t === 'string')].join('\n'),
-        };
-    }
-    return {
-        prepend: [...visitor.getImports()],
-        content: [visitor.fragments, ...visitorResult.definitions.filter(t => typeof t === 'string')].join('\n'),
-    };
-};
-const validate = async (schema, documents, config, outputFile) => {
-    if (path.extname(outputFile) !== '.ts' && path.extname(outputFile) !== '.tsx') {
-        throw new Error(`Plugin "typescript-react-query" requires extension to be ".ts" or ".tsx"!`);
-    }
-};
-
-exports.ReactQueryVisitor = ReactQueryVisitor;
-exports.plugin = plugin;
-exports.validate = validate;