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

package/package.json

@@ -1,19 +1,17 @@
 {
   "name": "@kubb/plugin-client",
-  "version": "5.0.0-beta.56",
-  "description": "Generate type-safe HTTP clients from your OpenAPI specification. Supports Axios, Fetch, and custom client adapters with full TypeScript inference and zero boilerplate.",
+  "version": "5.5.2",
+  "description": "Generate typed API operations against your own client module.",
   "keywords": [
     "api-client",
-    "axios",
     "code-generation",
-    "codegen",
-    "fetch",
     "http-client",
     "kubb",
     "openapi",
     "swagger",
     "typescript"
   ],
+  "homepage": "https://kubb.dev/plugins/plugin-client",
   "license": "MIT",
   "author": "stijnvanhulle",
   "repository": {
@@ -24,8 +22,6 @@
   "files": [
     "src",
     "dist",
-    "*.d.ts",
-    "*.d.cts",
     "!/**/**.test.**",
     "!/**/__tests__/**",
     "!/**/__snapshots__/**"
@@ -35,50 +31,12 @@
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
-  "typesVersions": {
-    "*": {
-      "clients/axios": [
-        "./dist/clients/axios.d.ts"
-      ],
-      "clients/fetch": [
-        "./dist/clients/fetch.d.ts"
-      ],
-      "templates/config.source": [
-        "./dist/templates/config.source.d.ts"
-      ],
-      "templates/clients/axios.source": [
-        "./dist/templates/clients/axios.source.d.ts"
-      ],
-      "templates/clients/fetch.source": [
-        "./dist/templates/clients/fetch.source.d.ts"
-      ]
-    }
-  },
   "exports": {
     ".": {
+      "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
       "require": "./dist/index.cjs"
     },
-    "./clients/axios": {
-      "import": "./dist/clients/axios.js",
-      "require": "./dist/clients/axios.cjs"
-    },
-    "./clients/fetch": {
-      "import": "./dist/clients/fetch.js",
-      "require": "./dist/clients/fetch.cjs"
-    },
-    "./templates/clients/axios.source": {
-      "import": "./dist/templates/clients/axios.source.js",
-      "require": "./dist/templates/clients/axios.source.cjs"
-    },
-    "./templates/clients/fetch.source": {
-      "import": "./dist/templates/clients/fetch.source.js",
-      "require": "./dist/templates/clients/fetch.source.cjs"
-    },
-    "./templates/config.source": {
-      "import": "./dist/templates/config.source.js",
-      "require": "./dist/templates/config.source.cjs"
-    },
     "./package.json": "./package.json"
   },
   "publishConfig": {
@@ -86,25 +44,17 @@
     "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
-    "@kubb/ast": "5.0.0-beta.55",
-    "@kubb/core": "5.0.0-beta.55",
-    "@kubb/renderer-jsx": "5.0.0-beta.55",
-    "@kubb/plugin-ts": "5.0.0-beta.56",
-    "@kubb/plugin-zod": "5.0.0-beta.56"
+    "@kubb/plugin-ts": "^5.0.2",
+    "@kubb/plugin-zod": "^5.4.1"
   },
   "devDependencies": {
-    "axios": "^1.17.0",
+    "@internals/client": "0.0.0",
     "@internals/shared": "0.0.0",
-    "@internals/utils": "0.0.0"
+    "kubb": "^5.4.0",
+    "typescript": "^6.0.3"
   },
   "peerDependencies": {
-    "@kubb/renderer-jsx": "5.0.0-beta.55",
-    "axios": "^1.7.2"
-  },
-  "peerDependenciesMeta": {
-    "axios": {
-      "optional": true
-    }
+    "kubb": "^5.4.0"
   },
   "engines": {
     "node": ">=22"
@@ -114,9 +64,6 @@
     "clean": "node -e \"require('node:fs').rmSync('./dist', {recursive:true,force:true})\"",
     "lint": "oxlint .",
     "lint:fix": "oxlint --fix .",
-    "release": "pnpm publish --no-git-check",
-    "release:canary": "bash ../../.github/canary.sh && node ../../scripts/build.js canary && pnpm publish --no-git-check",
-    "release:stage": "pnpm stage publish --no-git-check",
     "start": "tsdown --watch",
     "test": "vitest --passWithNoTests",
     "typecheck": "tsc -p ./tsconfig.json --noEmit --emitDeclarationOnly false"

package/src/generators/clientGenerator.tsx

@@ -1,135 +1,9 @@
-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'
+import { createClientGenerator } from '@internals/client'
+import type { PluginClient } from '../types.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).
+ * Built-in operation generator for `@kubb/plugin-client`. Emits one async function per OpenAPI
+ * operation using the shared `Operation` component: a grouped `<Name>Request` type and a function
+ * that forwards a single `options` object to the user-provided client module and returns the `RequestResult`.
  */
-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>
-    )
-  },
-})
+export const clientGenerator = createClientGenerator<PluginClient>('client', (options) => options.importPath)

