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

package/src/generators/classClientGenerator.tsx

@@ -1,261 +0,0 @@
-import path from 'node:path'
-import { getOperationParameters, 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, jsxRenderer } from '@kubb/renderer-jsx'
-import { ClassClient } from '../components/ClassClient'
-import { WrapperClient } from '../components/WrapperClient'
-import type { PluginClient } from '../types'
-import { isParserEnabled, resolveQueryParamsParser, resolveRequestParser, resolveResponseParser } from '../utils.ts'
-
-type OperationData = {
-  node: ast.OperationNode
-  name: string
-  tsResolver: ResolverTs
-  zodResolver: ResolverZod | null
-  typeFile: ast.FileNode
-  zodFile: ast.FileNode | null
-}
-
-type Controller = {
-  name: string
-  propertyName: 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, parser: PluginClient['resolvedOptions']['parser']): Array<string> {
-  const { query: queryParams } = getOperationParameters(node)
-  const names: Array<string | null | undefined> = [
-    resolveResponseParser(parser) === 'zod' ? zodResolver.resolveResponseName?.(node) : null,
-    resolveRequestParser(parser) === 'zod' && node.requestBody?.content?.[0]?.schema ? zodResolver.resolveDataName?.(node) : null,
-    resolveQueryParamsParser(parser) === 'zod' && queryParams.length > 0 ? zodResolver.resolveQueryParamsName?.(node, queryParams[0]!) : null,
-  ]
-  return names.filter((n): n is string => Boolean(n))
-}
-
-/**
- * Built-in `operations` generator for `@kubb/plugin-client` when
- * `clientType: 'class'`. Emits one class per tag, with one instance method
- * per operation and a shared constructor for request configuration.
- */
-export const classClientGenerator = defineGenerator<PluginClient>({
-  name: 'classClient',
-  renderer: jsxRenderer,
-  operations(nodes, ctx) {
-    const { config, driver, resolver, root } = ctx
-    const { output, group, dataReturnType, paramsCasing, paramsType, pathParamsType, parser, importPath, sdk } = 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 = isParserEnabled(parser) ? 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.resolveClassName('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, propertyName: resolver.resolveClientPropertyName(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, propertyName: resolver.resolveClientPropertyName(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, parser)
-        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 }
-    }
-
-    const files = controllers.map(({ name, file, operations: ops }) => {
-      const { typeImportsByFile, typeFilesByPath } = collectTypeImports(ops)
-      const { zodImportsByFile, zodFilesByPath } = isParserEnabled(parser)
-        ? 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')} />}
-
-          {parser === 'zod' && zodResolver && ops.some((op) => op.node.requestBody?.content?.[0]?.schema != null) && (
-            <File.Import name={['z']} path="zod" isTypeOnly />
-          )}
-
-          {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 />
-          })}
-
-          {isParserEnabled(parser) &&
-            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} />
-            })}
-
-          <ClassClient
-            name={name}
-            operations={ops}
-            baseURL={baseURL}
-            dataReturnType={dataReturnType}
-            pathParamsType={pathParamsType}
-            paramsCasing={paramsCasing}
-            paramsType={paramsType}
-            parser={parser}
-          />
-        </File>
-      )
-    })
-
-    if (sdk) {
-      const sdkFile = resolver.resolveFile({ name: sdk.className, extname: '.ts' }, { root, output, group: group ?? undefined })
-
-      files.push(
-        <File
-          key={sdkFile.path}
-          baseName={sdkFile.baseName}
-          path={sdkFile.path}
-          meta={sdkFile.meta}
-          banner={resolver.resolveBanner(ctx.meta, { output, config, file: { path: sdkFile.path, baseName: sdkFile.baseName } })}
-          footer={resolver.resolveFooter(ctx.meta, { output, config, file: { path: sdkFile.path, baseName: sdkFile.baseName } })}
-        >
-          {importPath ? (
-            <File.Import name={['Client', 'RequestConfig']} path={importPath} isTypeOnly />
-          ) : (
-            <File.Import name={['Client', 'RequestConfig']} root={sdkFile.path} path={path.resolve(root, '.kubb/client.ts')} isTypeOnly />
-          )}
-
-          {controllers.map(({ name, file }) => (
-            <File.Import key={name} name={[name]} root={sdkFile.path} path={file.path} />
-          ))}
-
-          <WrapperClient name={sdk.className} controllers={controllers.map(({ name, propertyName }) => ({ className: name, propertyName }))} />
-        </File>,
-      )
-    }
-
-    return <>{files}</>
-  },
-})

package/src/generators/clientGenerator.tsx

