@graphql-codegen/typescript-solid-query 1.0.0-alpha-20240201110240-bdef5b40fe364d6a5b0276786062c582bd60d3cc

package/esm/fetcher.js

@@ -0,0 +1,186 @@
+import autoBind from 'auto-bind';
+export class FetcherRenderer {
+    constructor(visitor) {
+        this.visitor = visitor;
+        autoBind(this);
+    }
+    createQueryMethodMap(isSuspense = false) {
+        const suspenseText = isSuspense ? 'Suspense' : '';
+        const queryMethodMap = {
+            infiniteQuery: {
+                getHook: (operationName = 'Query') => `create${suspenseText}Infinite${operationName}`,
+                getOptions: () => `Create${suspenseText}InfiniteQueryOptions`,
+                getOtherTypes: () => ({ infiniteData: 'InfiniteData' }),
+            },
+            query: {
+                getHook: (operationName = 'Query') => `create${suspenseText}${operationName}`,
+                getOptions: () => `Create${suspenseText}QueryOptions`,
+            },
+            mutation: {
+                getHook: (operationName = 'Mutation') => `create${operationName}`,
+                getOptions: () => `CreateMutationOptions`,
+            },
+        };
+        return queryMethodMap;
+    }
+    generateInfiniteQueryHelper(config, isSuspense) {
+        const { operationResultType, operationName } = config;
+        const { infiniteQuery } = this.createQueryMethodMap(isSuspense);
+        this.visitor.solidQueryHookIdentifiersInUse.add(infiniteQuery.getHook());
+        this.visitor.solidQueryOptionsIdentifiersInUse.add(infiniteQuery.getOptions());
+        this.visitor.solidQueryOptionsIdentifiersInUse.add(infiniteQuery.getOtherTypes().infiniteData);
+        const variables = this.generateInfiniteQueryVariablesSignature(config);
+        const options = this.generateInfiniteQueryOptionsSignature(config, isSuspense);
+        const generateBaseInfiniteQueryHook = (hookConfig) => {
+            const { implArguments, implHookOuter = '', implFetcher } = hookConfig;
+            const argumentsResult = implArguments !== null && implArguments !== void 0 ? implArguments : `
+      ${variables},
+      ${options}
+    `;
+            return `export const ${infiniteQuery.getHook(operationName)} = <
+      TData = ${`${infiniteQuery.getOtherTypes().infiniteData}<${operationResultType}>`},
+      TError = ${this.visitor.config.errorType}
+    >(${argumentsResult}) => {
+    ${implHookOuter}
+    return ${infiniteQuery.getHook()}<${operationResultType}, TError, TData>(
+      ${this.generateInfiniteQueryFormattedParameters(this.generateInfiniteQueryKey(config, isSuspense), implFetcher)}
+    )};`;
+        };
+        return { generateBaseInfiniteQueryHook, variables, options };
+    }
+    generateQueryHelper(config, isSuspense) {
+        const { operationName, operationResultType } = config;
+        const { query } = this.createQueryMethodMap(isSuspense);
+        this.visitor.solidQueryHookIdentifiersInUse.add(query.getHook());
+        this.visitor.solidQueryOptionsIdentifiersInUse.add(query.getOptions());
+        const variables = this.generateQueryVariablesSignature(config);
+        const options = this.generateQueryOptionsSignature(config, isSuspense);
+        const generateBaseQueryHook = (hookConfig) => {
+            const { implArguments, implHookOuter = '', implFetcher } = hookConfig;
+            const argumentsResult = implArguments !== null && implArguments !== void 0 ? implArguments : `
+      ${variables},
+      ${options}
+    `;
+            return `export const ${query.getHook(operationName)} = <
+      TData = ${operationResultType},
+      TError = ${this.visitor.config.errorType}
+    >(${argumentsResult}) => {
+    ${implHookOuter}
+    return ${query.getHook()}<${operationResultType}, TError, TData>(
+      ${this.generateQueryFormattedParameters(this.generateQueryKey(config, isSuspense), implFetcher)}
+    )};`;
+        };
+        return {
+            generateBaseQueryHook,
+            variables,
+            options,
+        };
+    }
+    generateMutationHelper(config) {
+        const { operationResultType, operationVariablesTypes, operationName } = config;
+        const { mutation } = this.createQueryMethodMap();
+        this.visitor.solidQueryHookIdentifiersInUse.add(mutation.getHook());
+        this.visitor.solidQueryOptionsIdentifiersInUse.add(mutation.getOptions());
+        const variables = `variables?: ${operationVariablesTypes}`;
+        const options = `options?: ${mutation.getOptions()}<${operationResultType}, TError, ${operationVariablesTypes}, TContext>`;
+        const generateBaseMutationHook = (hookConfig) => {
+            const { implArguments, implHookOuter = '', implFetcher } = hookConfig;
+            const argumentsResult = implArguments !== null && implArguments !== void 0 ? implArguments : `${options}`;
+            return `export const ${mutation.getHook(operationName)} = <
+      TError = ${this.visitor.config.errorType},
+      TContext = unknown
+    >(${argumentsResult}) => {
+    ${implHookOuter}
+    return ${mutation.getHook()}<${operationResultType}, TError, ${operationVariablesTypes}, TContext>(
+      ${this.generateMutationFormattedParameters(this.generateMutationKey(config), implFetcher)}
+    )};`;
+        };
+        return {
+            generateBaseMutationHook,
+            variables,
+            options,
+        };
+    }
+    generateQueryVariablesSignature({ hasRequiredVariables, operationVariablesTypes, }) {
+        return `variables${hasRequiredVariables ? '' : '?'}: ${operationVariablesTypes}`;
+    }
+    generateQueryOptionsSignature({ operationResultType }, isSuspense) {
+        const { query } = this.createQueryMethodMap(isSuspense);
+        return `options?: Omit<${query.getOptions()}<${operationResultType}, TError, TData>, 'queryKey'> & { queryKey?: ${query.getOptions()}<${operationResultType}, TError, TData>['queryKey'] }`;
+    }
+    generateInfiniteQueryVariablesSignature(config) {
+        return `variables: ${config.operationVariablesTypes}`;
+    }
+    generateInfiniteQueryOptionsSignature({ operationResultType }, isSuspense) {
+        const { infiniteQuery } = this.createQueryMethodMap(isSuspense);
+        return `options: Omit<${infiniteQuery.getOptions()}<${operationResultType}, TError, TData>, 'queryKey'> & { queryKey?: ${infiniteQuery.getOptions()}<${operationResultType}, TError, TData>['queryKey'] }`;
+    }
+    generateInfiniteQueryKey(config, isSuspense) {
+        const identifier = isSuspense ? 'infiniteSuspense' : 'infinite';
+        if (config.hasRequiredVariables)
+            return `['${config.node.name.value}.${identifier}', variables]`;
+        return `variables === undefined ? ['${config.node.name.value}.${identifier}'] : ['${config.node.name.value}.${identifier}', variables]`;
+    }
+    generateInfiniteQueryOutput(config, isSuspense = false) {
+        const { infiniteQuery } = this.createQueryMethodMap(isSuspense);
+        const signature = this.generateQueryVariablesSignature(config);
+        const { operationName, node } = config;
+        return {
+            hook: this.generateInfiniteQueryHook(config, isSuspense),
+            getKey: `${infiniteQuery.getHook(operationName)}.getKey = (${signature}) => ${this.generateInfiniteQueryKey(config, isSuspense)};`,
+            rootKey: `${infiniteQuery.getHook(operationName)}.rootKey = '${node.name.value}.infinite';`,
+        };
+    }
+    generateQueryKey(config, isSuspense) {
+        const identifier = isSuspense ? `${config.node.name.value}Suspense` : config.node.name.value;
+        if (config.hasRequiredVariables)
+            return `['${identifier}', variables]`;
+        return `variables === undefined ? ['${identifier}'] : ['${identifier}', variables]`;
+    }
+    generateQueryOutput(config, isSuspense = false) {
+        const { query } = this.createQueryMethodMap(isSuspense);
+        const signature = this.generateQueryVariablesSignature(config);
+        const { operationName, node, documentVariableName } = config;
+        return {
+            hook: this.generateQueryHook(config, isSuspense),
+            document: `${query.getHook(operationName)}.document = ${documentVariableName};`,
+            getKey: `${query.getHook(operationName)}.getKey = (${signature}) => ${this.generateQueryKey(config, isSuspense)};`,
+            rootKey: `${query.getHook(operationName)}.rootKey = '${node.name.value}';`,
+        };
+    }
+    generateMutationKey({ node }) {
+        return `['${node.name.value}']`;
+    }
+    generateMutationOutput(config) {
+        const { mutation } = this.createQueryMethodMap();
+        const { operationName } = config;
+        return {
+            hook: this.generateMutationHook(config),
+            getKey: `${mutation.getHook(operationName)}.getKey = () => ${this.generateMutationKey(config)};`,
+        };
+    }
+    generateInfiniteQueryFormattedParameters(queryKey, queryFn) {
+        return `(() => {
+    const { queryKey: optionsQueryKey, ...restOptions } = options;
+    return () => ({
+      queryKey: optionsQueryKey ?? ${queryKey},
+      queryFn: ${queryFn},
+      ...restOptions
+    }
+  }))()`;
+    }
+    generateQueryFormattedParameters(queryKey, queryFn) {
+        return `() => ({
+    queryKey: ${queryKey},
+    queryFn: ${queryFn},
+    ...options
+  })`;
+    }
+    generateMutationFormattedParameters(mutationKey, mutationFn) {
+        return `() => ({
+    mutationKey: ${mutationKey},
+    mutationFn: ${mutationFn},
+    ...options
+  })`;
+    }
+}

