@kubb/plugin-client 5.0.0-beta.42 → 5.0.0-beta.64

package/src/generators/staticClassClientGenerator.tsx

@@ -1,232 +0,0 @@
-import path from 'node:path'
-import { operationFileEntry, resolveOperationTypeNames } from '@internals/shared'
-import { camelCase } from '@internals/utils'
-import { ast, defineGenerator } from '@kubb/core'
-import type { ResolverTs } from '@kubb/plugin-ts'
-import { pluginTsName } from '@kubb/plugin-ts'
-import type { ResolverZod } from '@kubb/plugin-zod'
-import { pluginZodName } from '@kubb/plugin-zod'
-import { File, jsxRendererSync } from '@kubb/renderer-jsx'
-import { StaticClassClient } from '../components/StaticClassClient'
-import type { PluginClient } from '../types'
-
-type OperationData = {
-  node: ast.OperationNode
-  name: string
-  tsResolver: ResolverTs
-  zodResolver: ResolverZod | null
-  typeFile: ast.FileNode
-  zodFile: ast.FileNode | null
-}
-
-type Controller = {
-  name: string
-  file: ast.FileNode
-  operations: Array<OperationData>
-}
-
-function resolveTypeImportNames(node: ast.OperationNode, tsResolver: ResolverTs): Array<string> {
-  return resolveOperationTypeNames(node, tsResolver, { order: 'body-response-first' })
-}
-
-function resolveZodImportNames(node: ast.OperationNode, zodResolver: ResolverZod): Array<string> {
-  const names: Array<string | null | undefined> = [
-    zodResolver.resolveResponseName?.(node),
-    node.requestBody?.content?.[0]?.schema ? zodResolver.resolveDataName?.(node) : null,
-  ]
-  return names.filter((n): n is string => Boolean(n))
-}
-
-/**
- * Built-in `operations` generator for `@kubb/plugin-client` when
- * `clientType: 'staticClass'`. Emits one class per tag, with a static method
- * per operation so callers can use `Pet.getPetById(...)` without
- * instantiating the class.
- */
-export const staticClassClientGenerator = defineGenerator<PluginClient>({
-  name: 'staticClassClient',
-  renderer: jsxRendererSync,
-  operations(nodes, ctx) {
-    const { config, driver, resolver, root } = ctx
-    const { output, group, dataReturnType, paramsCasing, paramsType, pathParamsType, parser, importPath } = ctx.options
-    const baseURL = ctx.options.baseURL ?? ctx.meta.baseURL
-
-    const pluginTs = driver.getPlugin(pluginTsName)
-    if (!pluginTs) return null
-
-    const tsResolver = driver.getResolver(pluginTsName)
-    const tsPluginOptions = pluginTs.options
-    const pluginZod = parser === 'zod' ? driver.getPlugin(pluginZodName) : null
-    const zodResolver = pluginZod ? driver.getResolver(pluginZodName) : null
-
-    function buildOperationData(node: ast.OperationNode): OperationData {
-      const typeFile = tsResolver.resolveFile(operationFileEntry(node, node.operationId), {
-        root,
-        output: tsPluginOptions?.output ?? output,
-        group: tsPluginOptions?.group,
-      })
-      const zodFile =
-        zodResolver && pluginZod?.options
-          ? zodResolver.resolveFile(operationFileEntry(node, node.operationId), {
-              root,
-              output: pluginZod.options?.output ?? output,
-              group: pluginZod.options?.group ?? undefined,
-            })
-          : null
-
-      return {
-        node: node,
-        name: resolver.resolveName(node.operationId),
-        tsResolver,
-        zodResolver,
-        typeFile,
-        zodFile,
-      }
-    }
-
-    const controllers = nodes.reduce((acc, operationNode) => {
-      if (!ast.isHttpOperationNode(operationNode)) return acc
-      const tag = operationNode.tags[0]
-      const groupName = tag ? (group?.name?.({ group: camelCase(tag) }) ?? resolver.resolveGroupName(tag)) : resolver.resolveGroupName('Client')
-
-      if (!tag && !group) {
-        const name = resolver.resolveClassName('ApiClient')
-        const file = resolver.resolveFile({ name, extname: '.ts' }, { root, output, group: group ?? undefined })
-        const operationData = buildOperationData(operationNode)
-        const previous = acc.find((item) => item.file.path === file.path)
-
-        if (previous) {
-          previous.operations.push(operationData)
-        } else {
-          acc.push({ name, file, operations: [operationData] })
-        }
-        return acc
-      }
-
-      if (tag) {
-        const name = groupName
-        const file = resolver.resolveFile({ name, extname: '.ts', tag }, { root, output, group: group ?? undefined })
-        const operationData = buildOperationData(operationNode)
-        const previous = acc.find((item) => item.file.path === file.path)
-
-        if (previous) {
-          previous.operations.push(operationData)
-        } else {
-          acc.push({ name, file, operations: [operationData] })
-        }
-      }
-
-      return acc
-    }, [] as Array<Controller>)
-
-    function collectTypeImports(ops: Array<OperationData>) {
-      const typeImportsByFile = new Map<string, Set<string>>()
-      const typeFilesByPath = new Map<string, ast.FileNode>()
-
-      ops.forEach((op) => {
-        const names = resolveTypeImportNames(op.node, tsResolver)
-        if (!typeImportsByFile.has(op.typeFile.path)) {
-          typeImportsByFile.set(op.typeFile.path, new Set())
-        }
-        const imports = typeImportsByFile.get(op.typeFile.path)!
-        names.forEach((n) => {
-          imports.add(n)
-        })
-        typeFilesByPath.set(op.typeFile.path, op.typeFile)
-      })
-
-      return { typeImportsByFile, typeFilesByPath }
-    }
-
-    function collectZodImports(ops: Array<OperationData>) {
-      const zodImportsByFile = new Map<string, Set<string>>()
-      const zodFilesByPath = new Map<string, ast.FileNode>()
-
-      ops.forEach((op) => {
-        if (!op.zodFile || !zodResolver) return
-        const names = resolveZodImportNames(op.node, zodResolver)
-        if (!zodImportsByFile.has(op.zodFile.path)) {
-          zodImportsByFile.set(op.zodFile.path, new Set())
-        }
-        const imports = zodImportsByFile.get(op.zodFile.path)!
-        names.forEach((n) => {
-          imports.add(n)
-        })
-        zodFilesByPath.set(op.zodFile.path, op.zodFile)
-      })
-
-      return { zodImportsByFile, zodFilesByPath }
-    }
-
-    return (
-      <>
-        {controllers.map(({ name, file, operations: ops }) => {
-          const { typeImportsByFile, typeFilesByPath } = collectTypeImports(ops)
-          const { zodImportsByFile, zodFilesByPath } =
-            parser === 'zod' ? collectZodImports(ops) : { zodImportsByFile: new Map<string, Set<string>>(), zodFilesByPath: new Map<string, ast.FileNode>() }
-          const hasFormData = ops.some((op) => op.node.requestBody?.content?.some((e) => e.contentType === 'multipart/form-data') ?? false)
-
-          return (
-            <File
-              key={file.path}
-              baseName={file.baseName}
-              path={file.path}
-              meta={file.meta}
-              banner={resolver.resolveBanner(ctx.meta, { output, config, file: { path: file.path, baseName: file.baseName } })}
-              footer={resolver.resolveFooter(ctx.meta, { output, config, file: { path: file.path, baseName: file.baseName } })}
-            >
-              {importPath ? (
-                <>
-                  <File.Import name={'client'} path={importPath} />
-                  <File.Import name={['mergeConfig']} path={importPath} />
-                  <File.Import name={['Client', 'RequestConfig', 'ResponseErrorConfig']} path={importPath} isTypeOnly />
-                </>
-              ) : (
-                <>
-                  <File.Import name={['client']} root={file.path} path={path.resolve(root, '.kubb/client.ts')} />
-                  <File.Import name={['mergeConfig']} root={file.path} path={path.resolve(root, '.kubb/client.ts')} />
-                  <File.Import
-                    name={['Client', 'RequestConfig', 'ResponseErrorConfig']}
-                    root={file.path}
-                    path={path.resolve(root, '.kubb/client.ts')}
-                    isTypeOnly
-                  />
-                </>
-              )}
-
-              {hasFormData && <File.Import name={['buildFormData']} root={file.path} path={path.resolve(root, '.kubb/config.ts')} />}
-
-              {Array.from(typeImportsByFile.entries()).map(([filePath, importSet]) => {
-                const typeFile = typeFilesByPath.get(filePath)
-                if (!typeFile) return null
-                const importNames = Array.from(importSet).filter(Boolean)
-                if (importNames.length === 0) return null
-                return <File.Import key={filePath} name={importNames} root={file.path} path={typeFile.path} isTypeOnly />
-              })}
-
-              {parser === 'zod' &&
-                Array.from(zodImportsByFile.entries()).map(([filePath, importSet]) => {
-                  const zodFile = zodFilesByPath.get(filePath)
-                  if (!zodFile) return null
-                  const importNames = Array.from(importSet).filter(Boolean)
-                  if (importNames.length === 0) return null
-                  return <File.Import key={filePath} name={importNames} root={file.path} path={zodFile.path} />
-                })}
-
-              <StaticClassClient
-                name={name}
-                operations={ops}
-                baseURL={baseURL}
-                dataReturnType={dataReturnType}
-                pathParamsType={pathParamsType}
-                paramsCasing={paramsCasing}
-                paramsType={paramsType}
-                parser={parser}
-              />
-            </File>
-          )
-        })}
-      </>
-    )
-  },
-})