@@ -1,135 +0,0 @@
-import path from 'node:path'
-import { getOperationParameters, operationFileEntry, resolveOperationTypeNames } from '@internals/shared'
-import { ast, defineGenerator } from '@kubb/core'
-import { pluginTsName } from '@kubb/plugin-ts'
-import { pluginZodName } from '@kubb/plugin-zod'
-import { File, jsxRenderer } from '@kubb/renderer-jsx'
-import { Client } from '../components/Client'
-import { Url } from '../components/Url.tsx'
-import type { PluginClient } from '../types'
-import { isParserEnabled, resolveQueryParamsParser, resolveRequestParser, resolveResponseParser } from '../utils.ts'
-
-/**
- * Built-in operation generator for `@kubb/plugin-client`. Emits one async
- * function per OpenAPI operation, plus the matching URL helper. Used when
- * `clientType: 'function'` (the default).
- */
-export const clientGenerator = defineGenerator<PluginClient>({
-  name: 'client',
-  renderer: jsxRenderer,
-  operation(node, ctx) {
-    if (!ast.isHttpOperationNode(node)) return null
-    const { config, driver, resolver, root } = ctx
-    const { output, urlType, dataReturnType, paramsCasing, paramsType, pathParamsType, parser, importPath, group } = 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 pluginZod = isParserEnabled(parser) ? driver.getPlugin(pluginZodName) : null
-    const zodResolver = pluginZod ? driver.getResolver(pluginZodName) : null
-
-    const importedTypeNames = resolveOperationTypeNames(node, tsResolver, { paramsCasing })
-
-    const { query: queryParams } = getOperationParameters(node)
-
-    const importedZodNames = zodResolver
-      ? [
-          resolveResponseParser(parser) === 'zod' ? zodResolver.resolveResponseName?.(node) : null,
-          resolveRequestParser(parser) === 'zod' && node.requestBody?.content?.[0]?.schema ? zodResolver.resolveDataName?.(node) : null,
-          resolveQueryParamsParser(parser) === 'zod' && queryParams.length > 0 ? zodResolver.resolveQueryParamsName?.(node, queryParams[0]!) : null,
-        ].filter((name): name is string => Boolean(name))
-      : []
-
-    const zodRequestName = zodResolver && parser === 'zod' && node.requestBody?.content?.[0]?.schema ? (zodResolver.resolveDataName?.(node) ?? null) : null
-
-    const meta = {
-      name: resolver.resolveName(node.operationId),
-      urlName: resolver.resolveUrlName(node),
-      file: resolver.resolveFile(operationFileEntry(node, node.operationId), { root, output, group: group ?? undefined }),
-      fileTs: tsResolver.resolveFile(operationFileEntry(node, node.operationId), {
-        root,
-        output: pluginTs.options?.output ?? output,
-        group: pluginTs.options?.group ?? undefined,
-      }),
-      fileZod:
-        zodResolver && pluginZod?.options
-          ? zodResolver.resolveFile(operationFileEntry(node, node.operationId), {
-              root,
-              output: pluginZod.options.output ?? output,
-              group: pluginZod.options?.group ?? undefined,
-            })
-          : null,
-    } as const
-
-    const hasFormData = node.requestBody?.content?.some((e) => e.contentType === 'multipart/form-data') ?? false
-
-    return (
-      <File
-        baseName={meta.file.baseName}
-        path={meta.file.path}
-        meta={meta.file.meta}
-        banner={resolver.resolveBanner(ctx.meta, { output, config, file: { path: meta.file.path, baseName: meta.file.baseName } })}
-        footer={resolver.resolveFooter(ctx.meta, { output, config, file: { path: meta.file.path, baseName: meta.file.baseName } })}
-      >
-        {importPath ? (
-          <>
-            <File.Import name={'client'} path={importPath} />
-            <File.Import name={['Client', 'RequestConfig', 'ResponseErrorConfig']} path={importPath} isTypeOnly />
-          </>
-        ) : (
-          <>
-            <File.Import name={['client']} root={meta.file.path} path={path.resolve(root, '.kubb/client.ts')} />
-            <File.Import
-              name={['Client', 'RequestConfig', 'ResponseErrorConfig']}
-              root={meta.file.path}
-              path={path.resolve(root, '.kubb/client.ts')}
-              isTypeOnly
-            />
-          </>
-        )}
-
-        {hasFormData && <File.Import name={['buildFormData']} root={meta.file.path} path={path.resolve(root, '.kubb/config.ts')} />}
-
-        {zodRequestName && <File.Import name={['z']} path="zod" isTypeOnly />}
-
-        {meta.fileZod && importedZodNames.length > 0 && <File.Import name={importedZodNames as Array<string>} root={meta.file.path} path={meta.fileZod.path} />}
-
-        {meta.fileTs && importedTypeNames.length > 0 && (
-          <File.Import name={Array.from(new Set(importedTypeNames))} root={meta.file.path} path={meta.fileTs.path} isTypeOnly />
-        )}
-
-        <Url
-          name={meta.urlName}
-          baseURL={baseURL}
-          pathParamsType={pathParamsType}
-          paramsCasing={paramsCasing}
-          paramsType={paramsType}
-          node={node}
-          tsResolver={tsResolver}
-          isIndexable={urlType === 'export'}
-          isExportable={urlType === 'export'}
-        />
-
-        <Client
-          name={meta.name}
-          urlName={meta.urlName}
-          baseURL={baseURL}
-          dataReturnType={dataReturnType}
-          pathParamsType={pathParamsType}
-          paramsCasing={paramsCasing}
-          paramsType={paramsType}
-          node={node}
-          tsResolver={tsResolver}
-          zodResolver={zodResolver}
-          parser={parser}
-        />
-      </File>
-    )
-  },
-})