package/esm/index.js

@@ -0,0 +1,42 @@
+import { extname } from 'path';
+import { concatAST, Kind } from 'graphql';
+import { oldVisit } from '@graphql-codegen/plugin-helpers';
+import { SolidQueryVisitor } from './visitor.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 || []),
+    ];
+    const visitor = new SolidQueryVisitor(schema, allFragments, config, documents);
+    const visitorResult = 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'),
+    };
+};
+export const validate = async (schema, documents, config, outputFile) => {
+    if (extname(outputFile) !== '.ts' && extname(outputFile) !== '.tsx') {
+        throw new Error(`Plugin "typescript-solid-query" requires extension to be ".ts" or ".tsx"!`);
+    }
+};
+export { SolidQueryVisitor };

package/esm/visitor.js

@@ -0,0 +1,152 @@
+import autoBind from 'auto-bind';
+import { pascalCase } from 'change-case-all';
+import { ClientSideBaseVisitor, DocumentMode, getConfigValue, } from '@graphql-codegen/visitor-plugin-common';
+import { CustomMapperFetcher } from './fetcher-custom-mapper.js';
+import { HardcodedFetchFetcher } from './fetcher-fetch-hardcoded.js';
+import { FetchFetcher } from './fetcher-fetch.js';
+import { GraphQLRequestClientFetcher } from './fetcher-graphql-request.js';
+export class SolidQueryVisitor extends ClientSideBaseVisitor {
+    constructor(schema, fragments, rawConfig, documents) {
+        super(schema, fragments, rawConfig, {
+            documentMode: DocumentMode.string,
+            errorType: getConfigValue(rawConfig.errorType, 'unknown'),
+            exposeDocument: getConfigValue(rawConfig.exposeDocument, false),
+            exposeQueryKeys: getConfigValue(rawConfig.exposeQueryKeys, false),
+            exposeQueryRootKeys: getConfigValue(rawConfig.exposeQueryRootKeys, false),
+            exposeMutationKeys: getConfigValue(rawConfig.exposeMutationKeys, false),
+            exposeFetcher: getConfigValue(rawConfig.exposeFetcher, false),
+            addInfiniteQuery: getConfigValue(rawConfig.addInfiniteQuery, false),
+            addSuspenseQuery: getConfigValue(rawConfig.addSuspenseQuery, false),
+            solidQueryImportFrom: getConfigValue(rawConfig.solidQueryImportFrom, ''),
+        });
+        this.rawConfig = rawConfig;
+        this.solidQueryHookIdentifiersInUse = new Set();
+        this.solidQueryOptionsIdentifiersInUse = new Set();
+        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' || (typeof raw === 'object' && 'clientImportPath' in raw)) {
+            return new GraphQLRequestClientFetcher(this, raw);
+        }
+        return new CustomMapperFetcher(this, raw);
+    }
+    get hasOperations() {
+        return this._collectedOperations.length > 0;
+    }
+    getImports() {
+        const baseImports = super.getImports();
+        if (!this.hasOperations) {
+            return baseImports;
+        }
+        const hookAndTypeImports = [
+            ...Array.from(this.solidQueryHookIdentifiersInUse),
+            ...Array.from(this.solidQueryOptionsIdentifiersInUse).map(identifier => `${this.config.useTypeImports ? 'type ' : ''}${identifier}`),
+        ];
+        const moduleName = this.config.solidQueryImportFrom
+            ? this.config.solidQueryImportFrom
+            : '@tanstack/solid-query';
+        return [...baseImports, `import { ${hookAndTypeImports.join(', ')} } from '${moduleName}';`];
+    }
+    getFetcherImplementation() {
+        return this.fetcher.generateFetcherImplementation();
+    }
+    _getHookSuffix(name, operationType) {
+        if (this.config.omitOperationSuffix) {
+            return '';
+        }
+        if (!this.config.dedupeOperationSuffix) {
+            return pascalCase(operationType);
+        }
+        if (name.includes('Query') || name.includes('Mutation') || name.includes('Subscription')) {
+            return '';
+        }
+        return 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,
+        });
+        const generateConfig = {
+            node,
+            documentVariableName,
+            operationResultType,
+            operationVariablesTypes,
+            hasRequiredVariables,
+            operationName,
+        };
+        operationResultType = this._externalImportPrefix + operationResultType;
+        operationVariablesTypes = this._externalImportPrefix + operationVariablesTypes;
+        const queries = [];
+        const getOutputFromQueries = () => `\n${queries.join('\n\n')}\n`;
+        if (operationType === 'Query') {
+            const addQuery = (generateConfig, isSuspense = false) => {
+                const { hook, getKey, rootKey, document } = this.fetcher.generateQueryOutput(generateConfig, isSuspense);
+                queries.push(hook);
+                if (this.config.exposeDocument)
+                    queries.push(document);
+                if (this.config.exposeQueryKeys)
+                    queries.push(getKey);
+                if (this.config.exposeQueryRootKeys)
+                    queries.push(rootKey);
+            };
+            addQuery(generateConfig);
+            if (this.config.addSuspenseQuery)
+                addQuery(generateConfig, true);
+            if (this.config.addInfiniteQuery) {
+                const addInfiniteQuery = (generateConfig, isSuspense = false) => {
+                    const { hook, getKey, rootKey } = this.fetcher.generateInfiniteQueryOutput(generateConfig, isSuspense);
+                    queries.push(hook);
+                    if (this.config.exposeQueryKeys)
+                        queries.push(getKey);
+                    if (this.config.exposeQueryRootKeys)
+                        queries.push(rootKey);
+                };
+                addInfiniteQuery(generateConfig);
+                if (this.config.addSuspenseQuery) {
+                    addInfiniteQuery(generateConfig, true);
+                }
+            }
+            // The reason we're looking at the private field of the CustomMapperFetcher to see if it's a solid 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._isSolidHook) {
+                queries.push(this.fetcher.generateFetcherFetch(generateConfig));
+            }
+            return getOutputFromQueries();
+        }
+        if (operationType === 'Mutation') {
+            const { hook, getKey } = this.fetcher.generateMutationOutput(generateConfig);
+            queries.push(hook);
+            if (this.config.exposeMutationKeys)
+                queries.push(getKey);
+            if (this.config.exposeFetcher && !this.fetcher._isSolidHook) {
+                queries.push(this.fetcher.generateFetcherFetch(generateConfig));
+            }
+            return getOutputFromQueries();
+        }
+        if (operationType === 'Subscription') {
+            // eslint-disable-next-line no-console
+            console.warn(`Plugin "typescript-solid-query" does not support GraphQL Subscriptions at the moment! Ignoring "${node.name.value}"...`);
+        }
+        return null;
+    }
+}

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@graphql-codegen/typescript-solid-query",
+  "version": "1.0.0-alpha-20240201110240-bdef5b40fe364d6a5b0276786062c582bd60d3cc",
+  "description": "GraphQL Code Generator plugin for generating a ready-to-use Solid-Query Hooks based on GraphQL operations",
+  "peerDependencies": {
+    "graphql": "^0.8.0 || ^0.9.0 || ^0.10.0 || ^0.11.0 || ^0.12.0 || ^0.13.0 || ^14.0.0 || ^15.0.0 || ^16.0.0"
+  },
+  "dependencies": {
+    "@graphql-codegen/plugin-helpers": "^3.0.0",
+    "@graphql-codegen/visitor-plugin-common": "2.13.1",
+    "auto-bind": "~4.0.0",
+    "change-case-all": "1.0.15",
+    "tslib": "~2.6.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dotansimha/graphql-code-generator-community.git",
+    "directory": "packages/plugins/typescript/solid-query"
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">= 18.0.0"
+  },
+  "main": "cjs/index.js",
+  "module": "esm/index.js",
+  "typings": "typings/index.d.ts",
+  "typescript": {
+    "definition": "typings/index.d.ts"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "require": {
+        "types": "./typings/index.d.cts",
+        "default": "./cjs/index.js"
+      },
+      "import": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      },
+      "default": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      }
+    },
+    "./package.json": "./package.json"
+  }
+}

