@kubb/plugin-client 5.0.0-alpha.29 → 5.0.0-alpha.30

package/src/plugin.ts

@@ -1,10 +1,9 @@
 import path from 'node:path'
 import { camelCase } from '@internals/utils'
-import { walk } from '@kubb/ast'
-import type { OperationNode } from '@kubb/ast/types'
-import { createPlugin, type Group, getBarrelFiles, getPreset, runGeneratorOperation, runGeneratorOperations } from '@kubb/core'
+import { createPlugin, type Group, getPreset, mergeGenerators } 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'
@@ -42,10 +41,10 @@ export const pluginClient = createPlugin<PluginClient>((options) => {
   const {
     output = { path: 'clients', barrelType: 'named' },
     group,
-    urlType = false,
     exclude = [],
     include,
     override = [],
+    urlType = false,
     dataReturnType = 'data',
     paramsType = 'inline',
     pathParamsType = paramsType === 'object' ? 'object' : options.pathParamsType || 'inline',
@@ -81,11 +80,15 @@ export const pluginClient = createPlugin<PluginClient>((options) => {
     generators: selectedGenerators,
   })
 
+  const generators = preset.generators ?? []
+  const mergedGenerator = mergeGenerators(generators)
+
   let resolveNameWarning = false
   let resolvePathWarning = false
 
   return {
     name: pluginClientName,
+    version,
     get resolver() {
       return preset.resolver
     },
@@ -98,6 +101,9 @@ export const pluginClient = createPlugin<PluginClient>((options) => {
         clientType,
         bundle,
         output,
+        exclude,
+        include,
+        override,
         group: group
           ? ({
               ...group,
@@ -126,31 +132,32 @@ export const pluginClient = createPlugin<PluginClient>((options) => {
     pre: [pluginTsName, parser === 'zod' ? pluginZodName : undefined].filter(Boolean),
     resolvePath(baseName, pathMode, options) {
       if (!resolvePathWarning) {
-        this.events.emit('warn', 'Do not use resolvePath for pluginClient, use resolverClient.resolvePath instead')
+        this.warn('Do not use resolvePath for pluginClient, use resolverClient.resolvePath instead')
         resolvePathWarning = true
       }
 
       return this.plugin.resolver.resolvePath(
         { baseName, pathMode, tag: options?.group?.tag, path: options?.group?.path },
-        { root: path.resolve(this.config.root, this.config.output.path), output, group: this.plugin.options.group },
+        { root: this.root, output, group: this.plugin.options.group },
       )
     },
     resolveName(name, type) {
       if (!resolveNameWarning) {
-        this.events.emit('warn', 'Do not use resolveName for pluginClient, use resolverClient.default instead')
+        this.warn('Do not use resolveName for pluginClient, use resolverClient.default instead')
         resolveNameWarning = true
       }
 
       return this.plugin.resolver.default(name, type)
     },
-    async install() {
-      const { config, fabric, plugin, adapter, rootNode, driver } = this
-      const root = path.resolve(config.root, config.output.path)
-      const resolver = preset.resolver
-
-      if (!adapter) {
-        throw new Error('Plugin cannot work without adapter being set')
-      }
+    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
 
       // pre add bundled fetch
       if (bundle && !plugin.options.importPath) {
@@ -184,35 +191,6 @@ export const pluginClient = createPlugin<PluginClient>((options) => {
         imports: [],
         exports: [],
       })
-
-      const collectedOperations: Array<OperationNode> = []
-      const generatorContext = { generators: preset.generators, plugin, resolver, exclude, include, override, fabric, adapter, config, driver }
-
-      await walk(rootNode, {
-        depth: 'shallow',
-        async operation(operationNode) {
-          const baseOptions = resolver.resolveOptions(operationNode, { options: plugin.options, exclude, include, override })
-
-          if (baseOptions !== null) {
-            collectedOperations.push(operationNode)
-          }
-
-          await runGeneratorOperation(operationNode, generatorContext)
-        },
-      })
-
-      await runGeneratorOperations(collectedOperations, generatorContext)
-
-      const barrelFiles = await getBarrelFiles(this.fabric.files, {
-        type: output.barrelType ?? 'named',
-        root,
-        output,
-        meta: {
-          pluginName: this.plugin.name,
-        },
-      })
-
-      await this.upsertFile(...barrelFiles)
     },
   }
 })

package/src/types.ts

@@ -205,6 +205,9 @@ export type Options = {
 
 type ResolvedOptions = {
   output: Output
+  exclude: Array<Exclude>
+  include: Array<Include> | undefined
+  override: Array<Override<ResolvedOptions>>
   group: Group | undefined
   client: Options['client']
   clientType: NonNullable<Options['clientType']>
@@ -222,3 +225,11 @@ type ResolvedOptions = {
 }
 
 export type PluginClient = PluginFactoryOptions<'plugin-client', Options, ResolvedOptions, never, ResolvePathOptions, ResolverClient>
+
+declare global {
+  namespace Kubb {
+    interface PluginRegistry {
+      'plugin-client': PluginClient
+    }
+  }
+}