@kubb/plugin-swr 5.0.0-alpha.34 → 5.0.0-alpha.35

package/src/generators/mutationGenerator.tsx

@@ -1,168 +1,245 @@
 import path from 'node:path'
-import { useDriver } from '@kubb/core/hooks'
-import { ClientLegacy as Client, pluginClientName } from '@kubb/plugin-client'
-import { createReactGenerator } from '@kubb/plugin-oas/generators'
-import { useOas, useOperationManager } from '@kubb/plugin-oas/hooks'
-import { getBanner, getFooter } from '@kubb/plugin-oas/utils'
+
+import { ast, defineGenerator } from '@kubb/core'
+import { ClientLegacy as ClientLegacyComponent, pluginClientName } from '@kubb/plugin-client'
 import { pluginTsName } from '@kubb/plugin-ts'
 import { pluginZodName } from '@kubb/plugin-zod'
-import { File } from '@kubb/renderer-jsx'
+import { File, jsxRenderer } from '@kubb/renderer-jsx'
 import { difference } from 'remeda'
 import { Mutation, MutationKey } from '../components'
 import type { PluginSwr } from '../types'
+import { transformName } from '../utils.ts'
 
-export const mutationGenerator = createReactGenerator<PluginSwr>({
+export const mutationGenerator = defineGenerator<PluginSwr>({
   name: 'swr-mutation',
-  Operation({ config, operation, generator, plugin }) {
-    const {
-      options,
-      options: { output },
-    } = plugin
-    const driver = useDriver()
-    const root = path.resolve(config.root, config.output.path)
-
-    const oas = useOas()
-    const { getSchemas, getName, getFile } = useOperationManager(generator)
-
-    const isQuery = !!options.query && options.query?.methods.some((method) => operation.method === method)
+  renderer: jsxRenderer,
+  operation(node, ctx) {
+    const { adapter, config, driver, resolver, root } = ctx
+    const { output, query, mutation, paramsCasing, paramsType, pathParamsType, parser, client: clientOptions, group, transformers } = ctx.options
+
+    const pluginTs = driver.getPlugin(pluginTsName)
+    if (!pluginTs?.resolver) return null
+    const tsResolver = pluginTs.resolver
+
+    // Check if this operation is a mutation
+    const isQuery = !!query && query.methods.some((method) => node.method.toLowerCase() === method.toLowerCase())
     const isMutation =
-      options.mutation !== false &&
+      mutation !== false &&
       !isQuery &&
-      difference(options.mutation ? options.mutation.methods : [], options.query ? options.query.methods : []).some((method) => operation.method === method)
+      difference(mutation ? mutation.methods : [], query ? query.methods : []).some((method) => node.method.toLowerCase() === method.toLowerCase())
 
-    const importPath = options.mutation ? options.mutation.importPath : 'swr'
+    if (!isMutation) return null
 
-    const mutation = {
-      name: getName(operation, { type: 'function', prefix: 'use' }),
-      typeName: getName(operation, { type: 'type' }),
-      file: getFile(operation, { prefix: 'use' }),
-    }
+    const importPath = mutation ? mutation.importPath : 'swr/mutation'
 
-    const type = {
-      file: getFile(operation, { pluginName: pluginTsName }),
-      //todo remove type?
-      schemas: getSchemas(operation, { pluginName: pluginTsName, type: 'type' }),
-    }
+    // Resolve names — apply transformers.name to each constructed name to match the old
+    // createPlugin resolveName lifecycle (e.g. `addPetMutationKey` → `addPetMutationKeySWR`)
+    const baseName = resolver.resolveName(node.operationId)
+    const mutationHookName = transformName(`use${baseName.charAt(0).toUpperCase()}${baseName.slice(1)}`, 'function', transformers)
+    const mutationTypeName = transformName(`${baseName.charAt(0).toUpperCase()}${baseName.slice(1)}`, 'type', transformers)
+    const mutationKeyName = transformName(`${baseName}MutationKey`, 'const', transformers)
+    const mutationKeyTypeName = transformName(`${baseName.charAt(0).toUpperCase()}${baseName.slice(1)}MutationKey`, 'type', transformers)
+    const clientName = baseName
 
-    const zod = {
-      file: getFile(operation, { pluginName: pluginZodName }),
-      schemas: getSchemas(operation, { pluginName: pluginZodName, type: 'function' }),
+    const meta = {
+      file: resolver.resolveFile({ name: mutationHookName, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path }, { root, output, group }),
+      fileTs: tsResolver.resolveFile(
+        { name: node.operationId, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path },
+        { root, output: pluginTs.options?.output ?? output, group: pluginTs.options?.group },
+      ),
     }
 
-    const hasClientPlugin = !!driver.getPlugin(pluginClientName)
-    // Class-based clients are not compatible with query hooks, so we generate inline clients
-    const shouldUseClientPlugin = hasClientPlugin && options.client.clientType !== 'class'
-    const client = {
-      name: shouldUseClientPlugin
-        ? getName(operation, {
-            type: 'function',
-            pluginName: pluginClientName,
-          })
-        : getName(operation, {
-            type: 'function',
-          }),
-      file: getFile(operation, { pluginName: pluginClientName }),
-    }
+    const casedParams = ast.caseParams(node.parameters, paramsCasing)
+    const pathParams = casedParams.filter((p) => p.in === 'path')
+    const queryParams = casedParams.filter((p) => p.in === 'query')
+    const headerParams = casedParams.filter((p) => p.in === 'header')
 
-    const mutationKey = {
-      name: getName(operation, { type: 'const', suffix: 'MutationKey' }),
-      typeName: getName(operation, { type: 'type', suffix: 'MutationKey' }),
-    }
+    const importedTypeNames = [
+      ...pathParams.map((p) => tsResolver.resolvePathParamsName(node, p)),
+      ...queryParams.map((p) => tsResolver.resolveQueryParamsName(node, p)),
+      ...headerParams.map((p) => tsResolver.resolveHeaderParamsName(node, p)),
+      node.requestBody?.schema ? tsResolver.resolveDataName(node) : undefined,
+      tsResolver.resolveResponseName(node),
+      ...node.responses.map((res) => tsResolver.resolveResponseStatusName(node, res.statusCode)),
+    ].filter(Boolean)
 
-    if (!isMutation) {
-      return null
-    }
+    const pluginZodRaw = parser === 'zod' ? driver.getPlugin(pluginZodName) : undefined
+    const pluginZod = pluginZodRaw?.name === pluginZodName ? pluginZodRaw : undefined
+    const zodResolver = pluginZod?.resolver
+    const fileZod = zodResolver
+      ? zodResolver.resolveFile(
+          { name: node.operationId, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path },
+          { root, output: pluginZod?.options?.output ?? output, group: pluginZod?.options?.group },
+        )
+      : undefined
+    const zodSchemaNames =
+      zodResolver && parser === 'zod'
+        ? [zodResolver.resolveResponseName?.(node), node.requestBody?.schema ? zodResolver.resolveDataName?.(node) : undefined].filter(Boolean)
+        : []
+
+    const clientPlugin = driver.getPlugin(pluginClientName)
+    const hasClientPlugin = clientPlugin?.name === pluginClientName
+    const shouldUseClientPlugin = hasClientPlugin && clientOptions.clientType !== 'class'
+
+    const clientFile = shouldUseClientPlugin
+      ? clientPlugin?.resolver?.resolveFile(
+          { name: node.operationId, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path },
+          {
+            root,
+            output: clientPlugin?.options?.output ?? output,
+            group: clientPlugin?.options?.group,
+          },
+        )
+      : undefined
+
+    const resolvedClientName = shouldUseClientPlugin ? (clientPlugin?.resolver?.resolveName(node.operationId) ?? clientName) : clientName
 
     return (
       <File
-        baseName={mutation.file.baseName}
-        path={mutation.file.path}
-        meta={mutation.file.meta}
-        banner={getBanner({ oas, output, config: driver.config })}
-        footer={getFooter({ oas, output })}
+        baseName={meta.file.baseName}
+        path={meta.file.path}
+        meta={meta.file.meta}
+        banner={resolver.resolveBanner(adapter.inputNode, { output, config })}
+        footer={resolver.resolveFooter(adapter.inputNode, { output, config })}
       >
-        {options.parser === 'zod' && (
-          <File.Import name={[zod.schemas.response.name, zod.schemas.request?.name].filter(Boolean)} root={mutation.file.path} path={zod.file.path} />
+        {parser === 'zod' && fileZod && zodSchemaNames.length > 0 && (
+          <File.Import name={zodSchemaNames as string[]} root={meta.file.path} path={fileZod.path} />
         )}
-        {options.client.importPath ? (
+        {clientOptions.importPath ? (
           <>
-            {!shouldUseClientPlugin && <File.Import name={'fetch'} path={options.client.importPath} />}
-            <File.Import name={['Client', 'RequestConfig', 'ResponseErrorConfig']} path={options.client.importPath} isTypeOnly />
-            {options.client.dataReturnType === 'full' && <File.Import name={['ResponseConfig']} path={options.client.importPath} isTypeOnly />}
+            {!shouldUseClientPlugin && <File.Import name={'fetch'} path={clientOptions.importPath} />}
+            <File.Import name={['Client', 'RequestConfig', 'ResponseErrorConfig']} path={clientOptions.importPath} isTypeOnly />
+            {clientOptions.dataReturnType === 'full' && <File.Import name={['ResponseConfig']} path={clientOptions.importPath} isTypeOnly />}
           </>
         ) : (
           <>
-            {!shouldUseClientPlugin && <File.Import name={['fetch']} root={mutation.file.path} path={path.resolve(root, '.kubb/fetch.ts')} />}
+            {!shouldUseClientPlugin && <File.Import name={['fetch']} root={meta.file.path} path={path.resolve(root, '.kubb/fetch.ts')} />}
             <File.Import
               name={['Client', 'RequestConfig', 'ResponseErrorConfig']}
-              root={mutation.file.path}
+              root={meta.file.path}
               path={path.resolve(root, '.kubb/fetch.ts')}
               isTypeOnly
             />
-            {options.client.dataReturnType === 'full' && (
-              <File.Import name={['ResponseConfig']} root={mutation.file.path} path={path.resolve(root, '.kubb/fetch.ts')} isTypeOnly />
+            {clientOptions.dataReturnType === 'full' && (
+              <File.Import name={['ResponseConfig']} root={meta.file.path} path={path.resolve(root, '.kubb/fetch.ts')} isTypeOnly />
             )}
           </>
         )}
         <File.Import name="useSWRMutation" path={importPath} />
         <File.Import name={['SWRMutationConfiguration', 'SWRMutationResponse']} path={importPath} isTypeOnly />
-        {shouldUseClientPlugin && <File.Import name={[client.name]} root={mutation.file.path} path={client.file.path} />}
-        {!shouldUseClientPlugin && <File.Import name={['buildFormData']} root={mutation.file.path} path={path.resolve(root, '.kubb/config.ts')} />}
-        <File.Import
-          name={[
-            type.schemas.request?.name,
-            type.schemas.response.name,
-            type.schemas.pathParams?.name,
-            type.schemas.queryParams?.name,
-            type.schemas.headerParams?.name,
-            ...(type.schemas.statusCodes?.map((item) => item.name) || []),
-          ].filter(Boolean)}
-          root={mutation.file.path}
-          path={type.file.path}
-          isTypeOnly
-        />
+        {shouldUseClientPlugin && clientFile && <File.Import name={[resolvedClientName]} root={meta.file.path} path={clientFile.path} />}
+        {!shouldUseClientPlugin && <File.Import name={['buildFormData']} root={meta.file.path} path={path.resolve(root, '.kubb/config.ts')} />}
+        {meta.fileTs && importedTypeNames.length > 0 && (
+          <File.Import name={Array.from(new Set(importedTypeNames))} root={meta.file.path} path={meta.fileTs.path} isTypeOnly />
+        )}
 
         <MutationKey
-          name={mutationKey.name}
-          typeName={mutationKey.typeName}
-          operation={operation}
-          pathParamsType={options.pathParamsType}
-          typeSchemas={type.schemas}
-          paramsCasing={options.paramsCasing}
-          transformer={options.mutationKey}
+          name={mutationKeyName}
+          typeName={mutationKeyTypeName}
+          node={node}
+          pathParamsType={pathParamsType}
+          paramsCasing={paramsCasing}
+          transformer={ctx.options.mutationKey}
         />
 
         {!shouldUseClientPlugin && (
-          <Client
-            name={client.name}
-            baseURL={options.client.baseURL}
-            operation={operation}
-            typeSchemas={type.schemas}
-            zodSchemas={zod.schemas}
-            dataReturnType={options.client.dataReturnType || 'data'}
-            paramsCasing={options.client?.paramsCasing || options.paramsCasing}
-            paramsType={options.paramsType}
-            pathParamsType={options.pathParamsType}
-            parser={options.parser}
+          <ClientLegacyComponent
+            name={resolvedClientName}
+            baseURL={clientOptions.baseURL}
+            operation={{
+              path: node.path,
+              method: node.method,
+              getDescription: () => node.description,
+              getSummary: () => node.summary,
+              isDeprecated: () => node.deprecated ?? false,
+              getContentType: () => node.requestBody?.contentType ?? 'application/json',
+            }}
+            typeSchemas={buildLegacyTypeSchemas(node, tsResolver)}
+            zodSchemas={zodResolver ? buildLegacyTypeSchemas(node, zodResolver) : undefined}
+            dataReturnType={clientOptions.dataReturnType || 'data'}
+            paramsCasing={clientOptions.paramsCasing || paramsCasing}
+            paramsType={paramsType}
+            pathParamsType={pathParamsType}
+            parser={parser}
           />
         )}
-        {options.mutation && (
+
+        {mutation && (
           <Mutation
-            name={mutation.name}
-            clientName={client.name}
-            typeName={mutation.typeName}
-            typeSchemas={type.schemas}
-            operation={operation}
-            dataReturnType={options.client.dataReturnType || 'data'}
-            paramsType={options.paramsType}
-            paramsCasing={options.paramsCasing}
-            pathParamsType={options.pathParamsType}
-            mutationKeyName={mutationKey.name}
-            mutationKeyTypeName={mutationKey.typeName}
-            paramsToTrigger={options.mutation.paramsToTrigger}
+            name={mutationHookName}
+            clientName={resolvedClientName}
+            typeName={mutationTypeName}
+            node={node}
+            tsResolver={tsResolver}
+            dataReturnType={clientOptions.dataReturnType || 'data'}
+            paramsType={paramsType}
+            paramsCasing={paramsCasing}
+            pathParamsType={pathParamsType}
+            mutationKeyName={mutationKeyName}
+            mutationKeyTypeName={mutationKeyTypeName}
+            paramsToTrigger={mutation.paramsToTrigger}
           />
         )}
       </File>
     )
   },
 })
+
+/**
+ * Builds a legacy-compatible OperationSchemas object from OperationNode + resolver.
+ * Used for the ClientLegacy component which still expects the old format.
+ */
+// biome-ignore lint/suspicious/noExplicitAny: bridge between v5 resolver types and legacy OperationSchemas format
+function buildLegacyTypeSchemas(node: ast.OperationNode, resolver: any) {
+  const pathParams = node.parameters.filter((p) => p.in === 'path')
+  const queryParams = node.parameters.filter((p) => p.in === 'query')
+  const headerParams = node.parameters.filter((p) => p.in === 'header')
+
+  const buildSchemaProps = (params: typeof pathParams) => {
+    const properties: Record<string, { type: string }> = {}
+    const required: string[] = []
+    for (const p of params) {
+      properties[p.name] = { type: p.schema?.primitive ?? 'unknown' }
+      if (p.required) required.push(p.name)
+    }
+    return { properties, required }
+  }
+
+  return {
+    response: { name: resolver.resolveResponseName(node) },
+    request: node.requestBody?.schema
+      ? {
+          name: resolver.resolveDataName(node),
+          schema: { required: node.requestBody.required ? ['body'] : [] },
+        }
+      : undefined,
+    pathParams:
+      pathParams.length > 0 && resolver.resolvePathParamsName
+        ? {
+            name: resolver.resolvePathParamsName(node, pathParams[0]!),
+            schema: buildSchemaProps(pathParams),
+          }
+        : undefined,
+    queryParams:
+      queryParams.length > 0 && resolver.resolveQueryParamsName
+        ? {
+            name: resolver.resolveQueryParamsName(node, queryParams[0]!),
+            schema: buildSchemaProps(queryParams),
+          }
+        : undefined,
+    headerParams:
+      headerParams.length > 0 && resolver.resolveHeaderParamsName
+        ? {
+            name: resolver.resolveHeaderParamsName(node, headerParams[0]!),
+            schema: buildSchemaProps(headerParams),
+          }
+        : undefined,
+    errors: node.responses
+      .filter((r) => {
+        const code = Number.parseInt(r.statusCode, 10)
+        return code >= 400 || r.statusCode === 'default'
+      })
+      .map((r) => ({ name: resolver.resolveResponseStatusName(node, r.statusCode) })),
+    statusCodes: node.responses.map((r) => ({ name: resolver.resolveResponseStatusName(node, r.statusCode) })),
+  }
+}