package/typings/config.d.cts

@@ -0,0 +1,115 @@
+import { RawClientSideBasePluginConfig } from '@graphql-codegen/visitor-plugin-common';
+export type HardcodedFetch = {
+    endpoint: string;
+    fetchParams?: string | Record<string, any>;
+};
+export type CustomFetch = {
+    func: string;
+    isSolidHook?: boolean;
+} | string;
+export type GraphQlRequest = 'graphql-request' | {
+    clientImportPath: string;
+};
+export interface BaseSolidQueryPluginConfig {
+    /**
+     * @default unknown
+     * @description Changes the default "TError" generic type.
+     */
+    errorType?: string;
+    /**
+     * @default false
+     * @description For each generate query hook adds `document` field with a
+     * corresponding GraphQL query. Useful for `queryClient.fetchQuery`.
+     * @exampleMarkdown
+     * ```ts
+     * queryClient.fetchQuery(
+     *   useUserDetailsQuery.getKey(variables),
+     *   () => gqlRequest(useUserDetailsQuery.document, variables)
+     * )
+     * ```
+     */
+    exposeDocument?: boolean;
+    /**
+     * @default false
+     * @description For each generate query hook adds getKey(variables: QueryVariables) function. Useful for cache updates. If addInfiniteQuery is true, it will also add a getKey function to each infinite query.
+     * @exampleMarkdown
+     * ```ts
+     * const query = useUserDetailsQuery(...)
+     * const key = useUserDetailsQuery.getKey({ id: theUsersId })
+     * // use key in a cache update after a mutation
+     * ```
+     */
+    exposeQueryKeys?: boolean;
+    /**
+     * @default false
+     * @description For each generate query hook adds rootKey. Useful for cache updates.
+     * @exampleMarkdown
+     * ```ts
+     * const query = useUserDetailsQuery(...)
+     * const key = useUserDetailsQuery.rootKey
+     * // use key in a cache update after a mutation
+     * ```
+     */
+    exposeQueryRootKeys?: boolean;
+    /**
+     * @default false
+     * @description For each generate mutation hook adds getKey() function. Useful for call outside of functional component.
+     * @exampleMarkdown
+     * ```ts
+     * const mutation = useUserDetailsMutation(...)
+     * const key = useUserDetailsMutation.getKey()
+     * ```
+     */
+    exposeMutationKeys?: boolean;
+    /**
+     * @default false
+     * @description For each generate query hook adds `fetcher` field with a corresponding GraphQL query using the fetcher.
+     * It is useful for `queryClient.fetchQuery` and `queryClient.prefetchQuery`.
+     * @exampleMarkdown
+     * ```ts
+     * await queryClient.prefetchQuery(userQuery.getKey(), () => userQuery.fetcher())
+     * ```
+     */
+    exposeFetcher?: boolean;
+    /**
+     * @default false
+     * @description Adds an Infinite Query along side the standard one
+     */
+    addInfiniteQuery?: boolean;
+    /**
+     * @default false
+     * @description Adds a Suspense Query along side the standard one
+     */
+    addSuspenseQuery?: boolean;
+    /**
+     * @default empty
+     * @description Add custom import for solid-query.
+     * It can be used to import from `@tanstack/solid-query` instead of `solid-query`. But make sure it include createQuery, CreateQueryOptions, createMutation, CreateMutationOptions, createInfiniteQuery, CreateInfiniteQueryOptions
+     *
+     * The following options are available to use:
+     *
+     * - "src/your-own-solid-query-customized": import { createQuery, CreateQueryOptions, createMutation, CreateMutationOptions, createInfiniteQuery, CreateInfiniteQueryOptions } from your own solid-query customized package.
+     */
+    solidQueryImportFrom?: string;
+}
+/**
+ * @description This plugin generates `Solid-Query` Hooks with TypeScript typings.
+ *
+ * It extends the basic TypeScript plugins: `@graphql-codegen/typescript`, `@graphql-codegen/typescript-operations` - and thus shares a similar configuration.
+ *
+ * > **If you are using the `solid-query` package instead of the `@tanstack/solid-query` package in your project, please set the `legacyMode` option to `true`.**
+ *
+ */
+export interface SolidQueryRawPluginConfig extends Omit<RawClientSideBasePluginConfig, 'documentMode' | 'noGraphQLTag' | 'gqlImport' | 'documentNodeImport' | 'noExport' | 'importOperationTypesFrom' | 'importDocumentNodeExternallyFrom' | 'useTypeImports' | 'legacyMode'>, BaseSolidQueryPluginConfig {
+    /**
+     * @description Customize the fetcher you wish to use in the generated file. Solid-Query is agnostic to the data-fetching layer, so you should provide it, or use a custom one.
+     *
+     * The following options are available to use:
+     *
+     * - 'fetch' - requires you to specify endpoint and headers on each call, and uses `fetch` to do the actual http call.
+     * - `{ endpoint: string, fetchParams: RequestInit }`: hardcode your endpoint and fetch options into the generated output, using the environment `fetch` method. You can also use `process.env.MY_VAR` as endpoint or header value.
+     * - `file#identifier` - You can use custom fetcher method that should implement the exported `SolidQueryFetcher` interface. Example: `./my-fetcher#myCustomFetcher`.
+     * - `graphql-request`: Will generate each hook with `client` argument, where you should pass your own `GraphQLClient` (created from `graphql-request`).
+     */
+    fetcher?: 'fetch' | HardcodedFetch | GraphQlRequest | CustomFetch;
+}

