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

package/src/generators/handlersGenerator.tsx

@@ -1,37 +1,37 @@
-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'
+import { transformName } from '../utils.ts'
 
-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, transformers } = ctx.options
 
-    const oas = useOas()
-    const { getName, getFile } = useOperationManager(generator)
+    const file = resolver.resolveFile({ name: 'handlers', 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 = transformName(resolver.resolveName(node.operationId), 'function', transformers)
+      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) => `${transformName(resolver.resolveName(node.operationId), 'function', transformers)}()`)
 
     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} />

package/src/generators/mswGenerator.tsx

@@ -1,94 +1,83 @@
-import { usePluginDriver } from '@kubb/core/hooks'
+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 { getResponseTypes, getSuccessResponses, resolveFakerMeta, transformName } 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, transformers } = ctx.options
 
+    const fileName = resolver.resolveName(node.operationId)
     const mock = {
-      name: getName(operation, { type: 'function' }),
-      file: getFile(operation),
+      name: transformName(fileName, 'function', transformers),
+      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 = getResponseTypes(node, tsResolver)
+    const successResponses = getSuccessResponses(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,15 +1,14 @@
-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,
@@ -19,97 +18,61 @@ export const pluginMsw = createPlugin<PluginMsw>((options) => {
     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(Boolean),
+    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,
+          transformers,
+          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,19 @@
+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>((_ctx) => ({
+  name: 'default',
+  pluginName: 'plugin-msw',
+  default(name, type) {
+    return camelCase(name, { isFile: type === 'file' })
+  },
+  resolveName(name) {
+    return camelCase(name, { suffix: 'handler' })
+  },
+}))

package/src/types.ts

@@ -1,65 +1,88 @@
-import type { Group, Output, PluginFactoryOptions, ResolveNameParams } from '@kubb/core'
+import type { ast, Exclude, Generator, Group, Include, Output, Override, PluginFactoryOptions, ResolveNameParams, Resolver } from '@kubb/core'
 
-import type { contentType, Oas } from '@kubb/oas'
-import type { Exclude, Include, Override, ResolvePathOptions } from '@kubb/plugin-oas'
-import type { Generator } from '@kubb/plugin-oas/generators'
+/**
+ * Resolver for MSW that provides naming methods for handler functions.
+ */
+export type ResolverMsw = Resolver & {
+  /**
+   * Resolves the handler function name for an operation.
+   */
+  resolveName(this: ResolverMsw, name: string): string
+}
 
 export type Options = {
   /**
    * Specify the export location for the files and define the behavior of the output
-   * @default { path: 'mocks', barrelType: 'named' }
+   * @default { path: 'handlers', barrelType: 'named' }
    */
-  output?: Output<Oas>
-  /**
-   * Define which contentType should be used.
-   * By default, the first JSON valid mediaType is used
-   */
-  contentType?: contentType
+  output?: Output
   baseURL?: string
   /**
    * Group the MSW mocks based on the provided name.
    */
   group?: Group
   /**
-   * Array containing exclude parameters to exclude/skip tags/operations/methods/paths.
+   * Tags, operations, or paths to exclude from generation.
    */
   exclude?: Array<Exclude>
   /**
-   * Array containing include parameters to include tags/operations/methods/paths.
+   * Tags, operations, or paths to include in generation.
    */
   include?: Array<Include>
   /**
-   * Array containing override parameters to override `options` based on tags/operations/methods/paths.
+   * Override options for specific tags, operations, or paths.
    */
   override?: Array<Override<ResolvedOptions>>
   transformers?: {
     /**
-     * Customize the names based on the type that is provided by the plugin.
+     * Override the default naming for handlers.
      */
     name?: (name: ResolveNameParams['name'], type?: ResolveNameParams['type']) => string
   }
+  /**
+   * Override naming conventions for function names and types.
+   */
+  resolver?: Partial<ResolverMsw> & ThisType<ResolverMsw>
+  /**
+   * AST visitor to transform generated nodes.
+   */
+  transformer?: ast.Visitor
   /**
    * Create `handlers.ts` file with all handlers grouped by methods.
    * @default false
    */
   handlers?: boolean
   /**
-   * Which parser should be used before returning the data to the Response of MSW.
-   * - 'data' uses your custom data to generate the data for the response.
-   * - 'faker' uses @kubb/plugin-faker to generate the data for the response.
+   * Which parser to use for generating response data.
+   *
    * @default 'data'
    */
   parser?: 'data' | 'faker'
   /**
-   * Define some generators next to the msw generators
+   * Additional generators alongside the default generators.
    */
   generators?: Array<Generator<PluginMsw>>
 }
+
 type ResolvedOptions = {
-  output: Output<Oas>
-  group: Options['group']
+  output: Output
+  group: Group | undefined
+  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
 }
 
-export type PluginMsw = PluginFactoryOptions<'plugin-msw', Options, ResolvedOptions, never, ResolvePathOptions>
+export type PluginMsw = PluginFactoryOptions<'plugin-msw', Options, ResolvedOptions, ResolverMsw>
+
+declare global {
+  namespace Kubb {
+    interface PluginRegistry {
+      'plugin-msw': PluginMsw
+    }
+  }
+}

package/src/utils.ts

@@ -0,0 +1,109 @@
+import type { 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)
+}
+
+/**
+ * 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
+}
+
+/**
+ * Maps all operation responses to their type names, including status code or 'default' for default responses.
+ */
+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
+}
+
+/**
+ * Converts an HTTP method to its lowercase MSW equivalent (e.g., 'POST' → 'post').
+ */
+export function getMswMethod(node: ast.OperationNode): string {
+  return 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('}', '')
+}
+
+/**
+ * Resolves faker metadata for an MSW operation, including response name and file path.
+ */
+export function resolveFakerMeta(
+  node: ast.OperationNode,
+  options: {
+    root: string
+    fakerResolver: ResolverFaker
+    fakerOutput: PluginMsw['resolvedOptions']['output']
+    fakerGroup: PluginMsw['resolvedOptions']['group']
+  },
+): { name: string; file: { path: string } } {
+  const { root, fakerResolver, fakerOutput, fakerGroup } = options
+  const tag = node.tags[0] ?? 'default'
+
+  return {
+    name: fakerResolver.resolveResponseName(node),
+    file: fakerResolver.resolveFile({ name: node.operationId, extname: '.ts', tag, path: node.path }, { root, output: fakerOutput, group: fakerGroup }),
+  }
+}