@kubb/plugin-mcp 5.0.0-alpha.8 → 5.0.0-beta.10

package/src/generators/mcpGenerator.tsx

@@ -1,109 +1,78 @@
 import path from 'node:path'
-import { Client } from '@kubb/plugin-client/components'
-import { createReactGenerator } from '@kubb/plugin-oas/generators'
-import { useOas, useOperationManager } from '@kubb/plugin-oas/hooks'
-import { getBanner, getFooter } from '@kubb/plugin-oas/utils'
+import { resolveOperationTypeNames } from '@internals/shared'
+import { defineGenerator } from '@kubb/core'
 import { pluginTsName } from '@kubb/plugin-ts'
-import { File } from '@kubb/react-fabric'
-import type { PluginMcp } from '../types'
+import { File, jsxRenderer } from '@kubb/renderer-jsx'
+import { McpHandler } from '../components/McpHandler.tsx'
+import type { PluginMcp } from '../types.ts'
 
-export const mcpGenerator = createReactGenerator<PluginMcp>({
+export const mcpGenerator = defineGenerator<PluginMcp>({
   name: 'mcp',
-  Operation({ config, operation, generator, plugin }) {
-    const { options } = plugin
-    const oas = useOas()
+  renderer: jsxRenderer,
+  operation(node, ctx) {
+    const { resolver, driver, root } = ctx
+    const { output, client, paramsCasing, group } = ctx.options
 
-    const { getSchemas, getName, getFile } = useOperationManager(generator)
+    const pluginTs = driver.getPlugin(pluginTsName)
 
-    const mcp = {
-      name: getName(operation, { type: 'function', suffix: 'handler' }),
-      file: getFile(operation),
+    if (!pluginTs) {
+      return null
     }
 
-    const type = {
-      file: getFile(operation, { pluginName: pluginTsName }),
-      schemas: getSchemas(operation, { pluginName: pluginTsName, type: 'type' }),
-    }
+    const tsResolver = driver.getResolver(pluginTsName)
+
+    const importedTypeNames = resolveOperationTypeNames(node, tsResolver, { paramsCasing, responseStatusNames: 'error' })
+
+    const meta = {
+      name: resolver.resolveHandlerName(node),
+      file: resolver.resolveFile({ name: node.operationId, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path }, { root, output, group }),
+      fileTs: tsResolver.resolveFile(
+        { name: node.operationId, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path },
+        {
+          root,
+          output: pluginTs.options?.output ?? output,
+          group: pluginTs.options?.group,
+        },
+      ),
+    } as const
 
     return (
-      <File
-        baseName={mcp.file.baseName}
-        path={mcp.file.path}
-        meta={mcp.file.meta}
-        banner={getBanner({ oas, output: options.output })}
-        footer={getFooter({ oas, output: options.output })}
-      >
-        {options.client.importPath ? (
+      <File baseName={meta.file.baseName} path={meta.file.path} meta={meta.file.meta}>
+        {meta.fileTs && importedTypeNames.length > 0 && (
+          <File.Import name={Array.from(new Set(importedTypeNames)).sort()} root={meta.file.path} path={meta.fileTs.path} isTypeOnly />
+        )}
+        <File.Import name={['CallToolResult', 'ServerNotification', 'ServerRequest']} path={'@modelcontextprotocol/sdk/types'} isTypeOnly />
+        <File.Import name={['RequestHandlerExtra']} path={'@modelcontextprotocol/sdk/shared/protocol'} isTypeOnly />
+        <File.Import name={['buildFormData']} root={meta.file.path} path={path.resolve(root, '.kubb/config.ts')} />
+        {client.importPath ? (
           <>
-            <File.Import name={'fetch'} path={options.client.importPath} />
-            <File.Import name={['Client', 'RequestConfig', 'ResponseErrorConfig']} path={options.client.importPath} isTypeOnly />
-            {options.client.dataReturnType === 'full' && <File.Import name={['ResponseConfig']} path={options.client.importPath} isTypeOnly />}
+            <File.Import name={['Client', 'RequestConfig', 'ResponseErrorConfig']} path={client.importPath} isTypeOnly />
+            <File.Import name={'fetch'} path={client.importPath} />
+            {client.dataReturnType === 'full' && <File.Import name={['ResponseConfig']} path={client.importPath} isTypeOnly />}
           </>
         ) : (
           <>
-            <File.Import name={['fetch']} root={mcp.file.path} path={path.resolve(config.root, config.output.path, '.kubb/fetch.ts')} />
             <File.Import
               name={['Client', 'RequestConfig', 'ResponseErrorConfig']}
-              root={mcp.file.path}
-              path={path.resolve(config.root, config.output.path, '.kubb/fetch.ts')}
+              root={meta.file.path}
+              path={path.resolve(root, '.kubb/fetch.ts')}
               isTypeOnly
             />
-            {options.client.dataReturnType === 'full' && (
-              <File.Import name={['ResponseConfig']} root={mcp.file.path} path={path.resolve(config.root, config.output.path, '.kubb/fetch.ts')} isTypeOnly />
+            <File.Import name={['fetch']} root={meta.file.path} path={path.resolve(root, '.kubb/fetch.ts')} />
+            {client.dataReturnType === 'full' && (
+              <File.Import name={['ResponseConfig']} root={meta.file.path} path={path.resolve(root, '.kubb/fetch.ts')} isTypeOnly />
             )}
           </>
         )}
-        <File.Import name={['buildFormData']} root={mcp.file.path} path={path.resolve(config.root, config.output.path, '.kubb/config.ts')} />
-        <File.Import name={['CallToolResult']} path={'@modelcontextprotocol/sdk/types'} isTypeOnly />
-        <File.Import
-          name={[
-            type.schemas.request?.name,
-            type.schemas.response.name,
-            type.schemas.pathParams?.name,
-            type.schemas.queryParams?.name,
-            type.schemas.headerParams?.name,
-            ...(type.schemas.statusCodes?.map((item) => item.name) || []),
-          ].filter(Boolean)}
-          root={mcp.file.path}
-          path={type.file.path}
-          isTypeOnly
-        />
 
-        <Client
-          name={mcp.name}
-          isConfigurable={false}
-          returnType={'Promise<CallToolResult>'}
-          baseURL={options.client.baseURL}
-          operation={operation}
-          typeSchemas={type.schemas}
-          zodSchemas={undefined}
-          dataReturnType={options.client.dataReturnType || 'data'}
-          paramsType={'object'}
-          paramsCasing={options.client?.paramsCasing || options.paramsCasing}
-          pathParamsType={'object'}
-          parser={'client'}
-        >
-          {options.client.dataReturnType === 'data' &&
-            `return {
-            content: [
-              {
-                type: 'text',
-                text: JSON.stringify(res.data)
-              }
-            ],
-            structuredContent: { data: res.data }
-           }`}
-          {options.client.dataReturnType === 'full' &&
-            `return {
-            content: [
-              {
-                type: 'text',
-                text: JSON.stringify(res)
-              }
-            ],
-            structuredContent: { data: res.data }
-           }`}
-        </Client>
+        <McpHandler
+          name={meta.name}
+          node={node}
+          resolver={tsResolver}
+          baseURL={client.baseURL}
+          dataReturnType={client.dataReturnType || 'data'}
+          paramsCasing={paramsCasing}
+        />
       </File>
     )
   },

package/src/generators/serverGenerator.tsx

@@ -1,81 +1,115 @@
-import { usePluginDriver } from '@kubb/core/hooks'
-import { createReactGenerator } from '@kubb/plugin-oas/generators'
-import { useOas, useOperationManager } from '@kubb/plugin-oas/hooks'
-import { getBanner, getFooter } from '@kubb/plugin-oas/utils'
-import { pluginTsName } from '@kubb/plugin-ts'
+import path from 'node:path'
+import { findSuccessStatusCode, getOperationParameters } from '@internals/shared'
+import { defineGenerator } from '@kubb/core'
 import { pluginZodName } from '@kubb/plugin-zod'
-import { File } from '@kubb/react-fabric'
-import { Server } from '../components/Server'
-import type { PluginMcp } from '../types'
+import { File, jsxRenderer } from '@kubb/renderer-jsx'
+import { Server } from '../components/Server.tsx'
+import type { PluginMcp } from '../types.ts'
 
-export const serverGenerator = createReactGenerator<PluginMcp>({
+/**
+ * Default v5 server generator for `@kubb/plugin-mcp`.
+ *
+ * Uses individual zod schemas for each param (e.g. `createPetsPathUuidSchema`, `createPetsQueryOffsetSchema`)
+ * and `resolveResponseStatusName` for per-status response schemas.
+ * Query and header params are composed into `z.object({ ... })` from individual schemas.
+ */
+export const serverGenerator = defineGenerator<PluginMcp>({
   name: 'operations',
-  Operations({ operations, generator, plugin }) {
-    const driver = usePluginDriver()
-    const { options } = plugin
+  renderer: jsxRenderer,
+  operations(nodes, ctx) {
+    const { adapter, config, resolver, plugin, driver, root } = ctx
+    const { output, paramsCasing, group } = ctx.options
 
-    const oas = useOas()
-    const { getFile, getName, getSchemas } = useOperationManager(generator)
+    const pluginZod = driver.getPlugin(pluginZodName)
+
+    if (!pluginZod) {
+      return
+    }
+
+    const zodResolver = driver.getResolver(pluginZodName)
 
     const name = 'server'
-    const file = driver.getFile({ name, extname: '.ts', pluginName: plugin.name })
+    const serverFilePath = path.resolve(root, output.path, 'server.ts')
+    const serverFile = {
+      baseName: 'server.ts' as const,
+      path: serverFilePath,
+      meta: { pluginName: plugin.name },
+    }
+
+    const jsonFilePath = path.resolve(root, output.path, '.mcp.json')
+    const jsonFile = {
+      baseName: '.mcp.json' as const,
+      path: jsonFilePath,
+      meta: { pluginName: plugin.name },
+    }
 
-    const jsonFile = driver.getFile({ name: '.mcp', extname: '.json', pluginName: plugin.name })
+    const operationsMapped = nodes.map((node) => {
+      const { path: pathParams, query: queryParams, header: headerParams } = getOperationParameters(node, { paramsCasing })
+
+      const mcpFile = resolver.resolveFile({ name: node.operationId, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path }, { root, output, group })
+
+      const zodFile = zodResolver.resolveFile(
+        { name: node.operationId, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path },
+        {
+          root,
+          output: pluginZod.options?.output ?? output,
+          group: pluginZod.options?.group,
+        },
+      )
+
+      const requestName = node.requestBody?.content?.[0]?.schema ? zodResolver.resolveDataName(node) : undefined
+      const successStatus = findSuccessStatusCode(node.responses)
+      const responseName = successStatus ? zodResolver.resolveResponseStatusName(node, successStatus) : undefined
+
+      const resolveParams = (params: typeof pathParams) => params.map((p) => ({ name: p.name, schemaName: zodResolver.resolveParamName(node, p) }))
 
-    const operationsMapped = operations.map((operation) => {
       return {
         tool: {
-          name: operation.getOperationId() || operation.getSummary() || `${operation.method.toUpperCase()} ${operation.path}`,
-          title: operation.getSummary() || undefined,
-          description: operation.getDescription() || `Make a ${operation.method.toUpperCase()} request to ${operation.path}`,
+          name: node.operationId,
+          title: node.summary || undefined,
+          description: node.description || `Make a ${node.method.toUpperCase()} request to ${node.path}`,
         },
         mcp: {
-          name: getName(operation, {
-            type: 'function',
-            suffix: 'handler',
-          }),
-          file: getFile(operation),
+          name: resolver.resolveHandlerName(node),
+          file: mcpFile,
         },
         zod: {
-          name: getName(operation, {
-            type: 'function',
-            pluginName: pluginZodName,
-          }),
-          schemas: getSchemas(operation, { pluginName: pluginZodName, type: 'function' }),
-          file: getFile(operation, { pluginName: pluginZodName }),
-        },
-        type: {
-          schemas: getSchemas(operation, { pluginName: pluginTsName, type: 'type' }),
+          pathParams: resolveParams(pathParams),
+          queryParams: queryParams.length ? resolveParams(queryParams) : undefined,
+          headerParams: headerParams.length ? resolveParams(headerParams) : undefined,
+          requestName,
+          responseName,
+          file: zodFile,
         },
+        node: node,
       }
     })
 
     const imports = operationsMapped.flatMap(({ mcp, zod }) => {
+      const zodNames = [
+        ...zod.pathParams.map((p) => p.schemaName),
+        ...(zod.queryParams ?? []).map((p) => p.schemaName),
+        ...(zod.headerParams ?? []).map((p) => p.schemaName),
+        zod.requestName,
+        zod.responseName,
+      ].filter((name): name is string => Boolean(name))
+
+      const uniqueNames = [...new Set(zodNames)].sort()
+
       return [
-        <File.Import key={mcp.name} name={[mcp.name]} root={file.path} path={mcp.file.path} />,
-        <File.Import
-          key={zod.name}
-          name={[
-            zod.schemas.request?.name,
-            zod.schemas.pathParams?.name,
-            zod.schemas.queryParams?.name,
-            zod.schemas.headerParams?.name,
-            zod.schemas.response?.name,
-          ].filter(Boolean)}
-          root={file.path}
-          path={zod.file.path}
-        />,
-      ]
+        <File.Import key={mcp.name} name={[mcp.name]} root={serverFile.path} path={mcp.file.path} />,
+        uniqueNames.length > 0 && <File.Import key={`zod-${mcp.name}`} name={uniqueNames} root={serverFile.path} path={zod.file.path} />,
+      ].filter(Boolean)
     })
 
     return (
       <>
         <File
-          baseName={file.baseName}
-          path={file.path}
-          meta={file.meta}
-          banner={getBanner({ oas, output: options.output, config: driver.config })}
-          footer={getFooter({ oas, output: options.output })}
+          baseName={serverFile.baseName}
+          path={serverFile.path}
+          meta={serverFile.meta}
+          banner={resolver.resolveBanner(adapter.inputNode, { output, config })}
+          footer={resolver.resolveFooter(adapter.inputNode, { output, config })}
         >
           <File.Import name={['McpServer']} path={'@modelcontextprotocol/sdk/server/mcp'} />
           <File.Import name={['z']} path={'zod'} />
@@ -84,9 +118,9 @@ export const serverGenerator = createReactGenerator<PluginMcp>({
           {imports}
           <Server
             name={name}
-            serverName={oas.api.info?.title}
-            serverVersion={oas.getVersion()}
-            paramsCasing={options.paramsCasing}
+            serverName={adapter.inputNode?.meta?.title ?? 'server'}
+            serverVersion={adapter.inputNode?.meta?.version ?? '0.0.0'}
+            paramsCasing={paramsCasing}
             operations={operationsMapped}
           />
         </File>
@@ -96,10 +130,10 @@ export const serverGenerator = createReactGenerator<PluginMcp>({
             {`
           {
             "mcpServers": {
-              "${oas.api.info?.title || 'server'}": {
+              "${adapter.inputNode?.meta?.title || 'server'}": {
                 "type": "stdio",
                 "command": "npx",
-                "args": ["tsx", "${file.path}"]
+                "args": ["tsx", "${path.relative(path.dirname(jsonFile.path), serverFile.path)}"]
               }
             }
           }

package/src/index.ts

@@ -1,2 +1,11 @@
-export { pluginMcp, pluginMcpName } from './plugin.ts'
-export type { PluginMcp } from './types.ts'
+export { McpHandler } from './components/McpHandler.tsx'
+export { Server } from './components/Server.tsx'
+
+export { mcpGenerator } from './generators/mcpGenerator.tsx'
+export { serverGenerator } from './generators/serverGenerator.tsx'
+
+export { default, pluginMcp, pluginMcpName } from './plugin.ts'
+
+export { resolverMcp } from './resolvers/resolverMcp.ts'
+
+export type { PluginMcp, ResolverMcp } from './types.ts'

package/src/plugin.ts

@@ -1,170 +1,122 @@
 import path from 'node:path'
 import { camelCase } from '@internals/utils'
-import { createPlugin, type Group, getBarrelFiles, getMode } from '@kubb/core'
+
+import { ast, definePlugin, type Group } from '@kubb/core'
 import { pluginClientName } from '@kubb/plugin-client'
 import { source as axiosClientSource } from '@kubb/plugin-client/templates/clients/axios.source'
 import { source as fetchClientSource } from '@kubb/plugin-client/templates/clients/fetch.source'
 import { source as configSource } from '@kubb/plugin-client/templates/config.source'
-import { OperationGenerator, pluginOasName } from '@kubb/plugin-oas'
 import { pluginTsName } from '@kubb/plugin-ts'
 import { pluginZodName } from '@kubb/plugin-zod'
-import { mcpGenerator, serverGenerator } from './generators'
+import { mcpGenerator } from './generators/mcpGenerator.tsx'
+import { serverGenerator } from './generators/serverGenerator.tsx'
+import { resolverMcp } from './resolvers/resolverMcp.ts'
 import type { PluginMcp } from './types.ts'
 
 export const pluginMcpName = 'plugin-mcp' satisfies PluginMcp['name']
 
-export const pluginMcp = createPlugin<PluginMcp>((options) => {
+export const pluginMcp = definePlugin<PluginMcp>((options) => {
   const {
     output = { path: 'mcp', barrelType: 'named' },
     group,
     exclude = [],
     include,
     override = [],
-    transformers = {},
-    generators = [mcpGenerator, serverGenerator].filter(Boolean),
-    contentType,
     paramsCasing,
     client,
+    resolver: userResolver,
+    transformer: userTransformer,
+    generators: userGenerators = [],
   } = options
 
   const clientName = client?.client ?? 'axios'
   const clientImportPath = client?.importPath ?? (!client?.bundle ? `@kubb/plugin-client/clients/${clientName}` : undefined)
 
-  return {
-    name: pluginMcpName,
-    options: {
-      output,
-      group,
-      paramsCasing,
-      client: {
-        client: clientName,
-        clientType: client?.clientType ?? 'function',
-        importPath: clientImportPath,
-        dataReturnType: client?.dataReturnType ?? 'data',
-        bundle: client?.bundle,
-        baseURL: client?.baseURL,
-        paramsCasing: client?.paramsCasing,
-      },
-    },
-    pre: [pluginOasName, pluginTsName, pluginZodName].filter(Boolean),
-    resolvePath(baseName, pathMode, options) {
-      const root = path.resolve(this.config.root, this.config.output.path)
-      const mode = pathMode ?? getMode(path.resolve(root, output.path))
-
-      if (mode === 'single') {
-        /**
-         * when output is a file then we will always append to the same file(output file), see fileManager.addOrAppend
-         * Other plugins then need to call addOrAppend instead of just add from the fileManager class
-         */
-        return path.resolve(root, output.path)
-      }
-
-      if (group && (options?.group?.path || options?.group?.tag)) {
-        const groupName: Group['name'] = group?.name
+  const groupConfig = group
+    ? ({
+        ...group,
+        name: group.name
           ? group.name
-          : (ctx) => {
-              if (group?.type === 'path') {
+          : (ctx: { group: string }) => {
+              if (group.type === 'path') {
                 return `${ctx.group.split('/')[1]}`
               }
               return `${camelCase(ctx.group)}Requests`
-            }
-
-        return path.resolve(
-          root,
-          output.path,
-          groupName({
-            group: group.type === 'path' ? options.group.path! : options.group.tag!,
-          }),
-          baseName,
-        )
-      }
-
-      return path.resolve(root, output.path, baseName)
-    },
-    resolveName(name, type) {
-      const resolvedName = camelCase(name, {
-        isFile: type === 'file',
-      })
-
-      if (type) {
-        return transformers?.name?.(resolvedName, type) || resolvedName
-      }
-
-      return resolvedName
-    },
-    async install() {
-      const root = path.resolve(this.config.root, this.config.output.path)
-      const mode = getMode(path.resolve(root, output.path))
-      const oas = await this.getOas()
-      const baseURL = await this.getBaseURL()
-
-      if (baseURL) {
-        this.plugin.options.client.baseURL = baseURL
-      }
-
-      const hasClientPlugin = !!this.driver.getPluginByName(pluginClientName)
-
-      if (this.plugin.options.client.bundle && !hasClientPlugin && !this.plugin.options.client.importPath) {
-        // pre add bundled fetch
-        await this.addFile({
-          baseName: 'fetch.ts',
-          path: path.resolve(root, '.kubb/fetch.ts'),
-          sources: [
-            {
-              name: 'fetch',
-              value: this.plugin.options.client.client === 'fetch' ? fetchClientSource : axiosClientSource,
-              isExportable: true,
-              isIndexable: true,
             },
-          ],
-          imports: [],
-          exports: [],
-        })
-      }
+      } satisfies Group)
+    : undefined
 
-      if (!hasClientPlugin) {
-        await this.addFile({
-          baseName: 'config.ts',
-          path: path.resolve(root, '.kubb/config.ts'),
-          sources: [
-            {
-              name: 'config',
-              value: configSource,
-              isExportable: false,
-              isIndexable: false,
-            },
-          ],
-          imports: [],
-          exports: [],
+  return {
+    name: pluginMcpName,
+    options,
+    dependencies: [pluginTsName, pluginZodName],
+    hooks: {
+      'kubb:plugin:setup'(ctx) {
+        const resolver = userResolver ? { ...resolverMcp, ...userResolver } : resolverMcp
+
+        ctx.setOptions({
+          output,
+          exclude,
+          include,
+          override,
+          group: groupConfig,
+          paramsCasing,
+          client: {
+            client: clientName,
+            clientType: client?.clientType ?? 'function',
+            importPath: clientImportPath,
+            dataReturnType: client?.dataReturnType ?? 'data',
+            bundle: client?.bundle,
+            baseURL: client?.baseURL,
+            paramsCasing: client?.paramsCasing,
+          },
+          resolver,
         })
-      }
-
-      const operationGenerator = new OperationGenerator(this.plugin.options, {
-        fabric: this.fabric,
-        oas,
-        driver: this.driver,
-        events: this.events,
-        plugin: this.plugin,
-        contentType,
-        exclude,
-        include,
-        override,
-        mode,
-      })
-
-      const files = await operationGenerator.build(...generators)
-      await this.upsertFile(...files)
-
-      const barrelFiles = await getBarrelFiles(this.fabric.files, {
-        type: output.barrelType ?? 'named',
-        root,
-        output,
-        meta: {
-          pluginName: this.plugin.name,
-        },
-      })
-
-      await this.upsertFile(...barrelFiles)
+        ctx.setResolver(resolver)
+        if (userTransformer) {
+          ctx.setTransformer(userTransformer)
+        }
+        ctx.addGenerator(mcpGenerator)
+        ctx.addGenerator(serverGenerator)
+        for (const gen of userGenerators) {
+          ctx.addGenerator(gen)
+        }
+
+        const root = path.resolve(ctx.config.root, ctx.config.output.path)
+        const hasClientPlugin = ctx.config.plugins?.some((p) => p.name === pluginClientName)
+
+        if (client?.bundle && !hasClientPlugin && !clientImportPath) {
+          ctx.injectFile({
+            baseName: 'fetch.ts',
+            path: path.resolve(root, '.kubb/fetch.ts'),
+            sources: [
+              ast.createSource({
+                name: 'fetch',
+                nodes: [ast.createText(clientName === 'fetch' ? fetchClientSource : axiosClientSource)],
+                isExportable: true,
+                isIndexable: true,
+              }),
+            ],
+          })
+        }
+
+        if (!hasClientPlugin) {
+          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 pluginMcp

package/src/resolvers/resolverMcp.ts

@@ -0,0 +1,31 @@
+import { camelCase } from '@internals/utils'
+import { defineResolver } from '@kubb/core'
+import type { PluginMcp } from '../types.ts'
+
+/**
+ * Naming convention resolver for MCP plugin.
+ *
+ * Provides default naming helpers using camelCase with a `handler` suffix for functions.
+ *
+ * @example
+ * `resolverMcp.default('addPet', 'function')  // → 'addPetHandler'`
+ */
+export const resolverMcp = defineResolver<PluginMcp>(() => ({
+  name: 'default',
+  pluginName: 'plugin-mcp',
+  default(name, type) {
+    if (type === 'file') {
+      return camelCase(name, { isFile: true })
+    }
+    return camelCase(name, { suffix: 'handler' })
+  },
+  resolveName(name) {
+    return this.default(name, 'function')
+  },
+  resolvePathName(name, type) {
+    return this.default(name, type)
+  },
+  resolveHandlerName(node) {
+    return this.resolveName(node.operationId)
+  },
+}))