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

package/cjs/fetcher-custom-mapper.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomMapperFetcher = void 0;
+const tslib_1 = require("tslib");
+const auto_bind_1 = tslib_1.__importDefault(require("auto-bind"));
+const visitor_plugin_common_1 = require("@graphql-codegen/visitor-plugin-common");
+const fetcher_js_1 = require("./fetcher.js");
+class CustomMapperFetcher extends fetcher_js_1.FetcherRenderer {
+    constructor(visitor, customFetcher) {
+        super(visitor);
+        this.visitor = visitor;
+        if (typeof customFetcher === 'string') {
+            customFetcher = { func: customFetcher };
+        }
+        this._mapper = (0, visitor_plugin_common_1.parseMapper)(customFetcher.func);
+        this._isSolidHook = customFetcher.isSolidHook;
+        (0, auto_bind_1.default)(this);
+    }
+    getFetcherFnName(operationResultType, operationVariablesTypes) {
+        return `${this._mapper.type}<${operationResultType}, ${operationVariablesTypes}>`;
+    }
+    generateFetcherImplementation() {
+        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(config, isSuspense = false) {
+        const { documentVariableName, operationResultType, operationVariablesTypes } = config;
+        const typedFetcher = this.getFetcherFnName(operationResultType, operationVariablesTypes);
+        const implHookOuter = this._isSolidHook
+            ? `const query = ${typedFetcher}(${documentVariableName})`
+            : '';
+        const implFetcher = this._isSolidHook
+            ? `(metaData) => query({...variables, ...(metaData.pageParam ?? {})})`
+            : `(metaData) => ${typedFetcher}(${documentVariableName}, {...variables, ...(metaData.pageParam ?? {})})()`;
+        const { generateBaseInfiniteQueryHook } = this.generateInfiniteQueryHelper(config, isSuspense);
+        return generateBaseInfiniteQueryHook({
+            implHookOuter,
+            implFetcher,
+        });
+    }
+    generateQueryHook(config, isSuspense = false) {
+        const { generateBaseQueryHook } = this.generateQueryHelper(config, isSuspense);
+        const { documentVariableName, operationResultType, operationVariablesTypes } = config;
+        const typedFetcher = this.getFetcherFnName(operationResultType, operationVariablesTypes);
+        const implFetcher = this._isSolidHook
+            ? `${typedFetcher}(${documentVariableName}).bind(null, variables)`
+            : `${typedFetcher}(${documentVariableName}, variables)`;
+        return generateBaseQueryHook({
+            implFetcher,
+        });
+    }
+    generateMutationHook(config) {
+        const { documentVariableName, operationResultType, operationVariablesTypes } = config;
+        const { generateBaseMutationHook, variables } = this.generateMutationHelper(config);
+        const typedFetcher = this.getFetcherFnName(operationResultType, operationVariablesTypes);
+        const implFetcher = this._isSolidHook
+            ? `${typedFetcher}(${documentVariableName})`
+            : `(${variables}) => ${typedFetcher}(${documentVariableName}, variables)()`;
+        return generateBaseMutationHook({
+            implFetcher,
+        });
+    }
+    generateFetcherFetch(config) {
+        const { documentVariableName, operationResultType, operationVariablesTypes, hasRequiredVariables, operationName, } = config;
+        // We can't generate a fetcher field since we can't call solid hooks outside of a Solid Fucntion Component
+        // Related: https://solidjs.org/docs/hooks-rules.html
+        if (this._isSolidHook)
+            return '';
+        const variables = `variables${hasRequiredVariables ? '' : '?'}: ${operationVariablesTypes}`;
+        const typedFetcher = this.getFetcherFnName(operationResultType, operationVariablesTypes);
+        const impl = `${typedFetcher}(${documentVariableName}, variables, options)`;
+        return `\ncreate${operationName}.fetcher = (${variables}, options?: RequestInit['headers']) => ${impl};`;
+    }
+}
+exports.CustomMapperFetcher = CustomMapperFetcher;

package/cjs/fetcher-fetch-hardcoded.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HardcodedFetchFetcher = void 0;
+const tslib_1 = require("tslib");
+const auto_bind_1 = tslib_1.__importDefault(require("auto-bind"));
+const fetcher_js_1 = require("./fetcher.js");
+class HardcodedFetchFetcher extends fetcher_js_1.FetcherRenderer {
+    constructor(visitor, config) {
+        super(visitor);
+        this.visitor = visitor;
+        this.config = config;
+        (0, auto_bind_1.default)(this);
+    }
+    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}`;
+    }
+    generateFetcherImplementation() {
+        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(config, isSuspense = false) {
+        const { generateBaseInfiniteQueryHook } = this.generateInfiniteQueryHelper(config, isSuspense);
+        const { documentVariableName, operationResultType, operationVariablesTypes } = config;
+        return generateBaseInfiniteQueryHook({
+            implFetcher: `(metaData) => fetcher<${operationResultType}, ${operationVariablesTypes}>(${documentVariableName}, {...variables, ...(metaData.pageParam ?? {})})()`,
+        });
+    }
+    generateQueryHook(config, isSuspense = false) {
+        const { generateBaseQueryHook } = this.generateQueryHelper(config, isSuspense);
+        const { documentVariableName, operationResultType, operationVariablesTypes } = config;
+        return generateBaseQueryHook({
+            implFetcher: `fetcher<${operationResultType}, ${operationVariablesTypes}>(${documentVariableName}, variables)`,
+        });
+    }
+    generateMutationHook(config) {
+        const { generateBaseMutationHook, variables } = this.generateMutationHelper(config);
+        const { documentVariableName, operationResultType, operationVariablesTypes } = config;
+        return generateBaseMutationHook({
+            implFetcher: `(${variables}) => fetcher<${operationResultType}, ${operationVariablesTypes}>(${documentVariableName}, variables)()`,
+        });
+    }
+    generateFetcherFetch(config) {
+        const { documentVariableName, operationResultType, operationVariablesTypes, operationName } = config;
+        const variables = this.generateQueryVariablesSignature(config);
+        return `\ncreate${operationName}.fetcher = (${variables}) => fetcher<${operationResultType}, ${operationVariablesTypes}>(${documentVariableName}, variables);`;
+    }
+}
+exports.HardcodedFetchFetcher = HardcodedFetchFetcher;

package/cjs/fetcher-fetch.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FetchFetcher = void 0;
+const tslib_1 = require("tslib");
+const auto_bind_1 = tslib_1.__importDefault(require("auto-bind"));
+const fetcher_js_1 = require("./fetcher.js");
+class FetchFetcher extends fetcher_js_1.FetcherRenderer {
+    constructor(visitor) {
+        super(visitor);
+        this.visitor = visitor;
+        (0, auto_bind_1.default)(this);
+    }
+    generateFetcherImplementation() {
+        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(config, isSuspense = false) {
+        const { generateBaseInfiniteQueryHook, variables, options } = this.generateInfiniteQueryHelper(config, isSuspense);
+        const { documentVariableName, operationResultType, operationVariablesTypes } = config;
+        return generateBaseInfiniteQueryHook({
+            implArguments: `
+      dataSource: { endpoint: string, fetchParams?: RequestInit },
+      ${variables},
+      ${options}
+    `,
+            implFetcher: `(metaData) => fetcher<${operationResultType}, ${operationVariablesTypes}>(dataSource.endpoint, dataSource.fetchParams || {}, ${documentVariableName}, {...variables, ...(metaData.pageParam ?? {})})()`,
+        });
+    }
+    generateQueryHook(config, isSuspense = false) {
+        const { generateBaseQueryHook, variables, options } = this.generateQueryHelper(config, isSuspense);
+        const { documentVariableName, operationResultType, operationVariablesTypes } = config;
+        return generateBaseQueryHook({
+            implArguments: `
+      dataSource: { endpoint: string, fetchParams?: RequestInit },
+      ${variables},
+      ${options}
+    `,
+            implFetcher: `fetcher<${operationResultType}, ${operationVariablesTypes}>(dataSource.endpoint, dataSource.fetchParams || {}, ${documentVariableName}, variables)`,
+        });
+    }
+    generateMutationHook(config) {
+        const { generateBaseMutationHook, variables, options } = this.generateMutationHelper(config);
+        const { documentVariableName, operationResultType, operationVariablesTypes } = config;
+        return generateBaseMutationHook({
+            implArguments: `
+      dataSource: { endpoint: string, fetchParams?: RequestInit },
+      ${options}
+    `,
+            implFetcher: `(${variables}) => fetcher<${operationResultType}, ${operationVariablesTypes}>(dataSource.endpoint, dataSource.fetchParams || {}, ${documentVariableName}, variables)()`,
+        });
+    }
+    generateFetcherFetch(config) {
+        const { documentVariableName, operationResultType, operationVariablesTypes, operationName } = config;
+        const variables = this.generateQueryVariablesSignature(config);
+        return `\ncreate${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,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphQLRequestClientFetcher = void 0;
+const tslib_1 = require("tslib");
+const auto_bind_1 = tslib_1.__importDefault(require("auto-bind"));
+const fetcher_js_1 = require("./fetcher.js");
+class GraphQLRequestClientFetcher extends fetcher_js_1.FetcherRenderer {
+    constructor(visitor, config) {
+        super(visitor);
+        this.visitor = visitor;
+        this.clientPath = typeof config === 'object' ? config.clientImportPath : null;
+        (0, auto_bind_1.default)(this);
+    }
+    generateFetcherImplementation() {
+        return this.clientPath
+            ? `
+function fetcher<TData, TVariables extends { [key: string]: any }>(query: string, variables?: TVariables, requestHeaders?: RequestInit['headers']) {
+  return async (): Promise<TData> => graphqlClient.request({
+    document: query,
+    variables,
+    requestHeaders
+  });
+}`
+            : `
+function fetcher<TData, TVariables extends { [key: string]: any }>(client: GraphQLClient, query: string, variables?: TVariables, requestHeaders?: RequestInit['headers']) {
+  return async (): Promise<TData> => client.request({
+    document: query,
+    variables,
+    requestHeaders
+  });
+}`;
+    }
+    generateInfiniteQueryHook(config, isSuspense = false) {
+        const typeImport = this.visitor.config.useTypeImports ? 'import type' : 'import';
+        if (this.clientPath)
+            this.visitor.imports.add(this.clientPath);
+        this.visitor.imports.add(`${typeImport} { GraphQLClient } from 'graphql-request';`);
+        const { generateBaseInfiniteQueryHook, variables, options } = this.generateInfiniteQueryHelper(config, isSuspense);
+        const { documentVariableName, operationResultType, operationVariablesTypes } = config;
+        return this.clientPath
+            ? generateBaseInfiniteQueryHook({
+                implArguments: `
+      pageParamKey: keyof ${operationVariablesTypes},
+      ${variables},
+      ${options},
+      headers?: RequestInit['headers']
+    `,
+                implFetcher: `(metaData) => fetcher<${operationResultType}, ${operationVariablesTypes}>(${documentVariableName}, {...variables, [pageParamKey]: metaData.pageParam}, headers)()`,
+            })
+            : generateBaseInfiniteQueryHook({
+                implArguments: `
+      client: GraphQLClient,
+      ${variables},
+      ${options},
+      headers?: RequestInit['headers']
+    `,
+                implFetcher: `(metaData) => fetcher<${operationResultType}, ${operationVariablesTypes}>(client, ${documentVariableName}, {...variables, ...(metaData.pageParam ?? {})}, headers)()`,
+            });
+    }
+    generateQueryHook(config, isSuspense = false) {
+        const typeImport = this.visitor.config.useTypeImports ? 'import type' : 'import';
+        if (this.clientPath)
+            this.visitor.imports.add(this.clientPath);
+        this.visitor.imports.add(`${typeImport} { GraphQLClient } from 'graphql-request';`);
+        this.visitor.imports.add(`${typeImport} { RequestInit } from 'graphql-request/dist/types.dom';`);
+        const { generateBaseQueryHook, variables, options } = this.generateQueryHelper(config, isSuspense);
+        const { documentVariableName, operationResultType, operationVariablesTypes } = config;
+        return this.clientPath
+            ? generateBaseQueryHook({
+                implArguments: `
+      ${variables},
+      ${options},
+      headers?: RequestInit['headers']
+    `,
+                implFetcher: `fetcher<${operationResultType}, ${operationVariablesTypes}>(${documentVariableName}, variables, headers)`,
+            })
+            : generateBaseQueryHook({
+                implArguments: `
+      client: GraphQLClient,
+      ${variables},
+      ${options},
+      headers?: RequestInit['headers']
+    `,
+                implFetcher: `fetcher<${operationResultType}, ${operationVariablesTypes}>(client, ${documentVariableName}, variables, headers)`,
+            });
+    }
+    generateMutationHook(config) {
+        const typeImport = this.visitor.config.useTypeImports ? 'import type' : 'import';
+        if (this.clientPath)
+            this.visitor.imports.add(this.clientPath);
+        this.visitor.imports.add(`${typeImport} { GraphQLClient } from 'graphql-request';`);
+        const { generateBaseMutationHook, variables, options } = this.generateMutationHelper(config);
+        const { documentVariableName, operationResultType, operationVariablesTypes } = config;
+        return this.clientPath
+            ? generateBaseMutationHook({
+                implArguments: `
+      ${options},
+      headers?: RequestInit['headers']
+    `,
+                implFetcher: `(${variables}) => fetcher<${operationResultType}, ${operationVariablesTypes}>(${documentVariableName}, variables, headers)()`,
+            })
+            : generateBaseMutationHook({
+                implArguments: `
+      client: GraphQLClient,
+      ${options},
+      headers?: RequestInit['headers']
+    `,
+                implFetcher: `(${variables}) => fetcher<${operationResultType}, ${operationVariablesTypes}>(client, ${documentVariableName}, variables, headers)()`,
+            });
+    }
+    generateFetcherFetch(config) {
+        const { documentVariableName, operationResultType, operationVariablesTypes, operationName } = config;
+        const variables = this.generateQueryVariablesSignature(config);
+        const typeImport = this.visitor.config.useTypeImports ? 'import type' : 'import';
+        if (this.clientPath)
+            this.visitor.imports.add(this.clientPath);
+        this.visitor.imports.add(`${typeImport} { RequestInit } from 'graphql-request/dist/types.dom';`);
+        return this.clientPath
+            ? `\ncreate${operationName}.fetcher = (${variables}, headers?: RequestInit['headers']) => fetcher<${operationResultType}, ${operationVariablesTypes}>(${documentVariableName}, variables, headers);`
+            : `\ncreate${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,191 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FetcherRenderer = void 0;
+const tslib_1 = require("tslib");
+const auto_bind_1 = tslib_1.__importDefault(require("auto-bind"));
+class FetcherRenderer {
+    constructor(visitor) {
+        this.visitor = visitor;
+        (0, auto_bind_1.default)(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
+  })`;
+    }
+}
+exports.FetcherRenderer = FetcherRenderer;

package/cjs/index.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SolidQueryVisitor = exports.validate = exports.plugin = void 0;
+const path_1 = require("path");
+const graphql_1 = require("graphql");
+const plugin_helpers_1 = require("@graphql-codegen/plugin-helpers");
+const visitor_js_1 = require("./visitor.js");
+Object.defineProperty(exports, "SolidQueryVisitor", { enumerable: true, get: function () { return visitor_js_1.SolidQueryVisitor; } });
+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.SolidQueryVisitor(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-solid-query" requires extension to be ".ts" or ".tsx"!`);
+    }
+};
+exports.validate = validate;

package/cjs/package.json

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