package/src/generators/groupedClientGenerator.tsx

@@ -1,82 +0,0 @@
-import { camelCase } from '@internals/utils'
-import type { ast } from '@kubb/core'
-import { defineGenerator } from '@kubb/core'
-import { File, Function, jsxRenderer } from '@kubb/renderer-jsx'
-import type { PluginClient } from '../types'
-
-/**
- * Emits one aggregate file per tag/group when `group` is configured. Each
- * file re-exports every client function for that group, so callers can
- * `import { petController } from './gen/clients'` instead of importing
- * each operation individually.
- */
-export const groupedClientGenerator = defineGenerator<PluginClient>({
-  name: 'groupedClient',
-  renderer: jsxRenderer,
-  operations(nodes, ctx) {
-    const { config, resolver, root } = ctx
-    const { output, group } = ctx.options
-
-    const controllers = nodes.reduce(
-      (acc, operationNode) => {
-        if (group?.type === 'tag') {
-          const tag = operationNode.tags[0]
-          const name = tag ? group?.name?.({ group: camelCase(tag) }) : null
-
-          if (!tag || !name) {
-            return acc
-          }
-
-          const file = resolver.resolveFile({ name, extname: '.ts', tag }, { root, output, group: group ?? undefined })
-          const clientFile = resolver.resolveFile(
-            { name: operationNode.operationId, extname: '.ts', tag: operationNode.tags[0] ?? 'default', path: operationNode.path },
-            { root, output, group: group ?? undefined },
-          )
-
-          const client = {
-            name: resolver.resolveName(operationNode.operationId),
-            file: clientFile,
-          }
-
-          const previous = acc.find((item) => item.file.path === file.path)
-
-          if (previous) {
-            previous.clients.push(client)
-          } else {
-            acc.push({ name, file, clients: [client] })
-          }
-        }
-
-        return acc
-      },
-      [] as Array<{ name: string; file: ast.FileNode; clients: Array<{ name: string; file: ast.FileNode }> }>,
-    )
-
-    return (
-      <>
-        {controllers.map(({ name, file, clients }) => {
-          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, isAggregation: true } })}
-              footer={resolver.resolveFooter(ctx.meta, { output, config, file: { path: file.path, baseName: file.baseName, isAggregation: true } })}
-            >
-              {clients.map((client) => (
-                <File.Import key={client.name} name={[client.name]} root={file.path} path={client.file.path} />
-              ))}
-
-              <File.Source name={name} isExportable isIndexable>
-                <Function export name={name}>
-                  {`return { ${clients.map((client) => client.name).join(', ')} }`}
-                </Function>
-              </File.Source>
-            </File>
-          )
-        })}
-      </>
-    )
-  },
-})

package/src/generators/operationsGenerator.ts

@@ -1,47 +0,0 @@
-import { Url } from '@internals/utils'
-import { ast, defineGenerator } from '@kubb/core'
-import type { PluginClient } from '../types'
-
-/**
- * Generates an `operations.ts` file that re-exports every operation grouped
- * by HTTP method. Enabled when `pluginClient({ operations: true })`. Useful
- * for building meta-tooling on top of the generated client (route
- * registries, API explorers).
- */
-export const operationsGenerator = defineGenerator<PluginClient>({
-  name: 'client',
-  operations(nodes, ctx) {
-    const { config, resolver, root } = ctx
-    const { output, group } = ctx.options
-
-    const name = 'operations'
-    const file = resolver.resolveFile({ name, extname: '.ts' }, { root, output, group: group ?? undefined })
-
-    const operationsObject: Record<string, { path: string; method: string }> = {}
-    for (const node of nodes) {
-      if (!ast.isHttpOperationNode(node)) continue
-      operationsObject[node.operationId] = {
-        path: Url.toPath(node.path),
-        method: node.method.toLowerCase(),
-      }
-    }
-
-    return [
-      ast.createFile({
-        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 } }),
-        sources: [
-          ast.createSource({
-            name,
-            isExportable: true,
-            isIndexable: true,
-            nodes: [ast.createConst({ name, export: true, nodes: [ast.createText(JSON.stringify(operationsObject, undefined, 2))] })],
-          }),
-        ],
-      }),
-    ]
-  },
-})