@kubb/plugin-react-query 3.0.0-beta.11 → 3.0.0-beta.12

package/src/generators/__snapshots__/findInfiniteByTagsCursor.ts

@@ -1,7 +1,7 @@
 import client from "@kubb/plugin-client/client";
 import type { RequestConfig } from "@kubb/plugin-client/client";
 import type { QueryKey, InfiniteQueryObserverOptions, UseInfiniteQueryResult } from "@tanstack/react-query";
-import { useInfiniteQuery, infiniteQueryOptions } from "@tanstack/react-query";
+import { infiniteQueryOptions, useInfiniteQuery } from "@tanstack/react-query";
 
  export const findPetsByTagsInfiniteQueryKey = (params?: FindPetsByTagsQueryParams) => [{ url: "/pet/findByTags" }, ...(params ? [params] : [])] as const;
 

package/src/generators/__snapshots__/postAsQuery.ts

@@ -1,7 +1,7 @@
 import client from "@kubb/plugin-client/client";
 import type { RequestConfig } from "@kubb/plugin-client/client";
 import type { QueryKey, QueryObserverOptions, UseQueryResult } from "custom-query";
-import { useQuery, queryOptions } from "custom-query";
+import { queryOptions, useQuery } from "custom-query";
 
  export const updatePetWithFormQueryKey = (petId: UpdatePetWithFormPathParams["petId"], data?: UpdatePetWithFormMutationRequest, params?: UpdatePetWithFormQueryParams) => [{ url: "/pet/:petId", params: { petId: petId } }, ...(params ? [params] : []), ...(data ? [data] : [])] as const;
 

package/src/generators/infiniteQueryGenerator.tsx

