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

package/src/components/Mock.tsx

@@ -1,48 +1,57 @@
+import { getPrimarySuccessResponse } from '@internals/shared'
 import { URLPath } from '@internals/utils'
-import type { OasTypes, Operation } from '@kubb/oas'
-import { File, Function, FunctionParams } from '@kubb/react-fabric'
-import type { FabricReactNode } from '@kubb/react-fabric/types'
+import { ast } from '@kubb/core'
+import { functionPrinter } from '@kubb/plugin-ts'
+import { File, Function } from '@kubb/renderer-jsx'
+import type { KubbReactNode } from '@kubb/renderer-jsx/types'
+import { getContentType, getMswMethod, getMswUrl, hasResponseSchema } from '../utils.ts'
 
 type Props = {
-  /**
-   * Name of the function
-   */
   name: string
   typeName: string
-  fakerName: string
+  requestTypeName?: string
   baseURL: string | undefined
-  operation: Operation
+  node: ast.OperationNode
 }
 
-export function Mock({ baseURL = '', name, typeName, operation }: Props): FabricReactNode {
-  const method = operation.method
-  const successStatusCodes = operation.getResponseStatusCodes().filter((code) => code.startsWith('2'))
-  const statusCode = successStatusCodes.length > 0 ? Number(successStatusCodes[0]) : 200
+const declarationPrinter = functionPrinter({ mode: 'declaration' })
 
-  const responseObject = operation.getResponseByStatusCode(statusCode) as OasTypes.ResponseObject
-  const contentType = Object.keys(responseObject.content || {})?.[0]
-  const url = new URLPath(operation.path).toURLPath().replace(/([^/]):/g, '$1\\\\:')
+export function Mock({ baseURL = '', name, typeName, requestTypeName, node }: Props): KubbReactNode {
+  const method = getMswMethod(node)
+  const successResponse = getPrimarySuccessResponse(node)
+  const statusCode = successResponse ? Number(successResponse.statusCode) : 200
+  const contentType = getContentType(successResponse)
+  const url = new URLPath(getMswUrl(node)).toURLPath()
 
   const headers = [contentType ? `'Content-Type': '${contentType}'` : undefined].filter(Boolean)
+  const responseHasSchema = hasResponseSchema(successResponse)
+  const dataType = responseHasSchema ? typeName : 'string | number | boolean | null | object'
 
-  const hasResponseSchema = contentType && responseObject?.content?.[contentType]?.schema !== undefined
+  const callbackType = requestTypeName
+    ? `HttpResponseResolver<Record<string, string>, ${requestTypeName}, any>`
+    : `((info: Parameters<Parameters<typeof http.${method}>[1]>[0]) => Response | Promise<Response>)`
 
-  // If no response schema, uses any type but function to avoid overriding callback
-  const dataType = hasResponseSchema ? typeName : 'string | number | boolean | null | object'
+  const params = declarationPrinter.print(
+    ast.createFunctionParameters({
+      params: [
+        ast.createFunctionParameter({
+          name: 'data',
+          type: ast.createParamsType({
+            variant: 'reference',
+            name: `${dataType} | ${callbackType}`,
+          }),
+          optional: true,
+        }),
+      ],
+    }),
+  )
 
-  const params = FunctionParams.factory({
-    data: {
-      type: `${dataType} | ((
-        info: Parameters<Parameters<typeof http.${method}>[1]>[0],
-      ) => Response | Promise<Response>)`,
-      optional: true,
-    },
-  })
+  const httpCall = requestTypeName ? `http.${method}<Record<string, string>, ${requestTypeName}, any>` : `http.${method}`
 
   return (
     <File.Source name={name} isIndexable isExportable>
-      <Function name={name} export params={params.toConstructor()}>
-        {`return http.${method}(\`${baseURL}${url.replace(/([^/]):/g, '$1\\\\:')}\`, function handler(info) {
+      <Function name={name} export params={params ?? ''}>
+        {`return ${httpCall}(\`${baseURL}${url.replace(/([^/]):/g, '$1\\\\:')}\`, function handler(info) {
     if(typeof data === 'function') return data(info)
 
     return new Response(JSON.stringify(data), {

package/src/components/MockWithFaker.tsx

@@ -1,43 +1,56 @@
+import { getPrimarySuccessResponse } from '@internals/shared'
 import { URLPath } from '@internals/utils'
-import type { OasTypes, Operation } from '@kubb/oas'
-import { File, Function, FunctionParams } from '@kubb/react-fabric'
-import type { FabricReactNode } from '@kubb/react-fabric/types'
+import { ast } from '@kubb/core'
+import { functionPrinter } from '@kubb/plugin-ts'
+import { File, Function } from '@kubb/renderer-jsx'
+import type { KubbReactNode } from '@kubb/renderer-jsx/types'
+import { getContentType, getMswMethod, getMswUrl } from '../utils.ts'
 
 type Props = {
-  /**
-   * Name of the function
-   */
   name: string
   typeName: string
+  requestTypeName?: string
   fakerName: string
   baseURL: string | undefined
-  operation: Operation
+  node: ast.OperationNode
 }
 
-export function MockWithFaker({ baseURL = '', name, fakerName, typeName, operation }: Props): FabricReactNode {
-  const method = operation.method
-  const successStatusCodes = operation.getResponseStatusCodes().filter((code) => code.startsWith('2'))
-  const statusCode = successStatusCodes.length > 0 ? Number(successStatusCodes[0]) : 200
+const declarationPrinter = functionPrinter({ mode: 'declaration' })
 
-  const responseObject = operation.getResponseByStatusCode(statusCode) as OasTypes.ResponseObject
-  const contentType = Object.keys(responseObject.content || {})?.[0]
-  const url = new URLPath(operation.path).toURLPath().replace(/([^/]):/g, '$1\\\\:')
+export function MockWithFaker({ baseURL = '', name, fakerName, typeName, requestTypeName, node }: Props): KubbReactNode {
+  const method = getMswMethod(node)
+  const successResponse = getPrimarySuccessResponse(node)
+  const statusCode = successResponse ? Number(successResponse.statusCode) : 200
+  const contentType = getContentType(successResponse)
+  const url = new URLPath(getMswUrl(node)).toURLPath()
 
   const headers = [contentType ? `'Content-Type': '${contentType}'` : undefined].filter(Boolean)
 
-  const params = FunctionParams.factory({
-    data: {
-      type: `${typeName} | ((
-        info: Parameters<Parameters<typeof http.${method}>[1]>[0],
-      ) => Response | Promise<Response>)`,
-      optional: true,
-    },
-  })
+  const callbackType = requestTypeName
+    ? `HttpResponseResolver<Record<string, string>, ${requestTypeName}, any>`
+    : `((info: Parameters<Parameters<typeof http.${method}>[1]>[0]) => Response | Promise<Response>)`
+
+  const params = declarationPrinter.print(
+    ast.createFunctionParameters({
+      params: [
+        ast.createFunctionParameter({
+          name: 'data',
+          type: ast.createParamsType({
+            variant: 'reference',
+            name: `${typeName} | ${callbackType}`,
+          }),
+          optional: true,
+        }),
+      ],
+    }),
+  )
+
+  const httpCall = requestTypeName ? `http.${method}<Record<string, string>, ${requestTypeName}, any>` : `http.${method}`
 
   return (
     <File.Source name={name} isIndexable isExportable>
-      <Function name={name} export params={params.toConstructor()}>
-        {`return http.${method}('${baseURL}${url.replace(/([^/]):/g, '$1\\\\:')}', function handler(info) {
+      <Function name={name} export params={params ?? ''}>
+        {`return ${httpCall}('${baseURL}${url.replace(/([^/]):/g, '$1\\\\:')}', function handler(info) {
     if(typeof data === 'function') return data(info)
 
     return new Response(JSON.stringify(data || ${fakerName}(data)), {

package/src/components/Response.tsx

@@ -1,34 +1,40 @@
-import type { OasTypes, Operation } from '@kubb/oas'
-import { File, Function, FunctionParams } from '@kubb/react-fabric'
-import type { FabricReactNode } from '@kubb/react-fabric/types'
+import { ast } from '@kubb/core'
+import { functionPrinter } from '@kubb/plugin-ts'
+import { File, Function } from '@kubb/renderer-jsx'
+import type { KubbReactNode } from '@kubb/renderer-jsx/types'
+import { getContentType, hasResponseSchema } from '../utils.ts'
 
 type Props = {
   typeName: string
-  operation: Operation
   name: string
-  statusCode: number
+  response: ast.ResponseNode
+  key?: string | number | null
 }
 
-export function Response({ name, typeName, operation, statusCode }: Props): FabricReactNode {
-  const responseObject = operation.getResponseByStatusCode(statusCode) as OasTypes.ResponseObject
-  const contentType = Object.keys(responseObject.content || {})?.[0]
+const declarationPrinter = functionPrinter({ mode: 'declaration' })
 
+export function Response({ name, typeName, response }: Props): KubbReactNode {
+  const statusCode = Number(response.statusCode)
+  const contentType = getContentType(response)
   const headers = [contentType ? `'Content-Type': '${contentType}'` : undefined].filter(Boolean)
 
-  const hasResponseSchema = contentType && responseObject?.content?.[contentType]?.schema !== undefined
-
-  const params = FunctionParams.factory({
-    data: {
-      type: `${typeName}`,
-      optional: !hasResponseSchema,
-    },
-  })
+  const params = declarationPrinter.print(
+    ast.createFunctionParameters({
+      params: [
+        ast.createFunctionParameter({
+          name: 'data',
+          type: ast.createParamsType({ variant: 'reference', name: typeName }),
+          optional: !hasResponseSchema(response),
+        }),
+      ],
+    }),
+  )
 
   const responseName = `${name}Response${statusCode}`
 
   return (
     <File.Source name={responseName} isIndexable isExportable>
-      <Function name={responseName} export params={params.toConstructor()}>
+      <Function name={responseName} export params={params ?? ''}>
         {`
     return new Response(JSON.stringify(data), {
       status: ${statusCode},

package/src/generators/handlersGenerator.tsx

@@ -1,40 +1,40 @@
-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 { File } from '@kubb/react-fabric'
+import { defineGenerator } from '@kubb/core'
+import { File, jsxRenderer } from '@kubb/renderer-jsx'
 import { Handlers } from '../components/Handlers.tsx'
 import type { PluginMsw } from '../types'
 
-export const handlersGenerator = createReactGenerator<PluginMsw>({
+export const handlersGenerator = defineGenerator<PluginMsw>({
   name: 'plugin-msw',
-  Operations({ operations, generator, plugin }) {
-    const driver = usePluginDriver()
+  renderer: jsxRenderer,
+  operations(nodes, ctx) {
+    const { resolver, config, root, adapter } = ctx
+    const { output, group } = ctx.options
 
-    const oas = useOas()
-    const { getName, getFile } = useOperationManager(generator)
+    const handlersName = resolver.resolveHandlersName()
+    const file = resolver.resolveFile({ name: resolver.resolvePathName(handlersName, 'file'), extname: '.ts' }, { root, output, group })
 
-    const file = driver.getFile({ name: 'handlers', extname: '.ts', pluginName: plugin.name })
-
-    const imports = operations.map((operation) => {
-      const operationFile = getFile(operation, { pluginName: plugin.name })
-      const operationName = getName(operation, { pluginName: plugin.name, type: 'function' })
+    const imports = nodes.map((node) => {
+      const operationName = resolver.resolveHandlerName(node)
+      const operationFile = resolver.resolveFile(
+        { name: resolver.resolveName(node.operationId), extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path },
+        { root, output, group },
+      )
 
       return <File.Import key={operationFile.path} name={[operationName]} root={file.path} path={operationFile.path} />
     })
 
-    const handlers = operations.map((operation) => `${getName(operation, { type: 'function', pluginName: plugin.name })}()`)
+    const handlers = nodes.map((node) => `${resolver.resolveHandlerName(node)}()`)
 
     return (
       <File
         baseName={file.baseName}
         path={file.path}
         meta={file.meta}
-        banner={getBanner({ oas, output: plugin.options.output, config: driver.config })}
-        footer={getFooter({ oas, output: plugin.options.output })}
+        banner={resolver.resolveBanner(adapter.inputNode, { output, config })}
+        footer={resolver.resolveFooter(adapter.inputNode, { output, config })}
       >
         {imports}
-        <Handlers name={'handlers'} handlers={handlers} />
+        <Handlers name={handlersName} handlers={handlers} />
       </File>
     )
   },

package/src/generators/mswGenerator.tsx

@@ -1,94 +1,84 @@
-import { usePluginDriver } from '@kubb/core/hooks'
+import { getOperationSuccessResponses, resolveResponseTypes } from '@internals/shared'
+import { defineGenerator } from '@kubb/core'
 import { pluginFakerName } from '@kubb/plugin-faker'
-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 { File } from '@kubb/react-fabric'
+import { File, jsxRenderer } from '@kubb/renderer-jsx'
 import { Mock, MockWithFaker, Response } from '../components'
 import type { PluginMsw } from '../types'
+import { resolveFakerMeta } from '../utils.ts'
 
-export const mswGenerator = createReactGenerator<PluginMsw>({
+export const mswGenerator = defineGenerator<PluginMsw>({
   name: 'msw',
-  Operation({ operation, generator, plugin }) {
-    const {
-      options: { output, parser, baseURL },
-    } = plugin
-    const driver = usePluginDriver()
-
-    const oas = useOas()
-    const { getSchemas, getName, getFile } = useOperationManager(generator)
+  renderer: jsxRenderer,
+  operation(node, ctx) {
+    const { driver, resolver, config, root, adapter } = ctx
+    const { output, parser, baseURL, group } = ctx.options
 
+    const fileName = resolver.resolveName(node.operationId)
     const mock = {
-      name: getName(operation, { type: 'function' }),
-      file: getFile(operation),
+      name: resolver.resolveHandlerName(node),
+      file: resolver.resolveFile({ name: fileName, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path }, { root, output, group }),
     }
 
-    const faker = {
-      file: getFile(operation, { pluginName: pluginFakerName }),
-      schemas: getSchemas(operation, { pluginName: pluginFakerName, type: 'function' }),
-    }
+    const fakerPlugin = parser === 'faker' ? driver.getPlugin(pluginFakerName) : undefined
+    const faker =
+      parser === 'faker' && fakerPlugin
+        ? resolveFakerMeta(node, {
+            root,
+            fakerResolver: driver.getResolver(pluginFakerName),
+            fakerOutput: fakerPlugin.options?.output ?? output,
+            fakerGroup: fakerPlugin.options?.group,
+          })
+        : undefined
+
+    const pluginTs = driver.getPlugin(pluginTsName)
+    if (!pluginTs) return null
+    const tsResolver = driver.getResolver(pluginTsName)
 
     const type = {
-      file: getFile(operation, { pluginName: pluginTsName }),
-      schemas: getSchemas(operation, { pluginName: pluginTsName, type: 'type' }),
+      file: 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 },
+      ),
+      responseName: tsResolver.resolveResponseName(node),
     }
 
-    const responseStatusCodes = operation.getResponseStatusCodes()
-
-    const types: [statusCode: number | 'default', typeName: string][] = []
-
-    for (const code of responseStatusCodes) {
-      if (code === 'default') {
-        types.push(['default', type.schemas.response.name])
-        continue
-      }
+    const types = resolveResponseTypes(node, tsResolver)
+    const successResponses = getOperationSuccessResponses(node)
+    const hasSuccessSchema = successResponses.some((response) => !!response.schema)
 
-      if (code.startsWith('2')) {
-        types.push([Number(code), type.schemas.response.name])
-        continue
-      }
-
-      const codeType = type.schemas.errors?.find((err) => err.statusCode === Number(code))
-      if (codeType) types.push([Number(code), codeType.name])
-    }
+    const requestName = node.requestBody?.content?.[0]?.schema ? tsResolver.resolveDataName(node) : undefined
 
     return (
       <File
         baseName={mock.file.baseName}
         path={mock.file.path}
         meta={mock.file.meta}
-        banner={getBanner({ oas, output, config: driver.config })}
-        footer={getFooter({ oas, output })}
+        banner={resolver.resolveBanner(adapter.inputNode, { output, config })}
+        footer={resolver.resolveFooter(adapter.inputNode, { output, config })}
       >
         <File.Import name={['http']} path="msw" />
-        <File.Import name={['ResponseResolver']} isTypeOnly path="msw" />
+        <File.Import name={['HttpResponseResolver']} isTypeOnly path="msw" />
         <File.Import
-          name={Array.from(new Set([type.schemas.response.name, ...types.map((t) => t[1])]))}
+          name={Array.from(new Set([type.responseName, ...types.map((t) => t[1]), ...(requestName ? [requestName] : [])]))}
           path={type.file.path}
           root={mock.file.path}
           isTypeOnly
         />
-        {parser === 'faker' && faker.file && faker.schemas.response && (
-          <File.Import name={[faker.schemas.response.name]} root={mock.file.path} path={faker.file.path} />
-        )}
+        {parser === 'faker' && faker && <File.Import name={[faker.name]} root={mock.file.path} path={faker.file.path} />}
 
         {types
           .filter(([code]) => code !== 'default')
-          .map(([code, typeName]) => (
-            <Response typeName={typeName} operation={operation} name={mock.name} statusCode={code as number} />
-          ))}
-        {parser === 'faker' && (
-          <MockWithFaker
-            name={mock.name}
-            typeName={type.schemas.response.name}
-            fakerName={faker.schemas.response.name}
-            operation={operation}
-            baseURL={baseURL}
-          />
-        )}
-        {parser === 'data' && (
-          <Mock name={mock.name} typeName={type.schemas.response.name} fakerName={faker.schemas.response.name} operation={operation} baseURL={baseURL} />
+          .map(([code, typeName]) => {
+            const response = node.responses.find((item) => item.statusCode === String(code))
+            if (!response) return null
+            return <Response key={typeName} typeName={typeName} response={response} name={mock.name} />
+          })}
+
+        {parser === 'faker' && faker && hasSuccessSchema ? (
+          <MockWithFaker name={mock.name} typeName={type.responseName} requestTypeName={requestName} fakerName={faker.name} node={node} baseURL={baseURL} />
+        ) : (
+          <Mock name={mock.name} typeName={type.responseName} requestTypeName={requestName} node={node} baseURL={baseURL} />
         )}
       </File>
     )

package/src/index.ts

@@ -1,2 +1,2 @@
-export { pluginMsw, pluginMswName } from './plugin.ts'
+export { default, pluginMsw, pluginMswName } from './plugin.ts'
 export type { PluginMsw } from './types.ts'

package/src/plugin.ts

@@ -1,115 +1,76 @@
-import path from 'node:path'
 import { camelCase } from '@internals/utils'
-import { createPlugin, type Group, getBarrelFiles, getMode } from '@kubb/core'
+import { definePlugin, type Group } from '@kubb/core'
 import { pluginFakerName } from '@kubb/plugin-faker'
-import { OperationGenerator, pluginOasName } from '@kubb/plugin-oas'
 import { pluginTsName } from '@kubb/plugin-ts'
 import { handlersGenerator, mswGenerator } from './generators'
+import { resolverMsw } from './resolvers/resolverMsw.ts'
 import type { PluginMsw } from './types.ts'
 
 export const pluginMswName = 'plugin-msw' satisfies PluginMsw['name']
 
-export const pluginMsw = createPlugin<PluginMsw>((options) => {
+export const pluginMsw = definePlugin<PluginMsw>((options) => {
   const {
     output = { path: 'handlers', barrelType: 'named' },
     group,
     exclude = [],
     include,
     override = [],
-    transformers = {},
     handlers = false,
     parser = 'data',
-    generators = [mswGenerator, handlers ? handlersGenerator : undefined].filter(Boolean),
-    contentType,
     baseURL,
+    resolver: userResolver,
+    transformer: userTransformer,
+    generators: userGenerators = [],
   } = options
 
-  return {
-    name: pluginMswName,
-    options: {
-      output,
-      parser,
-      group,
-      baseURL,
-    },
-    pre: [pluginOasName, pluginTsName, parser === 'faker' ? pluginFakerName : undefined].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)}Controller`
-            }
-
-        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, {
-        suffix: type ? 'handler' : undefined,
-        isFile: type === 'file',
-      })
+            },
+      } satisfies Group)
+    : undefined
 
-      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 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)
+  return {
+    name: pluginMswName,
+    options,
+    dependencies: [pluginTsName, parser === 'faker' ? pluginFakerName : undefined].filter((dependency): dependency is string => Boolean(dependency)),
+    hooks: {
+      'kubb:plugin:setup'(ctx) {
+        const resolver = userResolver ? { ...resolverMsw, ...userResolver } : resolverMsw
 
-      const barrelFiles = await getBarrelFiles(this.fabric.files, {
-        type: output.barrelType ?? 'named',
-        root,
-        output,
-        meta: {
-          pluginName: this.plugin.name,
-        },
-      })
+        ctx.setOptions({
+          output,
+          parser,
+          baseURL,
+          group: groupConfig,
+          exclude,
+          include,
+          override,
+          handlers,
+          resolver,
+        })
+        ctx.setResolver(resolver)
+        if (userTransformer) {
+          ctx.setTransformer(userTransformer)
+        }
 
-      await this.upsertFile(...barrelFiles)
+        ctx.addGenerator(mswGenerator)
+        if (handlers) {
+          ctx.addGenerator(handlersGenerator)
+        }
+        for (const gen of userGenerators) {
+          ctx.addGenerator(gen)
+        }
+      },
     },
   }
 })
+
+export default pluginMsw

package/src/resolvers/resolverMsw.ts

@@ -0,0 +1,28 @@
+import { camelCase } from '@internals/utils'
+import { defineResolver } from '@kubb/core'
+import type { PluginMsw } from '../types.ts'
+
+/**
+ * Naming convention resolver for MSW plugin.
+ *
+ * Provides default naming helpers using camelCase with a `handler` suffix.
+ */
+export const resolverMsw = defineResolver<PluginMsw>(() => ({
+  name: 'default',
+  pluginName: 'plugin-msw',
+  default(name, type) {
+    return camelCase(name, { isFile: type === 'file' })
+  },
+  resolveName(name) {
+    return camelCase(name, { suffix: 'handler' })
+  },
+  resolvePathName(name, type) {
+    return this.default(name, type)
+  },
+  resolveHandlerName(node) {
+    return this.resolveName(node.operationId)
+  },
+  resolveHandlersName() {
+    return 'handlers'
+  },
+}))