package/typings/config.d.ts

@@ -0,0 +1,115 @@
+import { RawClientSideBasePluginConfig } from '@graphql-codegen/visitor-plugin-common';
+export type HardcodedFetch = {
+    endpoint: string;
+    fetchParams?: string | Record<string, any>;
+};
+export type CustomFetch = {
+    func: string;
+    isSolidHook?: boolean;
+} | string;
+export type GraphQlRequest = 'graphql-request' | {
+    clientImportPath: string;
+};
+export interface BaseSolidQueryPluginConfig {
+    /**
+     * @default unknown
+     * @description Changes the default "TError" generic type.
+     */
+    errorType?: string;
+    /**
+     * @default false
+     * @description For each generate query hook adds `document` field with a
+     * corresponding GraphQL query. Useful for `queryClient.fetchQuery`.
+     * @exampleMarkdown
+     * ```ts
+     * queryClient.fetchQuery(
+     *   useUserDetailsQuery.getKey(variables),
+     *   () => gqlRequest(useUserDetailsQuery.document, variables)
+     * )
+     * ```
+     */
+    exposeDocument?: boolean;
+    /**
+     * @default false
+     * @description For each generate query hook adds getKey(variables: QueryVariables) function. Useful for cache updates. If addInfiniteQuery is true, it will also add a getKey function to each infinite query.
+     * @exampleMarkdown
+     * ```ts
+     * const query = useUserDetailsQuery(...)
+     * const key = useUserDetailsQuery.getKey({ id: theUsersId })
+     * // use key in a cache update after a mutation
+     * ```
+     */
+    exposeQueryKeys?: boolean;
+    /**
+     * @default false
+     * @description For each generate query hook adds rootKey. Useful for cache updates.
+     * @exampleMarkdown
+     * ```ts
+     * const query = useUserDetailsQuery(...)
+     * const key = useUserDetailsQuery.rootKey
+     * // use key in a cache update after a mutation
+     * ```
+     */
+    exposeQueryRootKeys?: boolean;
+    /**
+     * @default false
+     * @description For each generate mutation hook adds getKey() function. Useful for call outside of functional component.
+     * @exampleMarkdown
+     * ```ts
+     * const mutation = useUserDetailsMutation(...)
+     * const key = useUserDetailsMutation.getKey()
+     * ```
+     */
+    exposeMutationKeys?: boolean;
+    /**
+     * @default false
+     * @description For each generate query hook adds `fetcher` field with a corresponding GraphQL query using the fetcher.
+     * It is useful for `queryClient.fetchQuery` and `queryClient.prefetchQuery`.
+     * @exampleMarkdown
+     * ```ts
+     * await queryClient.prefetchQuery(userQuery.getKey(), () => userQuery.fetcher())
+     * ```
+     */
+    exposeFetcher?: boolean;
+    /**
+     * @default false
+     * @description Adds an Infinite Query along side the standard one
+     */
+    addInfiniteQuery?: boolean;
+    /**
+     * @default false
+     * @description Adds a Suspense Query along side the standard one
+     */
+    addSuspenseQuery?: boolean;
+    /**
+     * @default empty
+     * @description Add custom import for solid-query.
+     * It can be used to import from `@tanstack/solid-query` instead of `solid-query`. But make sure it include createQuery, CreateQueryOptions, createMutation, CreateMutationOptions, createInfiniteQuery, CreateInfiniteQueryOptions
+     *
+     * The following options are available to use:
+     *
+     * - "src/your-own-solid-query-customized": import { createQuery, CreateQueryOptions, createMutation, CreateMutationOptions, createInfiniteQuery, CreateInfiniteQueryOptions } from your own solid-query customized package.
+     */
+    solidQueryImportFrom?: string;
+}
+/**
+ * @description This plugin generates `Solid-Query` Hooks with TypeScript typings.
+ *
+ * It extends the basic TypeScript plugins: `@graphql-codegen/typescript`, `@graphql-codegen/typescript-operations` - and thus shares a similar configuration.
+ *
+ * > **If you are using the `solid-query` package instead of the `@tanstack/solid-query` package in your project, please set the `legacyMode` option to `true`.**
+ *
+ */
+export interface SolidQueryRawPluginConfig extends Omit<RawClientSideBasePluginConfig, 'documentMode' | 'noGraphQLTag' | 'gqlImport' | 'documentNodeImport' | 'noExport' | 'importOperationTypesFrom' | 'importDocumentNodeExternallyFrom' | 'useTypeImports' | 'legacyMode'>, BaseSolidQueryPluginConfig {
+    /**
+     * @description Customize the fetcher you wish to use in the generated file. Solid-Query is agnostic to the data-fetching layer, so you should provide it, or use a custom one.
+     *
+     * The following options are available to use:
+     *
+     * - 'fetch' - requires you to specify endpoint and headers on each call, and uses `fetch` to do the actual http call.
+     * - `{ endpoint: string, fetchParams: RequestInit }`: hardcode your endpoint and fetch options into the generated output, using the environment `fetch` method. You can also use `process.env.MY_VAR` as endpoint or header value.
+     * - `file#identifier` - You can use custom fetcher method that should implement the exported `SolidQueryFetcher` interface. Example: `./my-fetcher#myCustomFetcher`.
+     * - `graphql-request`: Will generate each hook with `client` argument, where you should pass your own `GraphQLClient` (created from `graphql-request`).
+     */
+    fetcher?: 'fetch' | HardcodedFetch | GraphQlRequest | CustomFetch;
+}

package/typings/fetcher-custom-mapper.d.cts

@@ -0,0 +1,15 @@
+import { CustomFetch } from './config.cjs';
+import { FetcherRenderer, type GenerateConfig } from './fetcher.cjs';
+import { SolidQueryVisitor } from './visitor.cjs';
+export declare class CustomMapperFetcher extends FetcherRenderer {
+    protected visitor: SolidQueryVisitor;
+    private _mapper;
+    private _isSolidHook;
+    constructor(visitor: SolidQueryVisitor, customFetcher: CustomFetch);
+    private getFetcherFnName;
+    generateFetcherImplementation(): string;
+    generateInfiniteQueryHook(config: GenerateConfig, isSuspense?: boolean): string;
+    generateQueryHook(config: GenerateConfig, isSuspense?: boolean): string;
+    generateMutationHook(config: GenerateConfig): string;
+    generateFetcherFetch(config: GenerateConfig): string;
+}