@@ -20,6 +20,8 @@ export const infiniteQueryGenerator = createReactGenerator<PluginReactQuery>({
     const isQuery = typeof options.query === 'boolean' ? options.query : !!options.query.methods?.some((method) => operation.method === method)
     const isInfinite = isQuery && !!options.infinite
 
+    const importPath = options.query ? options.query.importPath : '@tanstack/react-query'
+
     const query = {
       name: getName(operation, { type: 'function', prefix: 'use', suffix: 'infinite' }),
       typeName: getName(operation, { type: 'type' }),
@@ -50,15 +52,13 @@ export const infiniteQueryGenerator = createReactGenerator<PluginReactQuery>({
       schemas: getSchemas(operation, { pluginKey: [pluginZodName], type: 'function' }),
     }
 
-    if (!isQuery || !isInfinite || typeof options.query === 'boolean' || typeof options.infinite === 'boolean') {
+    if (!isQuery || !isInfinite) {
       return null
     }
 
     return (
       <File baseName={query.file.baseName} path={query.file.path} meta={query.file.meta} banner={output?.banner} footer={output?.footer}>
         {options.parser === 'zod' && <File.Import name={[zod.schemas.response.name]} root={query.file.path} path={zod.file.path} />}
-        <File.Import name={['useInfiniteQuery', 'infiniteQueryOptions']} path={options.query.importPath} />
-        <File.Import name={['QueryKey', 'WithRequired', 'InfiniteQueryObserverOptions', 'UseInfiniteQueryResult']} path={options.query.importPath} isTypeOnly />
         <File.Import name={'client'} path={options.client.importPath} />
         <File.Import name={['RequestConfig']} path={options.client.importPath} isTypeOnly />
         {options.client.dataReturnType === 'full' && <File.Import name={['ResponseConfig']} path={options.client.importPath} isTypeOnly />}
@@ -75,14 +75,13 @@ export const infiniteQueryGenerator = createReactGenerator<PluginReactQuery>({
           path={type.file.path}
           isTypeOnly
         />
-
         <QueryKey
           name={queryKey.name}
           typeName={queryKey.typeName}
           operation={operation}
           pathParamsType={options.pathParamsType}
           typeSchemas={type.schemas}
-          keysFn={options.query.key}
+          transformer={options.queryKey}
         />
         <Client
           name={client.name}
@@ -97,29 +96,40 @@ export const infiniteQueryGenerator = createReactGenerator<PluginReactQuery>({
           pathParamsType={options.pathParamsType}
           parser={options.parser}
         />
-        <InfiniteQueryOptions
-          name={queryOptions.name}
-          clientName={client.name}
-          queryKeyName={queryKey.name}
-          typeSchemas={type.schemas}
-          paramsType={options.paramsType}
-          pathParamsType={options.pathParamsType}
-          dataReturnType={options.client.dataReturnType}
-          cursorParam={options.infinite.cursorParam}
-          initialPageParam={options.infinite.initialPageParam}
-          queryParam={options.infinite.queryParam}
-        />
-        <InfiniteQuery
-          name={query.name}
-          queryOptionsName={queryOptions.name}
-          typeSchemas={type.schemas}
-          paramsType={options.paramsType}
-          pathParamsType={options.pathParamsType}
-          operation={operation}
-          dataReturnType={options.client.dataReturnType}
-          queryKeyName={queryKey.name}
-          queryKeyTypeName={queryKey.typeName}
-        />
+        {options.infinite && (
+          <>
+            <File.Import name={['infiniteQueryOptions']} path={importPath} />
+            <InfiniteQueryOptions
+              name={queryOptions.name}
+              clientName={client.name}
+              queryKeyName={queryKey.name}
+              typeSchemas={type.schemas}
+              paramsType={options.paramsType}
+              pathParamsType={options.pathParamsType}
+              dataReturnType={options.client.dataReturnType}
+              cursorParam={options.infinite.cursorParam}
+              initialPageParam={options.infinite.initialPageParam}
+              queryParam={options.infinite.queryParam}
+            />
+          </>
+        )}
+        {options.infinite && (
+          <>
+            <File.Import name={['useInfiniteQuery']} path={importPath} />
+            <File.Import name={['QueryKey', 'InfiniteQueryObserverOptions', 'UseInfiniteQueryResult']} path={importPath} isTypeOnly />
+            <InfiniteQuery
+              name={query.name}
+              queryOptionsName={queryOptions.name}
+              typeSchemas={type.schemas}
+              paramsType={options.paramsType}
+              pathParamsType={options.pathParamsType}
+              operation={operation}
+              dataReturnType={options.client.dataReturnType}
+              queryKeyName={queryKey.name}
+              queryKeyTypeName={queryKey.typeName}
+            />
+          </>
+        )}
       </File>
     )
   },

package/src/generators/mutationGenerator.tsx

@@ -21,6 +21,8 @@ export const mutationGenerator = createReactGenerator<PluginReactQuery>({
     const isQuery = typeof options.query === 'boolean' ? true : options.query?.methods.some((method) => operation.method === method)
     const isMutation = !isQuery && options.mutation && options.mutation.methods.some((method) => operation.method === method)
 
+    const importPath = options.mutation ? options.mutation.importPath : '@tanstack/react-query'
+
     const mutation = {
       name: getName(operation, { type: 'function', prefix: 'use' }),
       typeName: getName(operation, { type: 'type' }),
@@ -47,15 +49,13 @@ export const mutationGenerator = createReactGenerator<PluginReactQuery>({
       typeName: getName(operation, { type: 'type', suffix: 'MutationKey' }),
     }
 
-    if (!isMutation || typeof options.mutation === 'boolean') {
+    if (!isMutation) {
       return null
     }
 
     return (
       <File baseName={mutation.file.baseName} path={mutation.file.path} meta={mutation.file.meta} banner={output?.banner} footer={output?.footer}>
         {options.parser === 'zod' && <File.Import name={[zod.schemas.response.name]} root={mutation.file.path} path={zod.file.path} />}
-        <File.Import name={['useMutation']} path={options.mutation.importPath} />
-        <File.Import name={['UseMutationOptions']} path={options.mutation.importPath} isTypeOnly />
         <File.Import name={'client'} path={options.client.importPath} />
         <File.Import name={['RequestConfig', 'ResponseConfig']} path={options.client.importPath} isTypeOnly />
         <File.Import
@@ -71,14 +71,16 @@ export const mutationGenerator = createReactGenerator<PluginReactQuery>({
           path={type.file.path}
           isTypeOnly
         />
+
         <MutationKey
           name={mutationKey.name}
           typeName={mutationKey.typeName}
           operation={operation}
           pathParamsType={options.pathParamsType}
           typeSchemas={type.schemas}
-          keysFn={options.mutation.key}
+          transformer={options.mutationKey}
         />
+
         <Client
           name={client.name}
           isExportable={false}
@@ -92,17 +94,23 @@ export const mutationGenerator = createReactGenerator<PluginReactQuery>({
           pathParamsType={options.pathParamsType}
           parser={options.parser}
         />
-        <Mutation
-          name={mutation.name}
-          clientName={client.name}
-          typeName={mutation.typeName}
-          typeSchemas={type.schemas}
-          operation={operation}
-          dataReturnType={options.client.dataReturnType}
-          paramsType={options.paramsType}
-          pathParamsType={options.pathParamsType}
-          mutationKeyName={mutationKey.name}
-        />
+        {options.mutation && (
+          <>
+            <File.Import name={['useMutation']} path={importPath} />
+            <File.Import name={['UseMutationOptions']} path={importPath} isTypeOnly />
+            <Mutation
+              name={mutation.name}
+              clientName={client.name}
+              typeName={mutation.typeName}
+              typeSchemas={type.schemas}
+              operation={operation}
+              dataReturnType={options.client.dataReturnType}
+              paramsType={options.paramsType}
+              pathParamsType={options.pathParamsType}
+              mutationKeyName={mutationKey.name}
+            />
+          </>
+        )}
       </File>
     )
   },

package/src/generators/queryGenerator.tsx

@@ -19,7 +19,7 @@ export const queryGenerator = createReactGenerator<PluginReactQuery>({
     const { getSchemas, getName, getFile } = useOperationManager()
 
     const isQuery = typeof options.query === 'boolean' ? true : options.query?.methods.some((method) => operation.method === method)
-    const isMutation = !isQuery && options.mutation && options.mutation.methods.some((method) => operation.method === method)
+    const importPath = options.query ? options.query.importPath : '@tanstack/react-query'
 
     const query = {
       name: getName(operation, { type: 'function', prefix: 'use' }),
@@ -51,15 +51,13 @@ export const queryGenerator = createReactGenerator<PluginReactQuery>({
       schemas: getSchemas(operation, { pluginKey: [pluginZodName], type: 'function' }),
     }
 
-    if (!isQuery || typeof options.query === 'boolean') {
+    if (!isQuery) {
       return null
     }
 
     return (
       <File baseName={query.file.baseName} path={query.file.path} meta={query.file.meta} banner={output?.banner} footer={output?.footer}>
         {options.parser === 'zod' && <File.Import name={[zod.schemas.response.name]} root={query.file.path} path={zod.file.path} />}
-        <File.Import name={['useQuery', 'queryOptions']} path={options.query.importPath} />
-        <File.Import name={['QueryKey', 'WithRequired', 'QueryObserverOptions', 'UseQueryResult']} path={options.query.importPath} isTypeOnly />
         <File.Import name={'client'} path={options.client.importPath} />
         <File.Import name={['RequestConfig']} path={options.client.importPath} isTypeOnly />
         {options.client.dataReturnType === 'full' && <File.Import name={['ResponseConfig']} path={options.client.importPath} isTypeOnly />}
@@ -76,14 +74,13 @@ export const queryGenerator = createReactGenerator<PluginReactQuery>({
           path={type.file.path}
           isTypeOnly
         />
-
         <QueryKey
           name={queryKey.name}
           typeName={queryKey.typeName}
           operation={operation}
           pathParamsType={options.pathParamsType}
           typeSchemas={type.schemas}
-          keysFn={options.query.key}
+          transformer={options.queryKey}
         />
         <Client
           name={client.name}
@@ -98,6 +95,7 @@ export const queryGenerator = createReactGenerator<PluginReactQuery>({
           pathParamsType={options.pathParamsType}
           parser={options.parser}
         />
+        <File.Import name={['queryOptions']} path={importPath} />
         <QueryOptions
           name={queryOptions.name}
           clientName={client.name}
@@ -106,17 +104,23 @@ export const queryGenerator = createReactGenerator<PluginReactQuery>({
           paramsType={options.paramsType}
           pathParamsType={options.pathParamsType}
         />
-        <Query
-          name={query.name}
-          queryOptionsName={queryOptions.name}
-          typeSchemas={type.schemas}
-          paramsType={options.paramsType}
-          pathParamsType={options.pathParamsType}
-          operation={operation}
-          dataReturnType={options.client.dataReturnType}
-          queryKeyName={queryKey.name}
-          queryKeyTypeName={queryKey.typeName}
-        />
+        {options.query && (
+          <>
+            <File.Import name={['useQuery']} path={importPath} />
+            <File.Import name={['QueryKey', 'QueryObserverOptions', 'UseQueryResult']} path={importPath} isTypeOnly />
+            <Query
+              name={query.name}
+              queryOptionsName={queryOptions.name}
+              typeSchemas={type.schemas}
+              paramsType={options.paramsType}
+              pathParamsType={options.pathParamsType}
+              operation={operation}
+              dataReturnType={options.client.dataReturnType}
+              queryKeyName={queryKey.name}
+              queryKeyTypeName={queryKey.typeName}
+            />
+          </>
+        )}
       </File>
     )
   },

package/src/generators/suspenseQueryGenerator.tsx

@@ -21,6 +21,8 @@ export const suspenseQueryGenerator = createReactGenerator<PluginReactQuery>({
     const isQuery = typeof options.query === 'boolean' ? options.query : !!options.query.methods?.some((method) => operation.method === method)
     const isSuspense = isQuery && !!options.suspense
 
+    const importPath = options.query ? options.query.importPath : '@tanstack/react-query'
+
     const query = {
       name: getName(operation, { type: 'function', prefix: 'use', suffix: 'suspense' }),
       typeName: getName(operation, { type: 'type' }),
@@ -51,15 +53,13 @@ export const suspenseQueryGenerator = createReactGenerator<PluginReactQuery>({
       schemas: getSchemas(operation, { pluginKey: [pluginZodName], type: 'function' }),
     }
 
-    if (!isQuery || !isSuspense || typeof options.query === 'boolean') {
+    if (!isQuery || !isSuspense) {
       return null
     }
 
     return (
       <File baseName={query.file.baseName} path={query.file.path} meta={query.file.meta} banner={output?.banner} footer={output?.footer}>
         {options.parser === 'zod' && <File.Import name={[zod.schemas.response.name]} root={query.file.path} path={zod.file.path} />}
-        <File.Import name={['useSuspenseQuery', 'queryOptions']} path={options.query.importPath} />
-        <File.Import name={['QueryKey', 'WithRequired', 'UseSuspenseQueryOptions', 'UseSuspenseQueryResult']} path={options.query.importPath} isTypeOnly />
         <File.Import name={'client'} path={options.client.importPath} />
         <File.Import name={['RequestConfig']} path={options.client.importPath} isTypeOnly />
         {options.client.dataReturnType === 'full' && <File.Import name={['ResponseConfig']} path={options.client.importPath} isTypeOnly />}
@@ -76,15 +76,15 @@ export const suspenseQueryGenerator = createReactGenerator<PluginReactQuery>({
           path={type.file.path}
           isTypeOnly
         />
-
         <QueryKey
           name={queryKey.name}
           typeName={queryKey.typeName}
           operation={operation}
           pathParamsType={options.pathParamsType}
           typeSchemas={type.schemas}
-          keysFn={options.query.key}
+          transformer={options.queryKey}
         />
+
         <Client
           name={client.name}
           isExportable={false}
@@ -98,6 +98,7 @@ export const suspenseQueryGenerator = createReactGenerator<PluginReactQuery>({
           pathParamsType={options.pathParamsType}
           parser={options.parser}
         />
+        <File.Import name={['queryOptions']} path={importPath} />
         <QueryOptions
           name={queryOptions.name}
           clientName={client.name}
@@ -106,17 +107,23 @@ export const suspenseQueryGenerator = createReactGenerator<PluginReactQuery>({
           paramsType={options.paramsType}
           pathParamsType={options.pathParamsType}
         />
-        <SuspenseQuery
-          name={query.name}
-          queryOptionsName={queryOptions.name}
-          typeSchemas={type.schemas}
-          paramsType={options.paramsType}
-          pathParamsType={options.pathParamsType}
-          operation={operation}
-          dataReturnType={options.client.dataReturnType}
-          queryKeyName={queryKey.name}
-          queryKeyTypeName={queryKey.typeName}
-        />
+        {options.suspense && (
+          <>
+            <File.Import name={['useSuspenseQuery']} path={importPath} />
+            <File.Import name={['QueryKey', 'UseSuspenseQueryOptions', 'UseSuspenseQueryResult']} path={importPath} isTypeOnly />
+            <SuspenseQuery
+              name={query.name}
+              queryOptionsName={queryOptions.name}
+              typeSchemas={type.schemas}
+              paramsType={options.paramsType}
+              pathParamsType={options.pathParamsType}
+              operation={operation}
+              dataReturnType={options.client.dataReturnType}
+              queryKeyName={queryKey.name}
+              queryKeyTypeName={queryKey.typeName}
+            />
+          </>
+        )}
       </File>
     )
   },

package/src/plugin.ts

@@ -9,6 +9,8 @@ import { pluginZodName } from '@kubb/plugin-zod'
 
 import type { Plugin } from '@kubb/core'
 import type { PluginOas } from '@kubb/plugin-oas'
+import { MutationKey } from './components'
+import { QueryKey } from './components/QueryKey.tsx'
 import { infiniteQueryGenerator, mutationGenerator, queryGenerator, suspenseQueryGenerator } from './generators'
 import type { PluginReactQuery } from './types.ts'
 
@@ -30,6 +32,8 @@ export const pluginReactQuery = createPlugin<PluginReactQuery>((options) => {
     generators = [queryGenerator, suspenseQueryGenerator, infiniteQueryGenerator, mutationGenerator].filter(Boolean),
     mutation = {},
     query = {},
+    mutationKey = MutationKey.getTransformer,
+    queryKey = QueryKey.getTransformer,
   } = options
 
   return {
@@ -50,14 +54,14 @@ export const pluginReactQuery = createPlugin<PluginReactQuery>((options) => {
           }
         : false,
       suspense,
+      queryKey,
       query: {
-        key: (key: unknown[]) => key,
         methods: ['get'],
         importPath: '@tanstack/react-query',
         ...query,
       },
+      mutationKey,
       mutation: {
-        key: (key: unknown[]) => key,
         methods: ['post', 'put', 'patch', 'delete'],
         importPath: '@tanstack/react-query',
         ...mutation,

package/src/types.ts

@@ -1,16 +1,29 @@
 import type { Group, Output, PluginFactoryOptions, ResolveNameParams } from '@kubb/core'
 
-import type { HttpMethod } from '@kubb/oas'
+import type { HttpMethod, Operation } from '@kubb/oas'
 import type { PluginClient } from '@kubb/plugin-client'
-import type { Exclude, Generator, Include, Override, ResolvePathOptions } from '@kubb/plugin-oas'
+import type { Exclude, Generator, Include, OperationSchemas, Override, ResolvePathOptions } from '@kubb/plugin-oas'
+
+type TransformerProps = {
+  operation: Operation
+  schemas: OperationSchemas
+}
+
+export type Transformer = (props: TransformerProps) => unknown[]
 
 type Suspense = object
 
+/**
+ * Customize the queryKey
+ */
+type QueryKey = Transformer
+
+/**
+ * Customize the mutationKey
+ */
+type MutationKey = Transformer
+
 type Query = {
-  /**
-   * Customize the queryKey, here you can specify a suffix.
-   */
-  key: (key: unknown[]) => unknown[]
   /**
    * Define which HttpMethods can be used for queries
    * @default ['get']
@@ -27,10 +40,6 @@ type Query = {
 }
 
 type Mutation = {
-  /**
-   * Customize the queryKey, here you can specify a suffix.
-   */
-  key: (key: unknown[]) => unknown[]
   /**
    * Define which HttpMethods can be used for mutations
    * @default ['post', 'put', 'delete']
@@ -110,10 +119,12 @@ export type Options = {
    * When set, a suspenseQuery hooks will be added.
    */
   suspense?: Partial<Suspense> | false
+  queryKey?: QueryKey
   /**
    * Override some useQuery behaviours.
    */
   query?: Partial<Query> | false
+  mutationKey?: MutationKey
   /**
    * Override some useMutation behaviours.
    */
@@ -146,7 +157,9 @@ type ResolvedOptions = {
    */
   infinite: NonNullable<Infinite> | false
   suspense: Suspense | false
+  queryKey: QueryKey | undefined
   query: NonNullable<Required<Query>> | false
+  mutationKey: MutationKey | undefined
   mutation: NonNullable<Required<Mutation>> | false
 }