@kubb/plugin-client 5.0.0-alpha.33 → 5.0.0-alpha.35

package/src/plugin.ts

@@ -1,16 +1,16 @@
 import path from 'node:path'
 import { camelCase } from '@internals/utils'
-import { createFile, createSource, createText } from '@kubb/ast'
-import { createPlugin, type Group, getPreset, mergeGenerators } from '@kubb/core'
+
+import { ast, definePlugin, type Group } from '@kubb/core'
 import { pluginTsName } from '@kubb/plugin-ts'
 import { pluginZodName } from '@kubb/plugin-zod'
-import { version } from '../package.json'
 import { classClientGenerator } from './generators/classClientGenerator.tsx'
 import { clientGenerator } from './generators/clientGenerator.tsx'
 import { groupedClientGenerator } from './generators/groupedClientGenerator.tsx'
 import { operationsGenerator } from './generators/operationsGenerator.tsx'
 import { staticClassClientGenerator } from './generators/staticClassClientGenerator.tsx'
-import { presets } from './presets.ts'
+import { resolverClient } from './resolvers/resolverClient.ts'
+import { resolverClientLegacy } from './resolvers/resolverClientLegacy.ts'
 import { source as axiosClientSource } from './templates/clients/axios.source.ts'
 import { source as fetchClientSource } from './templates/clients/fetch.source.ts'
 import { source as configSource } from './templates/config.source.ts'
