@graphql-codegen/typescript-react-query 3.5.15 → 3.6.0-alpha-29eb1293b.0

package/cjs/config.js

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

package/cjs/fetcher-custom-mapper.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomMapperFetcher = void 0;
+const visitor_plugin_common_1 = require("@graphql-codegen/visitor-plugin-common");
+const variables_generator_js_1 = require("./variables-generator.js");
+class CustomMapperFetcher {
+    constructor(visitor, customFetcher) {
+        this.visitor = visitor;
+        if (typeof customFetcher === 'string') {
+            customFetcher = { func: customFetcher };
+        }
+        this._mapper = (0, visitor_plugin_common_1.parseMapper)(customFetcher.func);
+        this._isReactHook = customFetcher.isReactHook;
+    }
+    getFetcherFnName(operationResultType, operationVariablesTypes) {
+        return `${this._mapper.type}<${operationResultType}, ${operationVariablesTypes}>`;
+    }
+    generateFetcherImplementaion() {
+        if (this._mapper.isExternal) {
+            return (0, visitor_plugin_common_1.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>(
+      ${(0, variables_generator_js_1.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>(
+      ${(0, variables_generator_js_1.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>(
+      ${(0, variables_generator_js_1.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};`;
+    }
+}
+exports.CustomMapperFetcher = CustomMapperFetcher;

package/cjs/fetcher-fetch-hardcoded.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HardcodedFetchFetcher = void 0;
+const variables_generator_js_1 = require("./variables-generator.js");
+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 = (0, variables_generator_js_1.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>(
+      ${(0, variables_generator_js_1.generateInfiniteQueryKey)(node, hasRequiredVariables)},
+      (metaData) => fetcher<${operationResultType}, ${operationVariablesTypes}>(${documentVariableName}, {...variables, ...(metaData.pageParam ?? {})})(),
+      options
+    );`;
+    }
+    generateQueryHook(node, documentVariableName, operationName, operationResultType, operationVariablesTypes, hasRequiredVariables) {
+        const variables = (0, variables_generator_js_1.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>(
+      ${(0, variables_generator_js_1.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>(
+      ${(0, variables_generator_js_1.generateMutationKey)(node)},
+      (${variables}) => fetcher<${operationResultType}, ${operationVariablesTypes}>(${documentVariableName}, variables)(),
+      options
+    );`;
+    }
+    generateFetcherFetch(node, documentVariableName, operationName, operationResultType, operationVariablesTypes, hasRequiredVariables) {
+        const variables = (0, variables_generator_js_1.generateQueryVariablesSignature)(hasRequiredVariables, operationVariablesTypes);
+        return `\nuse${operationName}.fetcher = (${variables}) => fetcher<${operationResultType}, ${operationVariablesTypes}>(${documentVariableName}, variables);`;
+    }
+}
+exports.HardcodedFetchFetcher = HardcodedFetchFetcher;

package/cjs/fetcher-fetch.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FetchFetcher = void 0;
+const variables_generator_js_1 = require("./variables-generator.js");
+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 = (0, variables_generator_js_1.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>(
+      ${(0, variables_generator_js_1.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 = (0, variables_generator_js_1.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>(
+      ${(0, variables_generator_js_1.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>(
+      ${(0, variables_generator_js_1.generateMutationKey)(node)},
+      (${variables}) => fetcher<${operationResultType}, ${operationVariablesTypes}>(dataSource.endpoint, dataSource.fetchParams || {}, ${documentVariableName}, variables)(),
+      options
+    );`;
+    }
+    generateFetcherFetch(node, documentVariableName, operationName, operationResultType, operationVariablesTypes, hasRequiredVariables) {
+        const variables = (0, variables_generator_js_1.generateQueryVariablesSignature)(hasRequiredVariables, operationVariablesTypes);
+        return `\nuse${operationName}.fetcher = (dataSource: { endpoint: string, fetchParams?: RequestInit }, ${variables}) => fetcher<${operationResultType}, ${operationVariablesTypes}>(dataSource.endpoint, dataSource.fetchParams || {}, ${documentVariableName}, variables);`;
+    }
+}
+exports.FetchFetcher = FetchFetcher;

package/cjs/fetcher-graphql-request.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphQLRequestClientFetcher = void 0;
+const variables_generator_js_1 = require("./variables-generator.js");
+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 = (0, variables_generator_js_1.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>(
+      ${(0, variables_generator_js_1.generateInfiniteQueryKey)(node, hasRequiredVariables)},
+      (metaData) => fetcher<${operationResultType}, ${operationVariablesTypes}>(client, ${documentVariableName}, {...variables, ...(metaData.pageParam ?? {})}, headers)(),
+      options
+    );`;
+    }
+    generateQueryHook(node, documentVariableName, operationName, operationResultType, operationVariablesTypes, hasRequiredVariables) {
+        const variables = (0, variables_generator_js_1.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>(
+      ${(0, variables_generator_js_1.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>(
+      ${(0, variables_generator_js_1.generateMutationKey)(node)},
+      (${variables}) => fetcher<${operationResultType}, ${operationVariablesTypes}>(client, ${documentVariableName}, variables, headers)(),
+      options
+    );`;
+    }
+    generateFetcherFetch(node, documentVariableName, operationName, operationResultType, operationVariablesTypes, hasRequiredVariables) {
+        const variables = (0, variables_generator_js_1.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);`;
+    }
+}
+exports.GraphQLRequestClientFetcher = GraphQLRequestClientFetcher;

package/cjs/fetcher.js

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

package/cjs/index.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReactQueryVisitor = exports.validate = exports.plugin = void 0;
+const graphql_1 = require("graphql");
+const plugin_helpers_1 = require("@graphql-codegen/plugin-helpers");
+const visitor_js_1 = require("./visitor.js");
+Object.defineProperty(exports, "ReactQueryVisitor", { enumerable: true, get: function () { return visitor_js_1.ReactQueryVisitor; } });
+const path_1 = require("path");
+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 || []),
+    ];
+    const visitor = new visitor_js_1.ReactQueryVisitor(schema, allFragments, config, documents);
+    const visitorResult = (0, plugin_helpers_1.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'),
+    };
+};
+exports.plugin = plugin;
+const validate = async (schema, documents, config, outputFile) => {
+    if ((0, path_1.extname)(outputFile) !== '.ts' && (0, path_1.extname)(outputFile) !== '.tsx') {
+        throw new Error(`Plugin "typescript-react-query" requires extension to be ".ts" or ".tsx"!`);
+    }
+};
+exports.validate = validate;

package/cjs/package.json

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

package/cjs/variables-generator.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateMutationKeyMaker = exports.generateMutationKey = exports.generateQueryKeyMaker = exports.generateQueryKey = exports.generateInfiniteQueryKeyMaker = exports.generateInfiniteQueryKey = exports.generateQueryVariablesSignature = void 0;
+function generateQueryVariablesSignature(hasRequiredVariables, operationVariablesTypes) {
+    return `variables${hasRequiredVariables ? '' : '?'}: ${operationVariablesTypes}`;
+}
+exports.generateQueryVariablesSignature = generateQueryVariablesSignature;
+function generateInfiniteQueryKey(node, hasRequiredVariables) {
+    if (hasRequiredVariables)
+        return `['${node.name.value}.infinite', variables]`;
+    return `variables === undefined ? ['${node.name.value}.infinite'] : ['${node.name.value}.infinite', variables]`;
+}
+exports.generateInfiniteQueryKey = generateInfiniteQueryKey;
+function generateInfiniteQueryKeyMaker(node, operationName, operationVariablesTypes, hasRequiredVariables) {
+    const signature = generateQueryVariablesSignature(hasRequiredVariables, operationVariablesTypes);
+    return `\nuseInfinite${operationName}.getKey = (${signature}) => ${generateInfiniteQueryKey(node, hasRequiredVariables)};\n`;
+}
+exports.generateInfiniteQueryKeyMaker = generateInfiniteQueryKeyMaker;
+function generateQueryKey(node, hasRequiredVariables) {
+    if (hasRequiredVariables)
+        return `['${node.name.value}', variables]`;
+    return `variables === undefined ? ['${node.name.value}'] : ['${node.name.value}', variables]`;
+}
+exports.generateQueryKey = generateQueryKey;
+function generateQueryKeyMaker(node, operationName, operationVariablesTypes, hasRequiredVariables) {
+    const signature = generateQueryVariablesSignature(hasRequiredVariables, operationVariablesTypes);
+    return `\nuse${operationName}.getKey = (${signature}) => ${generateQueryKey(node, hasRequiredVariables)};\n`;
+}
+exports.generateQueryKeyMaker = generateQueryKeyMaker;
+function generateMutationKey(node) {
+    return `['${node.name.value}']`;
+}
+exports.generateMutationKey = generateMutationKey;
+function generateMutationKeyMaker(node, operationName) {
+    return `\nuse${operationName}.getKey = () => ${generateMutationKey(node)};\n`;
+}
+exports.generateMutationKeyMaker = generateMutationKeyMaker;

package/cjs/visitor.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReactQueryVisitor = void 0;
+const tslib_1 = require("tslib");
+const visitor_plugin_common_1 = require("@graphql-codegen/visitor-plugin-common");
+const variables_generator_js_1 = require("./variables-generator.js");
+const fetcher_custom_mapper_js_1 = require("./fetcher-custom-mapper.js");
+const fetcher_fetch_js_1 = require("./fetcher-fetch.js");
+const fetcher_graphql_request_js_1 = require("./fetcher-graphql-request.js");
+const fetcher_fetch_hardcoded_js_1 = require("./fetcher-fetch-hardcoded.js");
+const auto_bind_1 = tslib_1.__importDefault(require("auto-bind"));
+const change_case_all_1 = require("change-case-all");
+class ReactQueryVisitor extends visitor_plugin_common_1.ClientSideBaseVisitor {
+    constructor(schema, fragments, rawConfig, documents) {
+        super(schema, fragments, rawConfig, {
+            documentMode: visitor_plugin_common_1.DocumentMode.string,
+            errorType: (0, visitor_plugin_common_1.getConfigValue)(rawConfig.errorType, 'unknown'),
+            exposeDocument: (0, visitor_plugin_common_1.getConfigValue)(rawConfig.exposeDocument, false),
+            exposeQueryKeys: (0, visitor_plugin_common_1.getConfigValue)(rawConfig.exposeQueryKeys, false),
+            exposeMutationKeys: (0, visitor_plugin_common_1.getConfigValue)(rawConfig.exposeMutationKeys, false),
+            exposeFetcher: (0, visitor_plugin_common_1.getConfigValue)(rawConfig.exposeFetcher, false),
+            addInfiniteQuery: (0, visitor_plugin_common_1.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');
+        (0, auto_bind_1.default)(this);
+    }
+    get imports() {
+        return this._imports;
+    }
+    createFetcher(raw) {
+        if (raw === 'fetch') {
+            return new fetcher_fetch_js_1.FetchFetcher(this);
+        }
+        if (typeof raw === 'object' && 'endpoint' in raw) {
+            return new fetcher_fetch_hardcoded_js_1.HardcodedFetchFetcher(this, raw);
+        }
+        if (raw === 'graphql-request') {
+            return new fetcher_graphql_request_js_1.GraphQLRequestClientFetcher(this);
+        }
+        return new fetcher_custom_mapper_js_1.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 (0, change_case_all_1.pascalCase)(operationType);
+        }
+        if (name.includes('Query') || name.includes('Mutation') || name.includes('Subscription')) {
+            return '';
+        }
+        return (0, change_case_all_1.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${(0, variables_generator_js_1.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${(0, variables_generator_js_1.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 += (0, variables_generator_js_1.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;
+    }
+}
+exports.ReactQueryVisitor = ReactQueryVisitor;

package/esm/config.js

@@ -0,0 +1 @@
+export {};