@kubb/plugin-mcp 5.0.0-beta.4 → 5.0.0-beta.42

package/src/types.ts

@@ -6,54 +6,68 @@ import type { ClientImportPath, PluginClient } from '@kubb/plugin-client'
  */
 export type ResolverMcp = Resolver & {
   /**
-   * Resolves the handler function name for an operation.
+   * Resolves the base handler function name for an operation.
    *
    * @example Resolving handler function names
    * `resolver.resolveName('show pet by id') // -> 'showPetByIdHandler'`
    */
   resolveName(this: ResolverMcp, name: string): string
+  /**
+   * Resolves the output file name for an MCP module.
+   */
+  resolvePathName(this: ResolverMcp, name: string, type?: 'file' | 'function' | 'type' | 'const'): string
+  /**
+   * Resolves the handler function name for an operation.
+   */
+  resolveHandlerName(this: ResolverMcp, node: ast.OperationNode): string
 }
 
 export type Options = {
   /**
-   * Specify the export location for the files and define the behavior of the output.
-   * @default { path: 'mcp', barrelType: 'named' }
+   * Where the generated MCP tool handlers are written and how they are exported.
+   *
+   * @default { path: 'mcp', barrel: { type: 'named' } }
    */
   output?: Output
   /**
-   * Client configuration for HTTP request generation.
+   * HTTP client used by each MCP handler to call the underlying API. Mirrors a
+   * subset of `pluginClient` options.
    */
   client?: ClientImportPath & Pick<PluginClient['options'], 'clientType' | 'dataReturnType' | 'baseURL' | 'bundle' | 'paramsCasing'>
   /**
-   * Apply casing to parameter names to match your configuration.
+   * Rename parameter properties in the generated handlers. The HTTP layer still
+   * uses the original spec names; Kubb writes the mapping for you.
+   *
+   * @note Must match the value of `paramsCasing` on `@kubb/plugin-ts`.
    */
   paramsCasing?: 'camelcase'
   /**
-   * Group the MCP requests based on the provided name.
+   * Split generated files into subfolders based on the operation's tag.
    */
   group?: Group
   /**
-   * Tags, operations, or paths to exclude from generation.
+   * Skip operations matching at least one entry in the list.
    */
   exclude?: Array<Exclude>
   /**
-   * Tags, operations, or paths to include in generation.
+   * Restrict generation to operations matching at least one entry in the list.
    */
   include?: Array<Include>
   /**
-   * Override options for specific tags, operations, or paths.
+   * Apply a different options object to operations matching a pattern.
    */
   override?: Array<Override<ResolvedOptions>>
   /**
-   * Override naming conventions for function names and types.
+   * Override how handler names and file paths are built. Methods you omit fall
+   * back to the default `resolverMcp`.
    */
   resolver?: Partial<ResolverMcp> & ThisType<ResolverMcp>
   /**
-   * AST visitor to transform generated nodes.
+   * AST visitor applied to each operation node before printing.
    */
   transformer?: ast.Visitor
   /**
-   * Additional generators alongside the default generators.
+   * Custom generators that run alongside the built-in MCP generators.
    */
   generators?: Array<Generator<PluginMcp>>
 }