package/src/index.ts

@@ -1,9 +0,0 @@
-export { Client } from './components/Client.tsx'
-export { classClientGenerator } from './generators/classClientGenerator.tsx'
-export { clientGenerator } from './generators/clientGenerator.tsx'
-export { groupedClientGenerator } from './generators/groupedClientGenerator.tsx'
-export { operationsGenerator } from './generators/operationsGenerator.tsx'
-export { staticClassClientGenerator } from './generators/staticClassClientGenerator.tsx'
-export { default, pluginClient, pluginClientName } from './plugin.ts'
-export { resolverClient } from './resolvers/resolverClient.ts'
-export type { ClientImportPath, PluginClient, ResolverClient } from './types.ts'

package/src/plugin.ts

@@ -1,160 +0,0 @@
-import path from 'node:path'
-import { createGroupConfig } from '@internals/shared'
-
-import { ast, definePlugin } from '@kubb/core'
-import { pluginTsName } from '@kubb/plugin-ts'
-import { pluginZodName } from '@kubb/plugin-zod'
-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 { resolverClient } from './resolvers/resolverClient.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'
-import type { PluginClient } from './types.ts'
-
-/**
- * Canonical plugin name for `@kubb/plugin-client`. Used for driver lookups and
- * cross-plugin dependency references.
- */
-export const pluginClientName = 'plugin-client' satisfies PluginClient['name']
-
-/**
- * Generates one HTTP client function per OpenAPI operation. Each function has
- * typed path params, query params, body, and response, so callers use the API
- * like any other typed function. Ships with `axios` and `fetch` runtimes; bring
- * your own by setting `importPath`.
- *
- * @example
- * ```ts
- * import { defineConfig } from 'kubb'
- * import { pluginTs } from '@kubb/plugin-ts'
- * import { pluginClient } from '@kubb/plugin-client'
- *
- * export default defineConfig({
- *   input: { path: './petStore.yaml' },
- *   output: { path: './src/gen' },
- *   plugins: [
- *     pluginTs(),
- *     pluginClient({
- *       output: { path: './clients' },
- *       client: 'fetch',
- *     }),
- *   ],
- * })
- * ```
- */
-export const pluginClient = definePlugin<PluginClient>((options) => {
-  const {
-    output = { path: 'clients', barrelType: 'named' },
-    group,
-    exclude = [],
-    include,
-    override = [],
-    urlType = false,
-    dataReturnType = 'data',
-    paramsType = 'inline',
-    pathParamsType = paramsType === 'object' ? 'object' : options.pathParamsType || 'inline',
-    operations = false,
-    paramsCasing,
-    clientType = options.sdk ? 'class' : 'function',
-    parser = false,
-    client = 'axios',
-    importPath,
-    bundle = false,
-    sdk,
-    baseURL,
-    resolver: userResolver,
-    transformer: userTransformer,
-  } = options
-
-  const resolvedImportPath = importPath ?? (!bundle ? `@kubb/plugin-client/clients/${client}` : undefined)
-
-  const selectedGenerators =
-    options.generators ??
-    [
-      clientType === 'staticClass' ? staticClassClientGenerator : clientType === 'class' ? classClientGenerator : clientGenerator,
-      group && clientType === 'function' ? groupedClientGenerator : null,
-      operations ? operationsGenerator : null,
-    ].filter((x): x is NonNullable<typeof x> => Boolean(x))
-
-  const groupConfig = createGroupConfig(group, { suffix: 'Controller' })
-
-  return {
-    name: pluginClientName,
-    options,
-    dependencies: [pluginTsName, parser === 'zod' ? pluginZodName : null].filter((dependency): dependency is string => Boolean(dependency)),
-    hooks: {
-      'kubb:plugin:setup'(ctx) {
-        const resolver = userResolver ? { ...resolverClient, ...userResolver } : resolverClient
-
-        ctx.setOptions({
-          client,
-          clientType,
-          bundle,
-          output,
-          exclude,
-          include,
-          override,
-          group: groupConfig,
-          parser,
-          dataReturnType,
-          importPath: resolvedImportPath,
-          baseURL,
-          paramsType,
-          paramsCasing,
-          pathParamsType,
-          urlType,
-          sdk,
-          resolver,
-        })
-        ctx.setResolver(resolver)
-        if (userTransformer) {
-          ctx.setTransformer(userTransformer)
-        }
-        for (const gen of selectedGenerators) {
-          ctx.addGenerator(gen)
-        }
-
-        const root = path.resolve(ctx.config.root, ctx.config.output.path)
-
-        const isRelativePath = resolvedImportPath?.startsWith('.')
-
-        if (!isRelativePath) {
-          const isInlineSource = bundle && !resolvedImportPath
-
-          ctx.injectFile({
-            baseName: 'client.ts',
-            path: path.resolve(root, '.kubb/client.ts'),
-            sources: [
-              ast.createSource({
-                name: 'client',
-                nodes: isInlineSource ? [ast.createText(client === 'fetch' ? fetchClientSource : axiosClientSource)] : [],
-                isExportable: true,
-                isIndexable: true,
-              }),
-            ],
-            exports: !isInlineSource && resolvedImportPath ? [ast.createExport({ path: resolvedImportPath })] : [],
-          })
-        }
-
-        ctx.injectFile({
-          baseName: 'config.ts',
-          path: path.resolve(root, '.kubb/config.ts'),
-          sources: [
-            ast.createSource({
-              name: 'config',
-              nodes: [ast.createText(configSource)],
-              isExportable: false,
-              isIndexable: false,
-            }),
-          ],
-        })
-      },
-    },
-  }
-})
-
-export default pluginClient

