@kubb/plugin-react-query 3.0.0-alpha.5 → 3.0.0-alpha.6

package/src/components/Mutation.tsx

@@ -2,7 +2,7 @@ import transformers from '@kubb/core/transformers'
 import { FunctionParams, URLPath } from '@kubb/core/utils'
 import { useOperation, useOperationManager } from '@kubb/plugin-oas/hooks'
 import { getASTParams, getComments } from '@kubb/plugin-oas/utils'
-import { File, Function, Parser, useApp } from '@kubb/react'
+import { File, Function, useApp } from '@kubb/react'
 import { pluginTsName } from '@kubb/plugin-ts'
 
 import { SchemaType } from './SchemaType.tsx'
@@ -82,8 +82,9 @@ function Template({ name, params, mutateParams, JSDoc, client, hook, dataReturnT
     : undefined
 
   return (
-    <Function export name={name} params={params} JSDoc={JSDoc}>
-      {`
+    <File.Source name={name} isExportable>
+      <Function export name={name} params={params} JSDoc={JSDoc}>
+        {`
          const { mutation: mutationOptions, client: clientOptions = {} } = options ?? {}
 
          return ${hook.name}({
@@ -98,7 +99,8 @@ function Template({ name, params, mutateParams, JSDoc, client, hook, dataReturnT
            },
            ...mutationOptions
          })`}
-    </Function>
+      </Function>
+    </File.Source>
   )
 }
 
@@ -124,32 +126,30 @@ function RootTemplate({ children }: RootTemplateProps) {
   const fileType = getFile(operation, { pluginKey: [pluginTsName] })
 
   return (
-    <Parser language="typescript">
-      <File<FileMeta> baseName={file.baseName} path={file.path} meta={file.meta}>
-        <File.Import name={'client'} path={importPath} />
-        <File.Import name={['ResponseConfig']} path={importPath} isTypeOnly />
-        <File.Import
-          name={[
-            schemas.request?.name,
-            schemas.response.name,
-            schemas.pathParams?.name,
-            schemas.queryParams?.name,
-            schemas.headerParams?.name,
-            ...(schemas.errors?.map((error) => error.name) || []),
-          ].filter(Boolean)}
-          root={file.path}
-          path={fileType.path}
-          isTypeOnly
-        />
-        <File.Import
-          name={['UseMutationOptions', 'UseMutationResult']}
-          path={typeof mutate !== 'boolean' && mutate.importPath ? mutate.importPath : '@tanstack/react-query'}
-          isTypeOnly
-        />
-        <File.Import name={['useMutation']} path={typeof mutate !== 'boolean' && mutate.importPath ? mutate.importPath : '@tanstack/react-query'} />
-        <File.Source>{children}</File.Source>
-      </File>
-    </Parser>
+    <File<FileMeta> baseName={file.baseName} path={file.path} meta={file.meta}>
+      <File.Import name={'client'} path={importPath} />
+      <File.Import name={['ResponseConfig']} path={importPath} isTypeOnly />
+      <File.Import
+        name={[
+          schemas.request?.name,
+          schemas.response.name,
+          schemas.pathParams?.name,
+          schemas.queryParams?.name,
+          schemas.headerParams?.name,
+          ...(schemas.errors?.map((error) => error.name) || []),
+        ].filter(Boolean)}
+        root={file.path}
+        path={fileType.path}
+        isTypeOnly
+      />
+      <File.Import
+        name={['UseMutationOptions', 'UseMutationResult']}
+        path={typeof mutate !== 'boolean' && mutate.importPath ? mutate.importPath : '@tanstack/react-query'}
+        isTypeOnly
+      />
+      <File.Import name={['useMutation']} path={typeof mutate !== 'boolean' && mutate.importPath ? mutate.importPath : '@tanstack/react-query'} />
+      {children}
+    </File>
   )
 }
 

package/src/components/Query.tsx

@@ -1,7 +1,7 @@
 import { PackageManager } from '@kubb/core'
 import transformers from '@kubb/core/transformers'
 import { FunctionParams, URLPath } from '@kubb/core/utils'
-import { Parser, File, Function, useApp } from '@kubb/react'
+import { File, Function, useApp } from '@kubb/react'
 import { pluginTsName } from '@kubb/plugin-ts'
 import { pluginZodName } from '@kubb/plugin-zod'
 import { useOperation, useOperationManager } from '@kubb/plugin-oas/hooks'
@@ -56,7 +56,7 @@ function Template({ name, generics, returnType, params, JSDoc, hook, infinite }:
 
   if (isV5) {
     return (
-      <>
+      <File.Source name={name} isExportable>
         <Function name={name} export generics={generics} returnType={resolvedReturnType} params={params} JSDoc={JSDoc}>
           {`
          const { query: queryOptions, client: clientOptions = {} } = options ?? {}
@@ -74,12 +74,12 @@ function Template({ name, generics, returnType, params, JSDoc, hook, infinite }:
 
          `}
         </Function>
-      </>
+      </File.Source>
     )
   }
 
   return (
-    <>
+    <File.Source name={name} isExportable>
       <Function name={name} export generics={generics} returnType={resolvedReturnType} params={params} JSDoc={JSDoc}>
         {`
        const { query: queryOptions, client: clientOptions = {} } = options ?? {}
@@ -97,7 +97,7 @@ function Template({ name, generics, returnType, params, JSDoc, hook, infinite }:
 
        `}
       </Function>
-    </>
+    </File.Source>
   )
 }
 
@@ -547,80 +547,76 @@ Query.File = function ({ templates }: FileProps): ReactNode {
   }
 
   return (
-    <Parser language="typescript">
-      <File<FileMeta> baseName={file.baseName} path={file.path} meta={file.meta}>
-        {parser === 'zod' && <File.Import name={[zodSchemas.response?.name]} root={file.path} path={fileZodSchemas.path} />}
-        <File.Import name={'client'} path={importPath} />
-        <File.Import name={['ResponseConfig']} path={importPath} isTypeOnly />
-        <File.Import
-          name={[
-            schemas.request?.name,
-            schemas.response.name,
-            schemas.pathParams?.name,
-            schemas.queryParams?.name,
-            schemas.headerParams?.name,
-            ...(schemas.errors?.map((error) => error.name) || []),
-          ].filter(Boolean)}
-          root={file.path}
-          path={fileType.path}
-          isTypeOnly
-        />
+    <File<FileMeta> baseName={file.baseName} path={file.path} meta={file.meta}>
+      {parser === 'zod' && <File.Import name={[zodSchemas.response?.name]} root={file.path} path={fileZodSchemas.path} />}
+      <File.Import name={'client'} path={importPath} />
+      <File.Import name={['ResponseConfig']} path={importPath} isTypeOnly />
+      <File.Import
+        name={[
+          schemas.request?.name,
+          schemas.response.name,
+          schemas.pathParams?.name,
+          schemas.queryParams?.name,
+          schemas.headerParams?.name,
+          ...(schemas.errors?.map((error) => error.name) || []),
+        ].filter(Boolean)}
+        root={file.path}
+        path={fileType.path}
+        isTypeOnly
+      />
 
-        <QueryImports hookPath={typeof query !== 'boolean' ? query.importPath : undefined} Template={Import} isInfinite={false} isSuspense={false} />
-        {!!infinite && (
-          <QueryImports hookPath={typeof query !== 'boolean' ? query.importPath : undefined} Template={Import} isInfinite={true} isSuspense={false} />
-        )}
-        {!!suspense && isV5 && (
-          <QueryImports hookPath={typeof query !== 'boolean' ? query.importPath : undefined} Template={Import} isInfinite={false} isSuspense={true} />
-        )}
-        <File.Source>
-          <SchemaType />
-          <Query
-            factory={factory}
-            Template={Template}
-            QueryKeyTemplate={QueryKeyTemplate}
-            QueryOptionsTemplate={QueryOptionsTemplate}
-            infinite={false}
-            suspense={false}
-            query={query}
-            queryOptions={queryOptions}
-            hookName={importNames.query['react'].hookName}
-            resultType={importNames.query['react'].resultType}
-            optionsType={importNames.query['react'].optionsType}
-          />
-          {!!infinite && (
-            <Query
-              factory={factory}
-              Template={Template}
-              QueryKeyTemplate={QueryKeyTemplate}
-              QueryOptionsTemplate={QueryOptionsTemplate}
-              infinite={infinite}
-              suspense={false}
-              query={query}
-              queryOptions={queryOptions}
-              hookName={importNames.queryInfinite['react'].hookName}
-              resultType={importNames.queryInfinite['react'].resultType}
-              optionsType={importNames.queryInfinite['react'].optionsType}
-            />
-          )}
-          {!!suspense && isV5 && (
-            <Query
-              factory={factory}
-              Template={Template}
-              QueryKeyTemplate={QueryKeyTemplate}
-              QueryOptionsTemplate={QueryOptionsTemplate}
-              infinite={false}
-              suspense={suspense}
-              query={query}
-              queryOptions={queryOptions}
-              hookName={importNames.querySuspense['react'].hookName}
-              resultType={importNames.querySuspense['react'].resultType}
-              optionsType={importNames.querySuspense['react'].optionsType}
-            />
-          )}
-        </File.Source>
-      </File>
-    </Parser>
+      <QueryImports hookPath={typeof query !== 'boolean' ? query.importPath : undefined} Template={Import} isInfinite={false} isSuspense={false} />
+      {!!infinite && (
+        <QueryImports hookPath={typeof query !== 'boolean' ? query.importPath : undefined} Template={Import} isInfinite={true} isSuspense={false} />
+      )}
+      {!!suspense && isV5 && (
+        <QueryImports hookPath={typeof query !== 'boolean' ? query.importPath : undefined} Template={Import} isInfinite={false} isSuspense={true} />
+      )}
+      <SchemaType />
+      <Query
+        factory={factory}
+        Template={Template}
+        QueryKeyTemplate={QueryKeyTemplate}
+        QueryOptionsTemplate={QueryOptionsTemplate}
+        infinite={false}
+        suspense={false}
+        query={query}
+        queryOptions={queryOptions}
+        hookName={importNames.query['react'].hookName}
+        resultType={importNames.query['react'].resultType}
+        optionsType={importNames.query['react'].optionsType}
+      />
+      {!!infinite && (
+        <Query
+          factory={factory}
+          Template={Template}
+          QueryKeyTemplate={QueryKeyTemplate}
+          QueryOptionsTemplate={QueryOptionsTemplate}
+          infinite={infinite}
+          suspense={false}
+          query={query}
+          queryOptions={queryOptions}
+          hookName={importNames.queryInfinite['react'].hookName}
+          resultType={importNames.queryInfinite['react'].resultType}
+          optionsType={importNames.queryInfinite['react'].optionsType}
+        />
+      )}
+      {!!suspense && isV5 && (
+        <Query
+          factory={factory}
+          Template={Template}
+          QueryKeyTemplate={QueryKeyTemplate}
+          QueryOptionsTemplate={QueryOptionsTemplate}
+          infinite={false}
+          suspense={suspense}
+          query={query}
+          queryOptions={queryOptions}
+          hookName={importNames.querySuspense['react'].hookName}
+          resultType={importNames.querySuspense['react'].resultType}
+          optionsType={importNames.querySuspense['react'].optionsType}
+        />
+      )}
+    </File>
   )
 }
 

package/src/components/QueryKey.tsx

@@ -1,5 +1,5 @@
 import { FunctionParams, URLPath } from '@kubb/core/utils'
-import { Function, Type, useApp } from '@kubb/react'
+import { Function, Type, File, useApp } from '@kubb/react'
 import { useOperation, useOperationManager } from '@kubb/plugin-oas/hooks'
 import { getASTParams } from '@kubb/plugin-oas/utils'
 
@@ -41,13 +41,16 @@ type TemplateProps = {
 function Template({ name, typeName, params, generics, returnType, JSDoc, keys }: TemplateProps): ReactNode {
   return (
     <>
-      <Function.Arrow name={name} export generics={generics} params={params} returnType={returnType} singleLine JSDoc={JSDoc}>
-        {`[${keys}] as const`}
-      </Function.Arrow>
-
-      <Type name={typeName} export>
-        {`ReturnType<typeof ${name}>`}
-      </Type>
+      <File.Source name={name} isExportable>
+        <Function.Arrow name={name} export generics={generics} params={params} returnType={returnType} singleLine JSDoc={JSDoc}>
+          {`[${keys}] as const`}
+        </Function.Arrow>
+      </File.Source>
+      <File.Source name={name} isExportable isTypeOnly>
+        <Type name={typeName} export>
+          {`ReturnType<typeof ${name}>`}
+        </Type>
+      </File.Source>
     </>
   )
 }

package/src/components/QueryOptions.tsx

@@ -3,7 +3,7 @@ import transformers from '@kubb/core/transformers'
 import { FunctionParams, URLPath } from '@kubb/core/utils'
 import { useOperation, useOperationManager } from '@kubb/plugin-oas/hooks'
 import { getASTParams } from '@kubb/plugin-oas/utils'
-import { Function, useApp } from '@kubb/react'
+import { Function, useApp, File } from '@kubb/react'
 import { pluginZodName } from '@kubb/plugin-zod'
 
 import { isRequired } from '@kubb/oas'
@@ -123,8 +123,9 @@ function Template({ name, params, generics, returnType, JSDoc, hook, client, inf
   if (infinite) {
     if (isV5) {
       return (
-        <Function name={name} export params={params} JSDoc={JSDoc}>
-          {`
+        <File.Source name={name} isExportable>
+          <Function name={name} export params={params} JSDoc={JSDoc}>
+            {`
        const queryKey = ${hook.queryKey}
 
        return infiniteQueryOptions({
@@ -142,13 +143,15 @@ function Template({ name, params, generics, returnType, JSDoc, hook, client, inf
        })
 
        `}
-        </Function>
+          </Function>
+        </File.Source>
       )
     }
 
     return (
-      <Function name={name} export generics={generics} returnType={returnType} params={params} JSDoc={JSDoc}>
-        {`
+      <File.Source name={name} isExportable>
+        <Function name={name} export generics={generics} returnType={returnType} params={params} JSDoc={JSDoc}>
+          {`
          const queryKey = ${hook.queryKey}
 
          return {
@@ -166,14 +169,16 @@ function Template({ name, params, generics, returnType, JSDoc, hook, client, inf
          }
 
          `}
-      </Function>
+        </Function>
+      </File.Source>
     )
   }
 
   if (isV5) {
     return (
-      <Function name={name} export params={params} JSDoc={JSDoc}>
-        {`
+      <File.Source name={name} isExportable>
+        <Function name={name} export params={params} JSDoc={JSDoc}>
+          {`
    const queryKey = ${hook.queryKey}
 
    return queryOptions({
@@ -191,13 +196,15 @@ function Template({ name, params, generics, returnType, JSDoc, hook, client, inf
    })
 
    `}
-      </Function>
+        </Function>
+      </File.Source>
     )
   }
 
   return (
-    <Function name={name} export generics={generics} returnType={returnType} params={params} JSDoc={JSDoc}>
-      {`
+    <File.Source name={name} isExportable>
+      <Function name={name} export generics={generics} returnType={returnType} params={params} JSDoc={JSDoc}>
+        {`
        const queryKey = ${hook.queryKey}
 
        return {
@@ -215,7 +222,8 @@ function Template({ name, params, generics, returnType, JSDoc, hook, client, inf
        }
 
        `}
-    </Function>
+      </Function>
+    </File.Source>
   )
 }
 

package/src/components/SchemaType.tsx

@@ -1,5 +1,5 @@
 import { useOperation, useOperationManager } from '@kubb/plugin-oas/hooks'
-import { Type, useApp } from '@kubb/react'
+import { File, Type, useApp } from '@kubb/react'
 
 import type { ReactNode } from 'react'
 import type { PluginReactQuery } from '../types.ts'
@@ -32,9 +32,12 @@ export function SchemaType(): ReactNode {
 
   return (
     <>
-      <Type name={clientType}>{`typeof client<${TResponse}, ${TError}, ${isFormData ? 'FormData' : TRequest}>`}</Type>
-      <Type name={factoryName}>
-        {`
+      <File.Source name={clientType} isTypeOnly>
+        <Type name={clientType}>{`typeof client<${TResponse}, ${TError}, ${isFormData ? 'FormData' : TRequest}>`}</Type>
+      </File.Source>
+      <File.Source name={factoryName} isTypeOnly>
+        <Type name={factoryName}>
+          {`
         {
           data: ${TData}
           error: ${TError}
@@ -49,7 +52,8 @@ export function SchemaType(): ReactNode {
           }
         }
         `}
-      </Type>
+        </Type>
+      </File.Source>
     </>
   )
 }

package/src/components/__snapshots__/gen/showPetById.ts

@@ -1,57 +1,67 @@
 type GetPetsUuidClient = typeof client<GetPetsUuidQueryResponse, never, never>
-type GetPetsUuid = {
-  data: GetPetsUuidQueryResponse
-  error: never
-  request: never
-  pathParams: never
-  queryParams: never
-  headerParams: never
-  response: GetPetsUuidQueryResponse
-  client: {
-    parameters: Partial<Parameters<GetPetsUuidClient>[0]>
-    return: Awaited<ReturnType<GetPetsUuidClient>>
-  }
-}
 
-export const GetPetsUuidQueryKey = () => [{ url: '/pets/:uuid', params: { uuid: uuid } }] as const
+type GetPetsUuid = 
+            {
+              data: GetPetsUuidQueryResponse
+              error: never
+              request: never
+              pathParams: never
+              queryParams: never
+              headerParams: never
+              response: GetPetsUuidQueryResponse
+              client: {
+                parameters: Partial<Parameters<GetPetsUuidClient>[0]>
+                return: Awaited<ReturnType<GetPetsUuidClient>>
+              }
+            }
+
+export const GetPetsUuidQueryKey = () =>   [{ url: '/pets/:uuid', params: {uuid:uuid} }] as const
+
 export type GetPetsUuidQueryKey = ReturnType<typeof GetPetsUuidQueryKey>
-export function GetPetsUuidQueryOptions<TData = GetPetsUuid['response'], TQueryData = GetPetsUuid['response']>(
-  options: GetPetsUuid['client']['parameters'] = {},
-): WithRequired<UseBaseQueryOptions<GetPetsUuid['response'], GetPetsUuid['error'], TData, TQueryData>, 'queryKey'> {
-  const queryKey = GetPetsUuidQueryKey()
 
-  return {
-    queryKey,
-    queryFn: async () => {
-      const res = await client<GetPetsUuid['data'], GetPetsUuid['error']>({
-        method: 'get',
+export function GetPetsUuidQueryOptions<TData = GetPetsUuid["response"], TQueryData = GetPetsUuid["response"]>(options: GetPetsUuid['client']['parameters'] = {}): WithRequired<UseBaseQueryOptions<GetPetsUuid['response'], GetPetsUuid["error"], TData, TQueryData>, 'queryKey'> {
+  
+           const queryKey = GetPetsUuidQueryKey()
+    
+           return {
+             queryKey,
+             queryFn: async () => {
+               
+               
+               const res = await client<GetPetsUuid['data'],GetPetsUuid['error']>({
+                    method: "get",
         url: `/pets/${uuid}`,
-        ...options,
-      })
-
-      return res.data
-    },
-  }
+        ...options
+               })
+    
+               return res.data
+             },
+                 
+           }
+    
+           
 }
+
 /**
  * @link /pets/:uuid
  */
-export function useGetPetsUuid<TData = GetPetsUuid['response'], TQueryData = GetPetsUuid['response'], TQueryKey extends QueryKey = GetPetsUuidQueryKey>(
-  options: {
-    query?: Partial<UseBaseQueryOptions<GetPetsUuid['response'], GetPetsUuid['error'], TData, TQueryData, TQueryKey>>
-    client?: GetPetsUuid['client']['parameters']
-  } = {},
-): UseQueryResult<TData, GetPetsUuid['error']> & { queryKey: TQueryKey } {
-  const { query: queryOptions, client: clientOptions = {} } = options ?? {}
-  const queryKey = queryOptions?.queryKey ?? GetPetsUuidQueryKey()
-
-  const query = useQuery<GetPetsUuid['data'], GetPetsUuid['error'], TData, any>({
-    ...GetPetsUuidQueryOptions<TData, TQueryData>(clientOptions),
-    queryKey,
-    ...queryOptions,
-  }) as UseQueryResult<TData, GetPetsUuid['error']> & { queryKey: TQueryKey }
-
-  query.queryKey = queryKey as TQueryKey
-
-  return query
-}
+export function useGetPetsUuid<TData = GetPetsUuid["response"], TQueryData = GetPetsUuid["response"], TQueryKey extends QueryKey = GetPetsUuidQueryKey>(options: {
+        query?: Partial<UseBaseQueryOptions<GetPetsUuid['response'], GetPetsUuid['error'], TData, TQueryData, TQueryKey>>,
+        client?: GetPetsUuid['client']['parameters']
+    } = {}): UseQueryResult<TData, GetPetsUuid['error']> & { queryKey: TQueryKey } {
+  
+           const { query: queryOptions, client: clientOptions = {} } = options ?? {}
+           const queryKey = queryOptions?.queryKey ?? GetPetsUuidQueryKey()
+    
+           const query = useQuery<GetPetsUuid['data'], GetPetsUuid['error'], TData, any>({
+            ...GetPetsUuidQueryOptions<TData, TQueryData>(clientOptions),
+            queryKey,
+            ...queryOptions
+          }) as UseQueryResult<TData, GetPetsUuid['error']> & { queryKey: TQueryKey }
+    
+          query.queryKey = queryKey as TQueryKey
+    
+          return query
+    
+           
+}

package/src/components/__snapshots__/gen/useCreatePets.ts

@@ -1,46 +1,46 @@
 type CreatePetsClient = typeof client<CreatePetsMutationResponse, never, CreatePetsMutationRequest>
-type CreatePets = {
-  data: CreatePetsMutationResponse
-  error: never
-  request: CreatePetsMutationRequest
-  pathParams: CreatePetsPathParams
-  queryParams: CreatePetsQueryParams
-  headerParams: CreatePetsHeaderParams
-  response: CreatePetsMutationResponse
-  client: {
-    parameters: Partial<Parameters<CreatePetsClient>[0]>
-    return: Awaited<ReturnType<CreatePetsClient>>
-  }
-}
+
+type CreatePets = 
+            {
+              data: CreatePetsMutationResponse
+              error: never
+              request: CreatePetsMutationRequest
+              pathParams: CreatePetsPathParams
+              queryParams: CreatePetsQueryParams
+              headerParams: CreatePetsHeaderParams
+              response: CreatePetsMutationResponse
+              client: {
+                parameters: Partial<Parameters<CreatePetsClient>[0]>
+                return: Awaited<ReturnType<CreatePetsClient>>
+              }
+            }
 
 /**
  * @summary Create a pet
  * @link /pets/:uuid
  */
-export function useCreatePets(
-  uuid: CreatePetsPathParams['uuid'],
-  headers: CreatePets['headerParams'],
-  params?: CreatePets['queryParams'],
-  options: {
-    mutation?: UseMutationOptions<CreatePets['response'], CreatePets['error'], CreatePets['request']>
-    client?: CreatePets['client']['parameters']
-  } = {},
-) {
-  const { mutation: mutationOptions, client: clientOptions = {} } = options ?? {}
-
-  return useMutation({
-    mutationFn: async (data) => {
-      const res = await client<CreatePets['data'], CreatePets['error'], CreatePets['request']>({
-        method: 'post',
+export function useCreatePets(uuid: CreatePetsPathParams["uuid"], headers: CreatePets['headerParams'], params?: CreatePets['queryParams'], options: {
+          mutation?: UseMutationOptions<CreatePets["response"], CreatePets["error"], CreatePets["request"]>,
+          client?: CreatePets['client']['parameters']
+      } = {}) {
+  
+             const { mutation: mutationOptions, client: clientOptions = {} } = options ?? {}
+    
+             return useMutation({
+               mutationFn: async(data) => {
+                 
+                 
+                 const res = await client<CreatePets["data"], CreatePets["error"], CreatePets["request"]>({
+                      method: "post",
         url: `/pets/${uuid}`,
         params,
         data,
         headers: { ...headers, ...clientOptions.headers },
-        ...clientOptions,
-      })
-
-      return res.data
-    },
-    ...mutationOptions,
-  })
-}
+        ...clientOptions
+                 })
+    
+                 return res.data
+               },
+               ...mutationOptions
+             })
+}