package/src/index.ts

@@ -1,10 +1,2 @@
-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.ts'
-export { staticClassClientGenerator } from './generators/staticClassClientGenerator.tsx'
 export { default, pluginClient, pluginClientName } from './plugin.ts'
-export { resolverClient } from './resolvers/resolverClient.ts'
-export { isParserEnabled, resolveQueryParamsParser, resolveRequestParser, resolveResponseParser } from './utils.ts'
-export type { ClientImportPath, PluginClient, ResolverClient } from './types.ts'
+export type { Options, PluginClient, ResolvedOptions, ResolverClient } from './types.ts'

package/src/plugin.ts

@@ -1,158 +1,68 @@
-import path from 'node:path'
 import { createGroupConfig } from '@internals/shared'
-
-import { ast, definePlugin } from '@kubb/core'
+import { definePlugin, Resolver } from 'kubb/kit'
 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.ts'
-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'
-import { isParserEnabled } from './utils.ts'
+import { defaultMacros, resolverClient } from '@internals/client'
+import type { PluginClient, ResolvedOptions, ResolverClient } from './types.ts'
 
 /**
- * Canonical plugin name for `@kubb/plugin-client`. Used for driver lookups and
- * cross-plugin dependency references.
+ * Canonical plugin name for `@kubb/plugin-client`.
  */
 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`.
+ * Generates typed operations that call a client module owned by your application.
+ * The module at `importPath` must export the runtime helpers and types used by generated operations.
+ * Kubb does not copy or inject a transport implementation.
  *
  * @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',
- *     }),
- *   ],
- * })
+ * pluginClient({ importPath: '../api/client' })
  * ```
  */
 export const pluginClient = definePlugin<PluginClient>((options) => {
   const {
     output = { path: 'clients', barrel: { type: '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,
+    throwOnErrorDefault = true,
+    validator = false,
+    group,
     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)
+  const resolved: ResolvedOptions = {
+    output,
+    exclude,
+    include,
+    override,
+    group: createGroupConfig(group),
+    importPath,
+    baseURL: undefined,
+    throwOnErrorDefault,
+    validator,
+    returnType: 'plain',
+    sdk: undefined,
+    resolver: userResolver ? Resolver.merge<ResolverClient>(resolverClient, userResolver) : resolverClient,
+  }
 
   return {
     name: pluginClientName,
     options,
-    dependencies: [pluginTsName, isParserEnabled(parser) ? pluginZodName : null].filter((dependency): dependency is string => Boolean(dependency)),
+    dependencies: [pluginTsName, pluginZodName],
     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 })] : [],
-          })
+        if (validator && !ctx.config.plugins?.some((plugin) => plugin.name === pluginZodName)) {
+          throw new Error(`${pluginClientName}: \`validator\` needs ${pluginZodName}. Add pluginZod() to the plugins or set \`validator: false\`.`)
         }
 
-        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,
-            }),
-          ],
-        })
+        ctx.setOptions(resolved)
+        ctx.setResolver(resolved.resolver)
+        ctx.setMacros([...defaultMacros, ...(options.macros ?? [])])
+        ctx.addGenerator(clientGenerator)
       },
     },
   }