package/src/resolvers/resolverClient.ts

@@ -1,45 +0,0 @@
-import { camelCase, ensureValidVarName, pascalCase } from '@internals/utils'
-import { defineResolver } from '@kubb/core'
-import type { PluginClient } from '../types.ts'
-
-/**
- * Default resolver used by `@kubb/plugin-client`. Decides the names and file
- * paths for every generated client function or class. Functions and files use
- * camelCase; classes and tag groups use PascalCase.
- *
- * @example Resolve client function and class names
- * ```ts
- * import { resolverClient } from '@kubb/plugin-client'
- *
- * resolverClient.default('list pets', 'function') // 'listPets'
- * resolverClient.resolveClassName('pet')          // 'Pet'
- * resolverClient.resolveUrlName(operationNode)    // 'getShowPetByIdUrl'
- * ```
- */
-export const resolverClient = defineResolver<PluginClient>(() => ({
-  name: 'default',
-  pluginName: 'plugin-client',
-  default(name, type) {
-    const resolved = camelCase(name, { isFile: type === 'file' })
-    return type === 'file' ? resolved : ensureValidVarName(resolved)
-  },
-  resolveName(name) {
-    return this.default(name, 'function')
-  },
-  resolvePathName(name, type) {
-    return this.default(name, type)
-  },
-  resolveClassName(name) {
-    return ensureValidVarName(pascalCase(name))
-  },
-  resolveGroupName(name) {
-    return ensureValidVarName(pascalCase(name))
-  },
-  resolveClientPropertyName(name) {
-    return ensureValidVarName(camelCase(name))
-  },
-  resolveUrlName(node) {
-    const name = this.resolveName(node.operationId)
-    return `get${name.charAt(0).toUpperCase()}${name.slice(1)}Url`
-  },
-}))

package/src/templates/clients/axios.source.ts

@@ -1,4 +0,0 @@
-// @ts-expect-error - import attributes are handled at build time by importAttributeTextPlugin
-import content from '../../../templates/clients/axios.ts' with { type: 'text' }
-
-export const source = content as string

package/src/templates/clients/fetch.source.ts

@@ -1,4 +0,0 @@
-// @ts-expect-error - import attributes are handled at build time by importAttributeTextPlugin
-import content from '../../../templates/clients/fetch.ts' with { type: 'text' }
-
-export const source = content as string

package/src/templates/config.source.ts

@@ -1,4 +0,0 @@
-// @ts-expect-error - import attributes are handled at build time by importAttributeTextPlugin
-import content from '../../templates/config.ts' with { type: 'text' }
-
-export const source = content as string