@kubb/plugin-react-query 3.0.0-alpha.1 → 3.0.0-alpha.11

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 isIndexable>
+          <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 isIndexable>
+        <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 isIndexable>
+        <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 isIndexable>
+      <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
+             })
+}

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

@@ -1,47 +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(
-  options: {
-    mutation?: UseMutationOptions<
-      CreatePets['response'],
-      CreatePets['error'],
-      { uuid: CreatePetsPathParams['uuid']; params?: CreatePets['queryParams']; headers: CreatePets['headerParams']; data: CreatePets['request'] }
-    >
-    client?: CreatePets['client']['parameters']
-  } = {},
-) {
-  const { mutation: mutationOptions, client: clientOptions = {} } = options ?? {}
-
-  return useMutation({
-    mutationFn: async ({ uuid, headers, data, params }) => {
-      const res = await client<CreatePets['data'], CreatePets['error'], CreatePets['request']>({
-        method: 'post',
+export function useCreatePets(options: {
+          mutation?: UseMutationOptions<CreatePets["response"], CreatePets["error"], { uuid: CreatePetsPathParams["uuid"]; params?: CreatePets['queryParams']; headers: CreatePets['headerParams']; data: CreatePets['request'] }>,
+          client?: CreatePets['client']['parameters']
+      } = {}) {
+  
+             const { mutation: mutationOptions, client: clientOptions = {} } = options ?? {}
+    
+             return useMutation({
+               mutationFn: async({ uuid, headers, data, params }) => {
+                 
+                 
+                 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
+             })
+}

package/src/components/index.ts

@@ -1,5 +1,4 @@
 export { Mutation } from './Mutation.tsx'
-export { Operations } from './Operations.tsx'
 export { Query } from './Query.tsx'
 export { QueryKey } from './QueryKey.tsx'
 export { QueryOptions } from './QueryOptions.tsx'

package/src/plugin.ts

@@ -4,12 +4,12 @@ import { FileManager, PluginManager, createPlugin } from '@kubb/core'
 import { camelCase, pascalCase } from '@kubb/core/transformers'
 import { renderTemplate } from '@kubb/core/utils'
 import { pluginOasName } from '@kubb/plugin-oas'
-import { getGroupedByTagFiles } from '@kubb/plugin-oas/utils'
+
 import { pluginTsName } from '@kubb/plugin-ts'
 import { pluginZodName } from '@kubb/plugin-zod'
 
 import { OperationGenerator } from './OperationGenerator.tsx'
-import { Mutation, Operations, Query, QueryKey, QueryOptions } from './components/index.ts'
+import { Mutation, Query, QueryKey, QueryOptions } from './components/index.ts'
 
 import type { Plugin } from '@kubb/core'
 import type { PluginOas } from '@kubb/plugin-oas'
@@ -40,6 +40,10 @@ export const pluginReactQuery = createPlugin<PluginReactQuery>((options) => {
 
   return {
     name: pluginReactQueryName,
+    output: {
+      exportType: 'barrelNamed',
+      ...output,
+    },
     options: {
       client: {
         importPath: '@kubb/plugin-client/client',
@@ -78,7 +82,6 @@ export const pluginReactQuery = createPlugin<PluginReactQuery>((options) => {
         queryOptions: QueryOptions.templates,
         queryKey: QueryKey.templates,
         queryImports: QueryImports.templates,
-        operations: Operations.templates,
         ...templates,
       },
       parser,
@@ -126,7 +129,7 @@ export const pluginReactQuery = createPlugin<PluginReactQuery>((options) => {
     async buildStart() {
       const [swaggerPlugin]: [Plugin<PluginOas>] = PluginManager.getDependedPlugins<PluginOas>(this.plugins, [pluginOasName])
 
-      const oas = await swaggerPlugin.api.getOas()
+      const oas = await swaggerPlugin.context.getOas()
       const root = path.resolve(this.config.root, this.config.output.path)
       const mode = FileManager.getMode(path.resolve(root, output.path))
 
@@ -134,7 +137,7 @@ export const pluginReactQuery = createPlugin<PluginReactQuery>((options) => {
         oas,
         pluginManager: this.pluginManager,
         plugin: this.plugin,
-        contentType: swaggerPlugin.api.contentType,
+        contentType: swaggerPlugin.context.contentType,
         exclude,
         include,
         override,
@@ -143,41 +146,20 @@ export const pluginReactQuery = createPlugin<PluginReactQuery>((options) => {
 
       const files = await operationGenerator.build()
       await this.addFile(...files)
-    },
-    async writeFile(path, source) {
-      if (!path.endsWith('.ts') || !source) {
-        return
-      }
 
-      return this.fileManager.write(path, source, { sanity: false })
-    },
-    async buildEnd() {
-      if (this.config.output.write === false) {
-        return
-      }
-
-      const root = path.resolve(this.config.root, this.config.output.path)
-
-      if (group?.type === 'tag') {
-        const rootFiles = await getGroupedByTagFiles({
-          logger: this.logger,
-          files: this.fileManager.files,
-          plugin: this.plugin,
-          template,
-          exportAs: group.exportAs || '{{tag}}Hooks',
+      if (this.config.output.exportType) {
+        const barrelFiles = await this.fileManager.getBarrelFiles({
           root,
           output,
+          files: this.fileManager.files,
+          meta: {
+            pluginKey: this.plugin.key,
+          },
+          logger: this.logger,
         })
 
-        await this.addFile(...rootFiles)
+        await this.addFile(...barrelFiles)
       }
-
-      await this.fileManager.addIndexes({
-        root,
-        output,
-        meta: { pluginKey: this.plugin.key },
-        logger: this.logger,
-      })
     },
   }
 })

package/src/types.ts

@@ -4,14 +4,11 @@ import type * as KubbFile from '@kubb/fs/types'
 import type { HttpMethod } from '@kubb/oas'
 import type { Exclude, Include, Override, ResolvePathOptions } from '@kubb/plugin-oas'
 import type { Mutation } from './components/Mutation.tsx'
-import type { Operations } from './components/Operations.tsx'
 import type { Query as QueryTemplate } from './components/Query.tsx'
-import type { QueryImports } from './components/QueryImports.tsx'
 import type { QueryKey } from './components/QueryKey.tsx'
 import type { QueryOptions as QueryOptionsTemplate } from './components/QueryOptions.tsx'
 
 type Templates = {
-  operations?: typeof Operations.templates | false
   mutation?: typeof Mutation.templates | false
   query?: typeof QueryTemplate.templates | false
   queryOptions?: typeof QueryOptionsTemplate.templates | false