@kubb/plugin-react-query 5.0.0-alpha.9 → 5.0.0-beta.10

package/src/generators/customHookOptionsFileGenerator.tsx

@@ -1,75 +1,61 @@
 import fs from 'node:fs'
 import path from 'node:path'
-import { usePluginDriver } from '@kubb/core/hooks'
-import type { Operation } from '@kubb/oas'
-import { createReactGenerator } from '@kubb/plugin-oas/generators'
-import { useOperationManager } from '@kubb/plugin-oas/hooks'
-import { File, Function } from '@kubb/react-fabric'
+
+import { defineGenerator } from '@kubb/core'
+import { File, Function, jsxRenderer } from '@kubb/renderer-jsx'
 import type { PluginReactQuery } from '../types'
 
-export const customHookOptionsFileGenerator = createReactGenerator<PluginReactQuery>({
+export const customHookOptionsFileGenerator = defineGenerator<PluginReactQuery>({
   name: 'react-query-custom-hook-options-file',
-  Operations({ operations, generator, plugin, config }) {
-    const {
-      options,
-      options: { output },
-      name: pluginName,
-    } = plugin
-    const driver = usePluginDriver()
-
-    const { getFile } = useOperationManager(generator)
+  renderer: jsxRenderer,
+  operations(nodes, ctx) {
+    const { resolver, config, root } = ctx
+    const { output, customOptions, query, group } = ctx.options
 
-    if (!options.customOptions) {
-      return null
-    }
+    if (!customOptions) return null
 
     const override = output.override ?? config.output.override ?? false
-    const { importPath, name } = options.customOptions
+    const { importPath, name } = customOptions
+    const hookOptionsName = resolver.resolveHookOptionsName()
+    const customHookOptionsName = resolver.resolveCustomHookOptionsName()
 
-    const root = path.resolve(config.root, config.output.path)
+    const reactQueryImportPath = query ? query.importPath : '@tanstack/react-query'
 
-    const reactQueryImportPath = options.query ? options.query.importPath : '@tanstack/react-query'
-
-    const getHookFilePath = (operations: Operation[]) => {
-      const firstOperation = operations[0]
-      if (firstOperation != null) {
-        // Get the file of the first generated hook
-        return getFile(firstOperation, { prefix: 'use' }).path
-      }
-      // Get the index file of the hooks directory
-      return driver.getFile({ name: 'index', extname: '.ts', pluginName }).path
+    let hookFilePath: string
+    const firstNode = nodes[0]
+    if (firstNode) {
+      const hookName = resolver.resolveQueryName(firstNode)
+      const hookFile = resolver.resolveFile(
+        { name: hookName, extname: '.ts', tag: firstNode.tags[0] ?? 'default', path: firstNode.path },
+        { root, output, group },
+      )
+      hookFilePath = hookFile.path
+    } else {
+      hookFilePath = path.resolve(root, 'index.ts')
     }
 
     const ensureExtension = (filePath: string, extname: string) => {
-      if (path.extname(filePath) === '') {
-        return filePath + extname
-      }
+      if (path.extname(filePath) === '') return filePath + extname
       return filePath
     }
 
-    const getExternalFile = (filePath: string, rootPath: string) => {
-      const actualFilePath = ensureExtension(filePath, '.ts')
-      return {
-        baseName: path.basename(actualFilePath) as `${string}.${string}`,
-        name: path.basename(actualFilePath, path.extname(actualFilePath)),
-        path: path.resolve(rootPath, actualFilePath),
-      }
+    const basePath = path.dirname(hookFilePath)
+    const actualFilePath = ensureExtension(importPath, '.ts')
+    const file = {
+      baseName: path.basename(actualFilePath) as `${string}.${string}`,
+      name: path.basename(actualFilePath, path.extname(actualFilePath)),
+      path: path.resolve(basePath, actualFilePath),
     }
 
-    const basePath = path.dirname(getHookFilePath(operations))
-    const file = getExternalFile(importPath, basePath)
-
-    if (fs.existsSync(file.path) && !override) {
-      return null
-    }
+    if (fs.existsSync(file.path) && !override) return null
 
     return (
       <File baseName={file.baseName} path={file.path}>
         <File.Import name={['QueryClient']} path={reactQueryImportPath} isTypeOnly />
         <File.Import name={['useQueryClient']} path={reactQueryImportPath} />
-        <File.Import name={['HookOptions']} root={file.path} path={path.resolve(root, './index.ts')} />
+        <File.Import name={[hookOptionsName]} root={file.path} path={path.resolve(root, './index.ts')} />
         <File.Source name={file.name} isExportable isIndexable>
-          <Function name="getCustomHookOptions" params="{ queryClient }: { queryClient: QueryClient }" returnType="Partial<HookOptions>">
+          <Function name={customHookOptionsName} params="{ queryClient }: { queryClient: QueryClient }" returnType={`Partial<${hookOptionsName}>`}>
             {`return {
               // TODO: Define custom hook options here
               // Example:
@@ -82,13 +68,13 @@ export const customHookOptionsFileGenerator = createReactGenerator<PluginReactQu
           </Function>
           <Function
             name={name}
-            generics="T extends keyof HookOptions"
+            generics={`T extends keyof ${hookOptionsName}`}
             params="{ hookName, operationId }: { hookName: T, operationId: string }"
-            returnType="HookOptions[T]"
+            returnType={`${hookOptionsName}[T]`}
             export
           >
             {`const queryClient = useQueryClient()
-            const customOptions = getCustomHookOptions({ queryClient })
+            const customOptions = ${customHookOptionsName}({ queryClient })
             return customOptions[hookName] ?? {}`}
           </Function>
         </File.Source>

package/src/generators/hookOptionsGenerator.tsx

@@ -1,193 +1,130 @@
-import { usePluginDriver } from '@kubb/core/hooks'
-import type { Operation } from '@kubb/oas'
-import { createReactGenerator } from '@kubb/plugin-oas/generators'
-import { useOas, useOperationManager } from '@kubb/plugin-oas/hooks'
-import { getBanner, getFooter } from '@kubb/plugin-oas/utils'
-import { File, Type } from '@kubb/react-fabric'
+import { getOperationParameters } from '@internals/shared'
+import { defineGenerator } from '@kubb/core'
+import { File, jsxRenderer, Type } from '@kubb/renderer-jsx'
+import type { KubbReactNode } from '@kubb/renderer-jsx/types'
 import { difference } from 'remeda'
 import type { PluginReactQuery } from '../types'
+import { resolveOperationOverrides } from '../utils.ts'
 
-export const hookOptionsGenerator = createReactGenerator<PluginReactQuery>({
-  name: 'react-query-hook-options',
-  Operations({ operations, plugin, generator }) {
-    const {
-      options,
-      options: { output },
-      name: pluginName,
-    } = plugin
-    const driver = usePluginDriver()
-
-    const oas = useOas()
-    const { getName, getFile } = useOperationManager(generator)
-
-    if (!options.customOptions) {
-      return null
-    }
+type QueryOption = PluginReactQuery['resolvedOptions']['query']
+type MutationOption = PluginReactQuery['resolvedOptions']['mutation']
 
-    const name = 'HookOptions'
-    const file = driver.getFile({ name, extname: '.ts', pluginName })
-
-    const getOperationOptions = (operation: Operation) => {
-      const operationOptions = generator.getOptions(operation, operation.method)
-      return { ...options, ...operationOptions }
-    }
-
-    const isQuery = (operation: Operation) => {
-      const operationOptions = getOperationOptions(operation)
-      return typeof operationOptions.query === 'boolean' ? true : operationOptions.query?.methods.some((method) => operation.method === method)
-    }
-
-    const isMutation = (operation: Operation) => {
-      const operationOptions = getOperationOptions(operation)
-      return (
-        operationOptions.mutation !== false &&
-        !isQuery(operation) &&
-        difference(operationOptions.mutation ? operationOptions.mutation.methods : [], operationOptions.query ? operationOptions.query.methods : []).some(
-          (method) => operation.method === method,
+export const hookOptionsGenerator = defineGenerator<PluginReactQuery>({
+  name: 'react-query-hook-options',
+  renderer: jsxRenderer,
+  operations(nodes, ctx) {
+    const { resolver, config, root, adapter } = ctx
+    const { output, customOptions, query, mutation, suspense, infinite, group, override } = ctx.options
+
+    if (!customOptions) return null
+
+    const name = resolver.resolveHookOptionsName()
+    const resolvedFile = resolver.resolveFile({ name, extname: '.ts' }, { root, output, group })
+    const hookOptionsFile = {
+      ...resolvedFile,
+      baseName: `${name}.ts` as const,
+      path: resolvedFile.path.replace(/[^/\\]+\.ts$/, `${name}.ts`),
+    }
+
+    const imports: KubbReactNode[] = []
+    const hookOptions: Record<string, string> = {}
+
+    for (const node of nodes) {
+      const opOverrides = resolveOperationOverrides(node, override)
+      const nodeQuery: QueryOption = 'query' in opOverrides ? (opOverrides.query as QueryOption) : query
+      const nodeMutation: MutationOption = 'mutation' in opOverrides ? (opOverrides.mutation as MutationOption) : mutation
+      const nodeInfinite = 'infinite' in opOverrides ? opOverrides.infinite : infinite
+      const nodeInfiniteOptions = nodeInfinite && typeof nodeInfinite === 'object' ? nodeInfinite : undefined
+
+      // query: false means "still a query but skip the useQuery hook"
+      const isQueryOp =
+        nodeQuery === false
+          ? !!query && query.methods.some((m) => node.method.toLowerCase() === m.toLowerCase())
+          : !!nodeQuery && nodeQuery.methods.some((m) => node.method.toLowerCase() === m.toLowerCase())
+      const isMutationOp =
+        nodeMutation !== false &&
+        !isQueryOp &&
+        difference(nodeMutation ? nodeMutation.methods : [], nodeQuery ? nodeQuery.methods : []).some((m) => node.method.toLowerCase() === m.toLowerCase())
+      const isSuspenseOp = !!suspense
+      const isInfiniteOp = !!nodeInfiniteOptions
+
+      if (isQueryOp) {
+        const queryOptionsName = resolver.resolveQueryOptionsName(node)
+        const queryHookName = resolver.resolveQueryName(node)
+        const queryHookFile = resolver.resolveFile(
+          { name: queryHookName, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path },
+          { root, output, group },
         )
-      )
-    }
-
-    const isSuspense = (operation: Operation) => {
-      const operationOptions = getOperationOptions(operation)
-      return !!operationOptions.suspense
-    }
-
-    const isInfinite = (operation: Operation) => {
-      const operationOptions = getOperationOptions(operation)
-      const infiniteOptions = operationOptions.infinite && typeof operationOptions.infinite === 'object' ? operationOptions.infinite : undefined
-      return !!infiniteOptions
-    }
-
-    // Query/mutation hooks
-    const getHookName = (operation: Operation) => {
-      return getName(operation, { type: 'function', prefix: 'use' })
-    }
-
-    const getHookFile = (operation: Operation) => {
-      return getFile(operation, { prefix: 'use' })
-    }
-
-    // Query hooks
-    const getQueryHookOptions = (operation: Operation) => {
-      return getName(operation, { type: 'function', suffix: 'QueryOptions' })
-    }
-
-    const getQueryHookOptionsImport = (operation: Operation) => {
-      return <File.Import name={[getQueryHookOptions(operation)]} root={file.path} path={getHookFile(operation).path} />
-    }
-
-    // Mutation hooks
-    const getMutationHookOptions = (operation: Operation) => {
-      return getName(operation, { type: 'function', suffix: 'MutationOptions' })
-    }
-
-    const getMutationHookOptionsImport = (operation: Operation) => {
-      return <File.Import name={[getMutationHookOptions(operation)]} root={file.path} path={getHookFile(operation).path} />
-    }
-
-    // Suspense hooks
-    const getSuspenseHookName = (operation: Operation) => {
-      return getName(operation, { type: 'function', prefix: 'use', suffix: 'suspense' })
-    }
-
-    const getSuspenseHookFile = (operation: Operation) => {
-      return getFile(operation, { prefix: 'use', suffix: 'suspense' })
-    }
-
-    const getSuspenseHookOptions = (operation: Operation) => {
-      return getName(operation, { type: 'function', suffix: 'SuspenseQueryOptions' })
-    }
-
-    const getSuspenseHookOptionsImport = (operation: Operation) => {
-      return <File.Import name={[getSuspenseHookOptions(operation)]} root={file.path} path={getSuspenseHookFile(operation).path} />
-    }
-
-    // Infinite hooks
-    const getInfiniteHookName = (operation: Operation) => {
-      return getName(operation, { type: 'function', prefix: 'use', suffix: 'infinite' })
-    }
-
-    const getInfiniteHookFile = (operation: Operation) => {
-      return getFile(operation, { prefix: 'use', suffix: 'infinite' })
-    }
-
-    const getInfiniteHookOptions = (operation: Operation) => {
-      return getName(operation, { type: 'function', suffix: 'InfiniteQueryOptions' })
-    }
-
-    const getInfiniteHookOptionsImport = (operation: Operation) => {
-      return <File.Import name={[getInfiniteHookOptions(operation)]} root={file.path} path={getInfiniteHookFile(operation).path} />
-    }
-
-    // Suspense infinite hooks
-    const getSuspenseInfiniteHookName = (operation: Operation) => {
-      return getName(operation, { type: 'function', prefix: 'use', suffix: 'suspenseInfinite' })
-    }
-
-    const getSuspenseInfiniteHookFile = (operation: Operation) => {
-      return getFile(operation, { prefix: 'use', suffix: 'suspenseInfinite' })
-    }
-
-    const getSuspenseInfiniteHookOptions = (operation: Operation) => {
-      return getName(operation, { type: 'function', suffix: 'SuspenseInfiniteQueryOptions' })
-    }
-
-    const getSuspenseInfiniteHookOptionsImport = (operation: Operation) => {
-      return <File.Import name={[getSuspenseInfiniteHookOptions(operation)]} root={file.path} path={getSuspenseInfiniteHookFile(operation).path} />
-    }
-
-    const imports = operations
-      .flatMap((operation) => {
-        if (isQuery(operation)) {
-          return [
-            getQueryHookOptionsImport(operation),
-            isSuspense(operation) ? getSuspenseHookOptionsImport(operation) : undefined,
-            isInfinite(operation) ? getInfiniteHookOptionsImport(operation) : undefined,
-            isSuspense(operation) && isInfinite(operation) ? getSuspenseInfiniteHookOptionsImport(operation) : undefined,
-          ].filter(Boolean)
+        imports.push(<File.Import name={[queryOptionsName]} root={hookOptionsFile.path} path={queryHookFile.path} />)
+        hookOptions[queryHookName] = `Partial<ReturnType<typeof ${queryOptionsName}>>`
+
+        if (isSuspenseOp) {
+          const suspenseOptionsName = resolver.resolveSuspenseQueryOptionsName(node)
+          const suspenseHookName = resolver.resolveSuspenseQueryName(node)
+          const suspenseHookFile = resolver.resolveFile(
+            { name: suspenseHookName, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path },
+            { root, output, group },
+          )
+          imports.push(<File.Import name={[suspenseOptionsName]} root={hookOptionsFile.path} path={suspenseHookFile.path} />)
+          hookOptions[suspenseHookName] = `Partial<ReturnType<typeof ${suspenseOptionsName}>>`
         }
-        if (isMutation(operation)) {
-          return [getMutationHookOptionsImport(operation)]
-        }
-        return []
-      })
-      .filter(Boolean)
 
-    const hookOptions = operations.reduce(
-      (acc, operation) => {
-        if (isQuery(operation)) {
-          acc[getHookName(operation)] = `Partial<ReturnType<typeof ${getQueryHookOptions(operation)}>>`
-          if (isSuspense(operation)) {
-            acc[getSuspenseHookName(operation)] = `Partial<ReturnType<typeof ${getSuspenseHookOptions(operation)}>>`
-          }
-          if (isInfinite(operation)) {
-            acc[getInfiniteHookName(operation)] = `Partial<ReturnType<typeof ${getInfiniteHookOptions(operation)}>>`
+        if (isInfiniteOp) {
+          // Validate queryParam
+          const normalizeKey = (key: string) => key.replace(/\?$/, '')
+          const queryParamKeys = getOperationParameters(node).query.map((p) => p.name)
+          const hasQueryParam = nodeInfiniteOptions!.queryParam ? queryParamKeys.some((k) => normalizeKey(k) === nodeInfiniteOptions!.queryParam) : false
+
+          if (hasQueryParam) {
+            const infiniteOptionsName = resolver.resolveInfiniteQueryOptionsName(node)
+            const infiniteHookName = resolver.resolveInfiniteQueryName(node)
+            const infiniteHookFile = resolver.resolveFile(
+              { name: infiniteHookName, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path },
+              { root, output, group },
+            )
+            imports.push(<File.Import name={[infiniteOptionsName]} root={hookOptionsFile.path} path={infiniteHookFile.path} />)
+            hookOptions[infiniteHookName] = `Partial<ReturnType<typeof ${infiniteOptionsName}>>`
+
+            if (isSuspenseOp) {
+              const suspenseInfiniteOptionsName = resolver.resolveSuspenseInfiniteQueryOptionsName(node)
+              const suspenseInfiniteHookName = resolver.resolveSuspenseInfiniteQueryName(node)
+              const suspenseInfiniteHookFile = resolver.resolveFile(
+                { name: suspenseInfiniteHookName, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path },
+                { root, output, group },
+              )
+              imports.push(<File.Import name={[suspenseInfiniteOptionsName]} root={hookOptionsFile.path} path={suspenseInfiniteHookFile.path} />)
+              hookOptions[suspenseInfiniteHookName] = `Partial<ReturnType<typeof ${suspenseInfiniteOptionsName}>>`
+            }
           }
-          if (isSuspense(operation) && isInfinite(operation)) {
-            acc[getSuspenseInfiniteHookName(operation)] = `Partial<ReturnType<typeof ${getSuspenseInfiniteHookOptions(operation)}>>`
-          }
-        }
-        if (isMutation(operation)) {
-          acc[getHookName(operation)] = `Partial<ReturnType<typeof ${getMutationHookOptions(operation)}>>`
         }
-        return acc
-      },
-      {} as Record<string, string>,
-    )
+      }
+
+      if (isMutationOp) {
+        const mutationOptionsName = resolver.resolveMutationOptionsName(node)
+        const mutationHookName = resolver.resolveMutationName(node)
+        const mutationHookFile = resolver.resolveFile(
+          { name: mutationHookName, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path },
+          { root, output, group },
+        )
+        imports.push(<File.Import name={[mutationOptionsName]} root={hookOptionsFile.path} path={mutationHookFile.path} />)
+        hookOptions[mutationHookName] = `Partial<ReturnType<typeof ${mutationOptionsName}>>`
+      }
+    }
 
     return (
       <File
-        baseName={file.baseName}
-        path={file.path}
-        meta={file.meta}
-        banner={getBanner({ oas, output, config: driver.config })}
-        footer={getFooter({ oas, output })}
+        baseName={hookOptionsFile.baseName}
+        path={hookOptionsFile.path}
+        meta={hookOptionsFile.meta}
+        banner={resolver.resolveBanner(adapter.inputNode, { output, config })}
+        footer={resolver.resolveFooter(adapter.inputNode, { output, config })}
       >
         {imports}
         <File.Source name={name} isExportable isIndexable isTypeOnly>
           <Type export name={name}>
-            {`{ ${Object.keys(hookOptions).map((key) => `${JSON.stringify(key)}: ${hookOptions[key]}`)} }`}
+            {`{ ${Object.keys(hookOptions)
+              .map((key) => `${JSON.stringify(key)}: ${hookOptions[key]}`)
+              .join(', ')} }`}
           </Type>
         </File.Source>
       </File>