@kubb/plugin-react-query 3.0.0-alpha.0 → 3.0.0-alpha.10

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
@@ -232,9 +229,3 @@ export type FileMeta = {
 }
 
 export type PluginReactQuery = PluginFactoryOptions<'plugin-react-query', Options, ResolvedOptions, never, ResolvePathOptions>
-
-declare module '@kubb/core' {
-  export interface _Register {
-    ['@kubb/plugin-react-query']: PluginReactQuery
-  }
-}