@@ -63,7 +77,7 @@ type ResolvedOptions = {
   exclude: Array<Exclude>
   include: Array<Include> | undefined
   override: Array<Override<ResolvedOptions>>
-  group: Group | undefined
+  group: Group | null
   client: Pick<PluginClient['options'], 'client' | 'clientType' | 'dataReturnType' | 'importPath' | 'baseURL' | 'bundle' | 'paramsCasing'>
   paramsCasing: Options['paramsCasing']
   resolver: ResolverMcp

package/src/utils.ts

@@ -1,19 +1,5 @@
-import { camelCase } from '@internals/utils'
 import type { ast } from '@kubb/core'
 
-/**
- * Find the first 2xx response status code from an operation's responses.
- */
-export function findSuccessStatusCode(responses: Array<{ statusCode: number | string }>): ast.StatusCode | undefined {
-  for (const res of responses) {
-    const code = Number(res.statusCode)
-    if (code >= 200 && code < 300) {
-      return res.statusCode as ast.StatusCode
-    }
-  }
-  return undefined
-}
-
 export type ZodParam = {
   name: string
   schemaName: string
@@ -31,83 +17,32 @@ export function zodGroupExpr(entry: string | Array<ZodParam>): string {
   return `z.object({ ${entries.join(', ')} })`
 }
 
-/**
- * Build JSDoc comment lines from an OperationNode.
- */
-export function getComments(node: ast.OperationNode): Array<string> {
-  return [
-    node.description && `@description ${node.description}`,
-    node.summary && `@summary ${node.summary}`,
-    node.deprecated && '@deprecated',
-    `{@link ${node.path.replaceAll('{', ':').replaceAll('}', '')}}`,
-  ].filter((x): x is string => Boolean(x))
-}
-
-/**
- * Build a mapping of original param names → camelCase names.
- * Returns `undefined` when no names actually change (no remapping needed).
- */
-export function getParamsMapping(params: Array<{ name: string }>): Record<string, string> | undefined {
-  if (!params.length) {
-    return undefined
-  }
-
-  const mapping: Record<string, string> = {}
-  let hasDifference = false
-
-  for (const p of params) {
-    const camelName = camelCase(p.name)
-    mapping[p.name] = camelName
-    if (p.name !== camelName) {
-      hasDifference = true
-    }
-  }
-
-  return hasDifference ? mapping : undefined
-}
-
 /**
  * Convert a SchemaNode type to an inline Zod expression string.
  * Used as fallback when no named zod schema is available for a path parameter.
  */
 export function zodExprFromSchemaNode(schema: ast.SchemaNode): string {
-  let expr: string
-  switch (schema.type) {
-    case 'enum': {
-      // namedEnumValues takes priority over enumValues
+  const baseExpr = (() => {
+    if (schema.type === 'enum') {
       const rawValues: Array<string | number | boolean> = schema.namedEnumValues?.length
         ? schema.namedEnumValues.map((v) => v.value)
         : (schema.enumValues ?? []).filter((v): v is string | number | boolean => v !== null)
 
       if (rawValues.length > 0 && rawValues.every((v) => typeof v === 'string')) {
-        expr = `z.enum([${rawValues.map((v) => JSON.stringify(v)).join(', ')}])`
-      } else if (rawValues.length > 0) {
+        return `z.enum([${rawValues.map((v) => JSON.stringify(v)).join(', ')}])`
+      }
+      if (rawValues.length > 0) {
         const literals = rawValues.map((v) => `z.literal(${JSON.stringify(v)})`)
-        expr = literals.length === 1 ? literals[0]! : `z.union([${literals.join(', ')}])`
-      } else {
-        expr = 'z.string()'
+        return literals.length === 1 ? literals[0]! : `z.union([${literals.join(', ')}])`
       }
-      break
+      return 'z.string()'
     }
-    case 'integer':
-      expr = 'z.coerce.number()'
-      break
-    case 'number':
-      expr = 'z.number()'
-      break
-    case 'boolean':
-      expr = 'z.boolean()'
-      break
-    case 'array':
-      expr = 'z.array(z.unknown())'
-      break
-    default:
-      expr = 'z.string()'
-  }
-
-  if (schema.nullable) {
-    expr = `${expr}.nullable()`
-  }
-
-  return expr
+    if (schema.type === 'integer') return 'z.coerce.number()'
+    if (schema.type === 'number') return 'z.number()'
+    if (schema.type === 'boolean') return 'z.boolean()'
+    if (schema.type === 'array') return 'z.array(z.unknown())'
+    return 'z.string()'
+  })()
+
+  return schema.nullable ? `${baseExpr}.nullable()` : baseExpr
 }