@@ -38,7 +38,7 @@ export const pluginClientName = 'plugin-client' satisfies PluginClient['name']
  * })
  * ```
  */
-export const pluginClient = createPlugin<PluginClient>((options) => {
+export const pluginClient = definePlugin<PluginClient>((options) => {
   const {
     output = { path: 'clients', barrelType: 'named' },
     group,
@@ -58,11 +58,13 @@ export const pluginClient = createPlugin<PluginClient>((options) => {
     bundle = false,
     wrapper,
     baseURL,
-    compatibilityPreset = 'default',
     resolver: userResolver,
     transformer: userTransformer,
+    compatibilityPreset = 'default',
   } = options
 
+  const defaultResolver = compatibilityPreset === 'kubbV4' ? resolverClientLegacy : resolverClient
+
   const resolvedImportPath = importPath ?? (!bundle ? `@kubb/plugin-client/clients/${client}` : undefined)
 
   const selectedGenerators =
@@ -73,125 +75,86 @@ export const pluginClient = createPlugin<PluginClient>((options) => {
       operations ? operationsGenerator : undefined,
     ].filter((x): x is NonNullable<typeof x> => Boolean(x))
 
-  const preset = getPreset({
-    preset: compatibilityPreset,
-    presets,
-    resolver: userResolver,
-    transformer: userTransformer,
-    generators: selectedGenerators,
-  })
-
-  const generators = preset.generators ?? []
-  const mergedGenerator = mergeGenerators(generators)
-
-  let resolveNameWarning = false
-  let resolvePathWarning = false
+  const groupConfig = group
+    ? ({
+        ...group,
+        name: group.name
+          ? group.name
+          : (ctx: { group: string }) => {
+              if (group.type === 'path') {
+                return `${ctx.group.split('/')[1]}`
+              }
+              return `${camelCase(ctx.group)}Controller`
+            },
+      } satisfies Group)
+    : undefined
 
   return {
     name: pluginClientName,
-    version,
-    get resolver() {
-      return preset.resolver
-    },
-    get transformer() {
-      return preset.transformer
-    },
-    get options() {
-      return {
-        client,
-        clientType,
-        bundle,
-        output,
-        exclude,
-        include,
-        override,
-        group: group
-          ? ({
-              ...group,
-              name: group.name
-                ? group.name
-                : (ctx: { group: string }) => {
-                    if (group.type === 'path') {
-                      return `${ctx.group.split('/')[1]}`
-                    }
-                    return `${camelCase(ctx.group)}Controller`
-                  },
-            } satisfies Group)
-          : undefined,
-        parser,
-        dataReturnType,
-        importPath: resolvedImportPath,
-        baseURL,
-        paramsType,
-        paramsCasing,
-        pathParamsType,
-        urlType,
-        wrapper,
-        resolver: preset.resolver,
-      }
-    },
-    pre: [pluginTsName, parser === 'zod' ? pluginZodName : undefined].filter(Boolean),
-    resolvePath(baseName, pathMode, options) {
-      if (!resolvePathWarning) {
-        this.warn('Do not use resolvePath for pluginClient, use resolverClient.resolvePath instead')
-        resolvePathWarning = true
-      }
+    options,
+    dependencies: [pluginTsName, parser === 'zod' ? pluginZodName : undefined].filter(Boolean),
+    hooks: {
+      'kubb:plugin:setup'(ctx) {
+        const resolver = userResolver ? { ...defaultResolver, ...userResolver } : defaultResolver
 
-      return this.plugin.resolver.resolvePath(
-        { baseName, pathMode, tag: options?.group?.tag, path: options?.group?.path },
-        { root: this.root, output, group: this.plugin.options.group },
-      )
-    },
-    resolveName(name, type) {
-      if (!resolveNameWarning) {
-        this.warn('Do not use resolveName for pluginClient, use resolverClient.default instead')
-        resolveNameWarning = true
-      }
+        ctx.setOptions({
+          client,
+          clientType,
+          bundle,
+          output,
+          exclude,
+          include,
+          override,
+          group: groupConfig,
+          parser,
+          dataReturnType,
+          importPath: resolvedImportPath,
+          baseURL,
+          paramsType,
+          paramsCasing,
+          pathParamsType,
+          urlType,
+          wrapper,
+          resolver,
+        })
+        ctx.setResolver(resolver)
+        if (userTransformer) {
+          ctx.setTransformer(userTransformer)
+        }
+        for (const gen of selectedGenerators) {
+          ctx.addGenerator(gen)
+        }
 
-      return this.plugin.resolver.default(name, type)
-    },
-    async operation(node, options) {
-      return mergedGenerator.operation?.call(this, node, options)
-    },
-    async operations(nodes, options) {
-      return mergedGenerator.operations?.call(this, nodes, options)
-    },
-    async buildStart() {
-      const { plugin } = this
-      const root = this.root
+        const root = path.resolve(ctx.config.root, ctx.config.output.path)
 
-      // pre add bundled fetch
-      if (bundle && !plugin.options.importPath) {
-        await this.addFile(
-          createFile({
+        if (bundle && !resolvedImportPath) {
+          ctx.injectFile({
             baseName: 'fetch.ts',
             path: path.resolve(root, '.kubb/fetch.ts'),
             sources: [
-              createSource({
+              ast.createSource({
                 name: 'fetch',
-                nodes: [createText(plugin.options.client === 'fetch' ? fetchClientSource : axiosClientSource)],
+                nodes: [ast.createText(client === 'fetch' ? fetchClientSource : axiosClientSource)],
                 isExportable: true,
                 isIndexable: true,
               }),
             ],
-          }),
-        )
-      }
+          })
+        }
 
-      await this.addFile(
-        createFile({
+        ctx.injectFile({
           baseName: 'config.ts',
           path: path.resolve(root, '.kubb/config.ts'),
           sources: [
-            createSource({
+            ast.createSource({
               name: 'config',
-              nodes: [createText(configSource)],
+              nodes: [ast.createText(configSource)],
               isExportable: false,
               isIndexable: false,
             }),
           ],
-        }),
-      )
+        })
+      },
     },
   }
 })

package/src/types.ts

@@ -1,5 +1,5 @@
-import type { Visitor } from '@kubb/ast/types'
 import type {
+  ast,
   CompatibilityPreset,
   Exclude,
   Generator,
@@ -195,7 +195,7 @@ export type Options = {
    * Single AST visitor applied to each node before printing.
    * Return `null` or `undefined` from a method to leave the node unchanged.
    */
-  transformer?: Visitor
+  transformer?: ast.Visitor
   /**
    * Define some generators next to the client generators.
    */

package/src/utils.ts

@@ -1,11 +1,11 @@
 import { URLPath } from '@internals/utils'
-import type { OperationNode, ParameterNode } from '@kubb/ast/types'
+import type { ast } from '@kubb/core'
 import { FunctionParams } from '@kubb/core'
 import type { PluginTs } from '@kubb/plugin-ts'
 import type { PluginZod } from '@kubb/plugin-zod'
 import type { PluginClient } from './types.ts'
 
-export function getComments(node: OperationNode): Array<string> {
+export function getComments(node: ast.OperationNode): Array<string> {
   return [
     node.description && `@description ${node.description}`,
     node.summary && `@summary ${node.summary}`,
@@ -17,7 +17,7 @@ export function getComments(node: OperationNode): Array<string> {
     .filter((x): x is string => Boolean(x))
 }
 
-export function buildParamsMapping(originalParams: Array<ParameterNode>, casedParams: Array<ParameterNode>): Record<string, string> | undefined {
+export function buildParamsMapping(originalParams: Array<ast.ParameterNode>, casedParams: Array<ast.ParameterNode>): Record<string, string> | undefined {
   const mapping: Record<string, string> = {}
   let hasChanged = false
   originalParams.forEach((param, i) => {
@@ -37,7 +37,7 @@ export function buildHeaders(contentType: string, hasHeaderParams: boolean): Arr
   ].filter(Boolean) as Array<string>
 }
 
-export function buildGenerics(node: OperationNode, tsResolver: PluginTs['resolver']): Array<string> {
+export function buildGenerics(node: ast.OperationNode, tsResolver: PluginTs['resolver']): Array<string> {
   const responseName = tsResolver.resolveResponseName(node)
   const requestName = node.requestBody?.schema ? tsResolver.resolveDataName(node) : undefined
   const errorNames = node.responses.filter((r) => Number.parseInt(r.statusCode, 10) >= 400).map((r) => tsResolver.resolveResponseStatusName(node, r.statusCode))
@@ -53,7 +53,7 @@ export function buildClassClientParams({
   isFormData,
   headers,
 }: {
-  node: OperationNode
+  node: ast.OperationNode
   path: URLPath
   baseURL: string | undefined
   tsResolver: PluginTs['resolver']
@@ -106,7 +106,7 @@ export function buildRequestDataLine({
   zodResolver,
 }: {
   parser: PluginClient['resolvedOptions']['parser'] | undefined
-  node: OperationNode
+  node: ast.OperationNode
   zodResolver?: PluginZod['resolver']
 }): string {
   const zodRequestName = zodResolver && parser === 'zod' && node.requestBody?.schema ? zodResolver.resolveDataName?.(node) : undefined
@@ -131,7 +131,7 @@ export function buildReturnStatement({
 }: {
   dataReturnType: PluginClient['resolvedOptions']['dataReturnType']
   parser: PluginClient['resolvedOptions']['parser'] | undefined
-  node: OperationNode
+  node: ast.OperationNode
   zodResolver?: PluginZod['resolver']
 }): string {
   const zodResponseName = zodResolver && parser === 'zod' ? zodResolver.resolveResponseName?.(node) : undefined

package/src/presets.ts

@@ -1,25 +0,0 @@
-import { definePresets } from '@kubb/core'
-import { resolverClient } from './resolvers/resolverClient.ts'
-import { resolverClientLegacy } from './resolvers/resolverClientLegacy.ts'
-import type { ResolverClient } from './types.ts'
-
-/**
- * Built-in preset registry for `@kubb/plugin-client`.
- *
- * - `default` — uses `resolverClient` with v5 naming conventions.
- * - `kubbV4`  — uses `resolverClientLegacy` with backward-compatible naming.
- *
- * Note: Unlike plugin-ts/plugin-zod, generators are not defined here because
- * plugin-client selects generators dynamically based on `clientType`, `group`,
- * and `operations` options. Generator selection happens in `plugin.ts`.
- */
-export const presets = definePresets<ResolverClient>({
-  default: {
-    name: 'default',
-    resolver: resolverClient,
-  },
-  kubbV4: {
-    name: 'kubbV4',
-    resolver: resolverClientLegacy,
-  },
-})