@kubb/plugin-msw 5.0.0-beta.3 → 5.0.0-beta.31

package/package.json

@@ -1,23 +1,19 @@
 {
   "name": "@kubb/plugin-msw",
-  "version": "5.0.0-beta.3",
-  "description": "Mock Service Worker (MSW) handlers generator plugin for Kubb, creating API mocks from OpenAPI specifications for frontend development and testing.",
+  "version": "5.0.0-beta.31",
+  "description": "Generate Mock Service Worker (MSW) request handlers from your OpenAPI specification. Intercept HTTP requests in the browser or Node.js for seamless frontend development and testing.",
   "keywords": [
     "api-mocking",
-    "code-generator",
+    "code-generation",
     "codegen",
-    "development",
-    "interceptor",
     "kubb",
     "mock-service-worker",
     "mocking",
     "mocks",
     "msw",
-    "oas",
     "openapi",
-    "plugins",
+    "service-worker",
     "swagger",
-    "testing",
     "typescript"
   ],
   "license": "MIT",
@@ -30,7 +26,7 @@
   "files": [
     "src",
     "dist",
-    "plugin.json",
+    "extension.yaml",
     "!/**/**.test.**",
     "!/**/__tests__/**",
     "!/**/__snapshots__/**"
@@ -76,16 +72,17 @@
     "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
-    "@kubb/core": "5.0.0-beta.3",
-    "@kubb/renderer-jsx": "5.0.0-beta.3",
-    "@kubb/plugin-faker": "5.0.0-beta.3",
-    "@kubb/plugin-ts": "5.0.0-beta.3"
+    "@kubb/core": "5.0.0-beta.31",
+    "@kubb/renderer-jsx": "5.0.0-beta.31",
+    "@kubb/plugin-faker": "5.0.0-beta.31",
+    "@kubb/plugin-ts": "5.0.0-beta.31"
   },
   "devDependencies": {
+    "@internals/shared": "0.0.0",
     "@internals/utils": "0.0.0"
   },
   "peerDependencies": {
-    "@kubb/renderer-jsx": "5.0.0-beta.3"
+    "@kubb/renderer-jsx": "5.0.0-beta.31"
   },
   "size-limit": [
     {

package/src/components/Handlers.tsx

@@ -7,7 +7,7 @@ type HandlersProps = {
    */
   name: string
   // custom
-  handlers: string[]
+  handlers: Array<string>
 }
 
 export function Handlers({ name, handlers }: HandlersProps): KubbReactNode {

package/src/components/Mock.tsx

@@ -1,15 +1,16 @@
+import { getPrimarySuccessResponse } from '@internals/shared'
 import { URLPath } from '@internals/utils'
 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, getPrimarySuccessResponse, hasResponseSchema } from '../utils.ts'
+import { getContentType, getMswMethod, getMswUrl, hasResponseSchema } from '../utils.ts'
 
 type Props = {
   name: string
   typeName: string
-  requestTypeName?: string
-  baseURL: string | undefined
+  requestTypeName?: string | null
+  baseURL: string | null | undefined
   node: ast.OperationNode
 }
 
@@ -22,7 +23,7 @@ export function Mock({ baseURL = '', name, typeName, requestTypeName, node }: Pr
   const contentType = getContentType(successResponse)
   const url = new URLPath(getMswUrl(node)).toURLPath()
 
-  const headers = [contentType ? `'Content-Type': '${contentType}'` : undefined].filter(Boolean)
+  const headers = [contentType ? `'Content-Type': '${contentType}'` : null].filter(Boolean)
   const responseHasSchema = hasResponseSchema(successResponse)
   const dataType = responseHasSchema ? typeName : 'string | number | boolean | null | object'
 

package/src/components/MockWithFaker.tsx

@@ -1,16 +1,17 @@
+import { getPrimarySuccessResponse } from '@internals/shared'
 import { URLPath } from '@internals/utils'
 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, getPrimarySuccessResponse } from '../utils.ts'
+import { getContentType, getMswMethod, getMswUrl } from '../utils.ts'
 
 type Props = {
   name: string
   typeName: string
-  requestTypeName?: string
+  requestTypeName?: string | null
   fakerName: string
-  baseURL: string | undefined
+  baseURL: string | null | undefined
   node: ast.OperationNode
 }
 
@@ -23,7 +24,7 @@ export function MockWithFaker({ baseURL = '', name, fakerName, typeName, request
   const contentType = getContentType(successResponse)
   const url = new URLPath(getMswUrl(node)).toURLPath()
 
-  const headers = [contentType ? `'Content-Type': '${contentType}'` : undefined].filter(Boolean)
+  const headers = [contentType ? `'Content-Type': '${contentType}'` : null].filter(Boolean)
 
   const callbackType = requestTypeName
     ? `HttpResponseResolver<Record<string, string>, ${requestTypeName}, any>`

package/src/components/Response.tsx

@@ -16,7 +16,7 @@ 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 headers = [contentType ? `'Content-Type': '${contentType}'` : null].filter(Boolean)
 
   const params = declarationPrinter.print(
     ast.createFunctionParameters({

package/src/generators/handlersGenerator.tsx

@@ -1,40 +1,46 @@
 import { defineGenerator } from '@kubb/core'
-import { File, jsxRenderer } from '@kubb/renderer-jsx'
+import { File, jsxRendererSync } from '@kubb/renderer-jsx'
 import { Handlers } from '../components/Handlers.tsx'
 import type { PluginMsw } from '../types'
-import { transformName } from '../utils.ts'
 
+/**
+ * Aggregate generator enabled by `pluginMsw({ handlers: true })`. Emits a
+ * `handlers.ts` file that re-exports every generated handler grouped by HTTP
+ * method, ready to spread into `setupServer(...handlers)` or
+ * `setupWorker(...handlers)`.
+ */
 export const handlersGenerator = defineGenerator<PluginMsw>({
   name: 'plugin-msw',
-  renderer: jsxRenderer,
+  renderer: jsxRendererSync,
   operations(nodes, ctx) {
-    const { resolver, config, root, adapter } = ctx
-    const { output, group, transformers } = ctx.options
+    const { resolver, config, root } = ctx
+    const { output, group } = ctx.options
 
-    const file = resolver.resolveFile({ name: 'handlers', extname: '.ts' }, { root, output, group })
+    const handlersName = resolver.resolveHandlersName()
+    const file = resolver.resolveFile({ name: resolver.resolvePathName(handlersName, 'file'), extname: '.ts' }, { root, output, group: group ?? undefined })
 
     const imports = nodes.map((node) => {
-      const operationName = transformName(resolver.resolveName(node.operationId), 'function', transformers)
+      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 },
+        { root, output, group: group ?? undefined },
       )
 
       return <File.Import key={operationFile.path} name={[operationName]} root={file.path} path={operationFile.path} />
     })
 
-    const handlers = nodes.map((node) => `${transformName(resolver.resolveName(node.operationId), 'function', transformers)}()`)
+    const handlers = nodes.map((node) => `${resolver.resolveHandlerName(node)}()`)
 
     return (
       <File
         baseName={file.baseName}
         path={file.path}
         meta={file.meta}
-        banner={resolver.resolveBanner(adapter.inputNode, { output, config })}
-        footer={resolver.resolveFooter(adapter.inputNode, { output, config })}
+        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 } })}
       >
         {imports}
-        <Handlers name={'handlers'} handlers={handlers} />
+        <Handlers name={handlersName} handlers={handlers} />
       </File>
     )
   },

package/src/generators/mswGenerator.tsx

@@ -1,34 +1,45 @@
-import { defineGenerator } from '@kubb/core'
+import { getOperationSuccessResponses, resolveResponseTypes } from '@internals/shared'
+import { ast, defineGenerator } from '@kubb/core'
 import { pluginFakerName } from '@kubb/plugin-faker'
 import { pluginTsName } from '@kubb/plugin-ts'
-import { File, jsxRenderer } from '@kubb/renderer-jsx'
+import { File, jsxRendererSync } from '@kubb/renderer-jsx'
 import { Mock, MockWithFaker, Response } from '../components'
 import type { PluginMsw } from '../types'
-import { getResponseTypes, getSuccessResponses, resolveFakerMeta, transformName } from '../utils.ts'
+import { resolveFakerMeta } from '../utils.ts'
 
+/**
+ * Built-in operation generator for `@kubb/plugin-msw`. Emits one MSW handler
+ * per OpenAPI operation. With `parser: 'faker'` the handler returns a value
+ * from `@kubb/plugin-faker`; with `parser: 'data'` it returns a typed empty
+ * payload for tests to fill in.
+ */
 export const mswGenerator = defineGenerator<PluginMsw>({
   name: 'msw',
-  renderer: jsxRenderer,
+  renderer: jsxRendererSync,
   operation(node, ctx) {
-    const { driver, resolver, config, root, adapter } = ctx
-    const { output, parser, baseURL, group, transformers } = ctx.options
+    if (!ast.isHttpOperationNode(node)) return null
+    const { driver, resolver, config, root } = ctx
+    const { output, parser, baseURL, group } = ctx.options
 
     const fileName = resolver.resolveName(node.operationId)
     const mock = {
-      name: transformName(fileName, 'function', transformers),
-      file: resolver.resolveFile({ name: fileName, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path }, { root, output, group }),
+      name: resolver.resolveHandlerName(node),
+      file: resolver.resolveFile(
+        { name: fileName, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path },
+        { root, output, group: group ?? undefined },
+      ),
     }
 
-    const fakerPlugin = parser === 'faker' ? driver.getPlugin(pluginFakerName) : undefined
+    const fakerPlugin = parser === 'faker' ? driver.getPlugin(pluginFakerName) : null
     const faker =
       parser === 'faker' && fakerPlugin
         ? resolveFakerMeta(node, {
             root,
             fakerResolver: driver.getResolver(pluginFakerName),
             fakerOutput: fakerPlugin.options?.output ?? output,
-            fakerGroup: fakerPlugin.options?.group,
+            fakerGroup: fakerPlugin.options?.group ?? null,
           })
-        : undefined
+        : null
 
     const pluginTs = driver.getPlugin(pluginTsName)
     if (!pluginTs) return null
@@ -37,24 +48,24 @@ export const mswGenerator = defineGenerator<PluginMsw>({
     const 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 },
+        { root, output: pluginTs.options?.output ?? output, group: pluginTs.options?.group ?? undefined },
       ),
       responseName: tsResolver.resolveResponseName(node),
     }
 
-    const types = getResponseTypes(node, tsResolver)
-    const successResponses = getSuccessResponses(node)
-    const hasSuccessSchema = successResponses.some((response) => !!response.schema)
+    const types = resolveResponseTypes(node, tsResolver)
+    const successResponses = getOperationSuccessResponses(node)
+    const hasSuccessSchema = successResponses.some((response) => !!response.content?.[0]?.schema)
 
-    const requestName = node.requestBody?.content?.[0]?.schema ? tsResolver.resolveDataName(node) : undefined
+    const requestName = node.requestBody?.content?.[0]?.schema ? tsResolver.resolveDataName(node) : null
 
     return (
       <File
         baseName={mock.file.baseName}
         path={mock.file.path}
         meta={mock.file.meta}
-        banner={resolver.resolveBanner(adapter.inputNode, { output, config })}
-        footer={resolver.resolveFooter(adapter.inputNode, { output, config })}
+        banner={resolver.resolveBanner(ctx.meta, { output, config, file: { path: mock.file.path, baseName: mock.file.baseName } })}
+        footer={resolver.resolveFooter(ctx.meta, { output, config, file: { path: mock.file.path, baseName: mock.file.baseName } })}
       >
         <File.Import name={['http']} path="msw" />
         <File.Import name={['HttpResponseResolver']} isTypeOnly path="msw" />

package/src/plugin.ts

@@ -1,13 +1,43 @@
-import { camelCase } from '@internals/utils'
-import { definePlugin, type Group } from '@kubb/core'
+import { createGroupConfig } from '@internals/shared'
+import { definePlugin } from '@kubb/core'
 import { pluginFakerName } from '@kubb/plugin-faker'
 import { pluginTsName } from '@kubb/plugin-ts'
 import { handlersGenerator, mswGenerator } from './generators'
 import { resolverMsw } from './resolvers/resolverMsw.ts'
 import type { PluginMsw } from './types.ts'
 
+/**
+ * Canonical plugin name for `@kubb/plugin-msw`. Used for driver lookups and
+ * cross-plugin dependency references.
+ */
 export const pluginMswName = 'plugin-msw' satisfies PluginMsw['name']
 
+/**
+ * Generates MSW request handlers from an OpenAPI spec. Drop them into your
+ * test setup or service worker to mock the API end-to-end. Request path,
+ * method, status, and response body all stay in sync with the spec. Combine
+ * with `@kubb/plugin-faker` (via `parser: 'faker'`) to seed handlers with
+ * realistic data.
+ *
+ * @example
+ * ```ts
+ * import { defineConfig } from 'kubb'
+ * import { pluginTs } from '@kubb/plugin-ts'
+ * import { pluginMsw } from '@kubb/plugin-msw'
+ *
+ * export default defineConfig({
+ *   input: { path: './petStore.yaml' },
+ *   output: { path: './src/gen' },
+ *   plugins: [
+ *     pluginTs(),
+ *     pluginMsw({
+ *       output: { path: './handlers' },
+ *       handlers: true,
+ *     }),
+ *   ],
+ * })
+ * ```
+ */
 export const pluginMsw = definePlugin<PluginMsw>((options) => {
   const {
     output = { path: 'handlers', barrelType: 'named' },
@@ -15,7 +45,6 @@ export const pluginMsw = definePlugin<PluginMsw>((options) => {
     exclude = [],
     include,
     override = [],
-    transformers = {},
     handlers = false,
     parser = 'data',
     baseURL,
@@ -24,24 +53,12 @@ export const pluginMsw = definePlugin<PluginMsw>((options) => {
     generators: userGenerators = [],
   } = options
 
-  const groupConfig = group
-    ? ({
-        ...group,
-        name: group.name
-          ? group.name
-          : (ctx: { group: string }) => {
-              if (group.type === 'path') {
-                return `${ctx.group.split('/')[1]}`
-              }
-              return `${camelCase(ctx.group)}Controller`
-            },
-      } satisfies Group)
-    : undefined
+  const groupConfig = createGroupConfig(group, { suffix: 'Controller', honorName: true })
 
   return {
     name: pluginMswName,
     options,
-    dependencies: [pluginTsName, parser === 'faker' ? pluginFakerName : undefined].filter(Boolean),
+    dependencies: [pluginTsName, parser === 'faker' ? pluginFakerName : null].filter((dependency): dependency is string => Boolean(dependency)),
     hooks: {
       'kubb:plugin:setup'(ctx) {
         const resolver = userResolver ? { ...resolverMsw, ...userResolver } : resolverMsw
@@ -55,7 +72,6 @@ export const pluginMsw = definePlugin<PluginMsw>((options) => {
           include,
           override,
           handlers,
-          transformers,
           resolver,
         })
         ctx.setResolver(resolver)

package/src/resolvers/resolverMsw.ts

@@ -3,11 +3,18 @@ import { defineResolver } from '@kubb/core'
 import type { PluginMsw } from '../types.ts'
 
 /**
- * Naming convention resolver for MSW plugin.
+ * Default resolver used by `@kubb/plugin-msw`. Decides the names and file
+ * paths for every generated MSW handler. Function names get a `Handler`
+ * suffix; the aggregate export is always `handlers`.
  *
- * Provides default naming helpers using camelCase with a `handler` suffix.
+ * @example Resolve a handler name
+ * ```ts
+ * import { resolverMsw } from '@kubb/plugin-msw'
+ *
+ * resolverMsw.resolveName('addPet') // 'addPetHandler'
+ * ```
  */
-export const resolverMsw = defineResolver<PluginMsw>((_ctx) => ({
+export const resolverMsw = defineResolver<PluginMsw>(() => ({
   name: 'default',
   pluginName: 'plugin-msw',
   default(name, type) {
@@ -16,4 +23,13 @@ export const resolverMsw = defineResolver<PluginMsw>((_ctx) => ({
   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'
+  },
 }))

package/src/types.ts

@@ -1,79 +1,93 @@
-import type { ast, Exclude, Generator, Group, Include, Output, Override, PluginFactoryOptions, ResolveNameParams, Resolver } from '@kubb/core'
+import type { ast, Exclude, Generator, Group, Include, Output, Override, PluginFactoryOptions, Resolver } from '@kubb/core'
 
 /**
  * Resolver for MSW that provides naming methods for handler functions.
  */
 export type ResolverMsw = Resolver & {
   /**
-   * Resolves the handler function name for an operation.
+   * Resolves the base handler function name for an operation.
    */
   resolveName(this: ResolverMsw, name: string): string
+  /**
+   * Resolves the output file name for an MSW handler module.
+   */
+  resolvePathName(this: ResolverMsw, name: string, type?: 'file' | 'function' | 'type' | 'const'): string
+  /**
+   * Resolves the handler function name for an operation.
+   */
+  resolveHandlerName(this: ResolverMsw, node: ast.OperationNode): string
+  /**
+   * Resolves the exported handlers collection name.
+   */
+  resolveHandlersName(this: ResolverMsw): string
 }
 
 export type Options = {
   /**
-   * Specify the export location for the files and define the behavior of the output
-   * @default { path: 'handlers', barrelType: 'named' }
+   * Where the generated MSW handlers are written and how they are exported.
+   *
+   * @default { path: 'handlers', barrel: { type: 'named' } }
    */
   output?: Output
+  /**
+   * Base URL prepended to every handler's request URL. When omitted, falls back
+   * to the adapter's server URL (typically `servers[0].url`).
+   */
   baseURL?: string
   /**
-   * Group the MSW mocks 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>>
-  transformers?: {
-    /**
-     * Override the default naming for handlers.
-     */
-    name?: (name: ResolveNameParams['name'], type?: ResolveNameParams['type']) => string
-  }
   /**
-   * Override naming conventions for function names and types.
+   * Override how handler names and file paths are built.
    */
   resolver?: Partial<ResolverMsw> & ThisType<ResolverMsw>
   /**
-   * AST visitor to transform generated nodes.
+   * AST visitor applied to operation nodes before printing.
    */
   transformer?: ast.Visitor
   /**
-   * Create `handlers.ts` file with all handlers grouped by methods.
+   * Emit a `handlers.ts` file that re-exports every handler grouped by HTTP method.
+   * Drop the file into `setupServer(...handlers)` or `setupWorker(...handlers)`.
+   *
    * @default false
    */
   handlers?: boolean
   /**
-   * Which parser to use for generating response data.
+   * Source of the response body returned by each generated handler.
+   * - `'data'` — typed empty/example payload, ready for you to fill in from tests.
+   * - `'faker'` — value produced by `@kubb/plugin-faker`.
    *
    * @default 'data'
    */
   parser?: 'data' | 'faker'
   /**
-   * Additional generators alongside the default generators.
+   * Custom generators that run alongside the built-in MSW generators.
    */
   generators?: Array<Generator<PluginMsw>>
 }
 
 type ResolvedOptions = {
   output: Output
-  group: Group | undefined
+  group: Group | null
   exclude: NonNullable<Options['exclude']>
   include: Options['include']
   override: NonNullable<Options['override']>
   parser: NonNullable<Options['parser']>
   baseURL: Options['baseURL'] | undefined
   handlers: boolean
-  transformers: NonNullable<Options['transformers']>
   resolver: ResolverMsw
 }
 

package/src/utils.ts

@@ -1,90 +1,52 @@
-import type { ast } from '@kubb/core'
+import { ast } from '@kubb/core'
 import type { ResolverFaker } from '@kubb/plugin-faker'
-import type { ResolverTs } from '@kubb/plugin-ts'
 import type { PluginMsw } from './types.ts'
 
-/**
- * Applies a name transformer function to a name if configured, otherwise returns it unchanged.
- */
-export function transformName(name: string, type: 'function' | 'type' | 'file' | 'const', transformers?: PluginMsw['resolvedOptions']['transformers']): string {
-  return transformers?.name?.(name, type) || name
-}
-
-/**
- * Filters responses to only those with 2xx status codes.
- */
-export function getSuccessResponses(node: ast.OperationNode): ast.ResponseNode[] {
-  return node.responses.filter((response) => {
-    const code = Number.parseInt(response.statusCode, 10)
-    return !Number.isNaN(code) && code >= 200 && code < 300
-  })
-}
-
-/**
- * Returns the first 2xx response for an operation, if any.
- */
-export function getPrimarySuccessResponse(node: ast.OperationNode): ast.ResponseNode | undefined {
-  return getSuccessResponses(node)[0]
-}
-
 /**
  * Gets the content type from a response, defaulting to 'application/json' if a schema exists.
  */
-export function getContentType(response: ast.ResponseNode | undefined): string | undefined {
-  return getResponseContentType(response) ?? (hasResponseSchema(response) ? 'application/json' : undefined)
+export function getContentType(response: ast.ResponseNode | null | undefined): string | null {
+  if (!hasResponseSchema(response)) {
+    return null
+  }
+
+  return getResponseContentType(response) ?? 'application/json'
 }
 
 /**
  * Determines if a response has a schema that is not void or any.
  */
-export function hasResponseSchema(response: ast.ResponseNode | undefined): boolean {
-  return !!getResponseContentType(response) || (!!response?.schema && response.schema.type !== 'void' && response.schema.type !== 'any')
-}
-
-function getResponseContentType(response: ast.ResponseNode | undefined): string | undefined {
-  const contentType = response as unknown as { mediaType?: string | null; contentType?: string | null } | undefined
-  const value = contentType?.mediaType ?? contentType?.contentType
-  return typeof value === 'string' && value.length > 0 ? value : undefined
+export function hasResponseSchema(response: ast.ResponseNode | null | undefined): boolean {
+  const schema = response?.content?.find((entry) => entry.schema)?.schema
+  return !!schema && schema.type !== 'void' && schema.type !== 'any'
 }
 
 /**
- * Maps all operation responses to their type names, including status code or 'default' for default responses.
+ * Picks the content type used for the mocked response header. When a response declares multiple
+ * content types, JSON is preferred (the faker mock body is JSON), otherwise the first declared type.
  */
-export function getResponseTypes(node: ast.OperationNode, tsResolver: ResolverTs): Array<[statusCode: number | 'default', typeName: string]> {
-  const types: Array<[number | 'default', string]> = []
-
-  for (const response of node.responses) {
-    if (response.statusCode === 'default') {
-      types.push(['default', tsResolver.resolveResponseName(node)])
-      continue
-    }
-
-    const code = Number.parseInt(response.statusCode, 10)
-    if (Number.isNaN(code)) continue
-
-    if (code >= 200 && code < 300) {
-      types.push([code, tsResolver.resolveResponseName(node)])
-      continue
-    }
-
-    types.push([code, tsResolver.resolveResponseStatusName(node, response.statusCode)])
-  }
-
-  return types
+function getResponseContentType(response: ast.ResponseNode | null | undefined): string | null {
+  const contents = response?.content ?? []
+  const jsonEntry = contents.find((entry) => {
+    const baseType = entry.contentType?.split(';')[0]?.trim().toLowerCase()
+    return baseType === 'application/json' || baseType?.endsWith('+json')
+  })
+  const value = (jsonEntry ?? contents[0])?.contentType
+  return typeof value === 'string' && value.length > 0 ? value : null
 }
 
 /**
  * Converts an HTTP method to its lowercase MSW equivalent (e.g., 'POST' → 'post').
  */
 export function getMswMethod(node: ast.OperationNode): string {
-  return node.method.toLowerCase()
+  return ast.isHttpOperationNode(node) ? node.method.toLowerCase() : ''
 }
 
 /**
  * Converts an OpenAPI-style path to an Express/MSW-style path by replacing `{param}` with `:param`.
  */
 export function getMswUrl(node: ast.OperationNode): string {
-  return node.path.replaceAll('{', ':').replaceAll('}', '')
+  return ast.isHttpOperationNode(node) ? node.path.replaceAll('{', ':').replaceAll('}', '') : ''
 }
 
 /**
@@ -104,6 +66,9 @@ export function resolveFakerMeta(
 
   return {
     name: fakerResolver.resolveResponseName(node),
-    file: fakerResolver.resolveFile({ name: node.operationId, extname: '.ts', tag, path: node.path }, { root, output: fakerOutput, group: fakerGroup }),
+    file: fakerResolver.resolveFile(
+      { name: node.operationId, extname: '.ts', tag, path: node.path },
+      { root, output: fakerOutput, group: fakerGroup ?? undefined },
+    ),
   }
 }