@kubb/plugin-msw 5.0.0-beta.56 → 5.0.0-beta.73

package/src/components/MockWithFaker.tsx

@@ -1,70 +0,0 @@
-import { getPrimarySuccessResponse } from '@internals/shared'
-import { Url } 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 } from '../utils.ts'
-
-type Props = {
-  name: string
-  typeName: string
-  requestTypeName?: string | null
-  fakerName: string
-  baseURL: string | null | undefined
-  node: ast.OperationNode
-}
-
-const declarationPrinter = functionPrinter({ mode: 'declaration' })
-
-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 = Url.toPath(getMswUrl(node))
-
-  const headers = [contentType ? `'Content-Type': '${contentType}'` : null].filter(Boolean)
-
-  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 ?? ''}>
-        {`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)), {
-      status: ${statusCode},
-      ${
-        headers.length
-          ? `  headers: {
-        ${headers.join(', \n')}
-      },`
-          : ''
-      }
-    })
-  })`}
-      </Function>
-    </File.Source>
-  )
-}

package/src/components/Response.tsx

@@ -1,52 +0,0 @@
-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
-  name: string
-  response: ast.ResponseNode
-  key?: string | number | null
-}
-
-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}'` : null].filter(Boolean)
-
-  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 ?? ''}>
-        {`
-    return new Response(JSON.stringify(data), {
-      status: ${statusCode},
-      ${
-        headers.length
-          ? `  headers: {
-        ${headers.join(', \n')}
-      },`
-          : ''
-      }
-    })`}
-      </Function>
-    </File.Source>
-  )
-}

package/src/components/index.ts

@@ -1,3 +0,0 @@
-export { Mock } from './Mock.tsx'
-export { MockWithFaker } from './MockWithFaker.tsx'
-export { Response } from './Response.tsx'

package/src/generators/handlersGenerator.ts

@@ -1,49 +0,0 @@
-import { ast, defineGenerator } from '@kubb/core'
-import type { PluginMsw } from '../types'
-
-/**
- * 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',
-  operations(nodes, ctx) {
-    const { resolver, config, root } = ctx
-    const { output, group } = ctx.options
-
-    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 = 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: group ?? undefined },
-      )
-      return ast.createImport({ name: [operationName], root: file.path, path: operationFile.path })
-    })
-
-    const handlers = nodes.map((node) => `${resolver.resolveHandlerName(node)}()`)
-
-    return [
-      ast.createFile({
-        baseName: file.baseName,
-        path: file.path,
-        meta: file.meta,
-        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,
-        sources: [
-          ast.createSource({
-            name: handlersName,
-            isIndexable: true,
-            isExportable: true,
-            nodes: [ast.createText(`export const ${handlersName} = ${JSON.stringify(handlers).replaceAll('"', '')} as const`)],
-          }),
-        ],
-      }),
-    ]
-  },
-})

package/src/generators/index.ts

@@ -1,2 +0,0 @@
-export { handlersGenerator } from './handlersGenerator.ts'
-export { mswGenerator } from './mswGenerator.tsx'

package/src/generators/mswGenerator.tsx

@@ -1,96 +0,0 @@
-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 { Mock, MockWithFaker, Response } from '../components'
-import type { PluginMsw } from '../types'
-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,
-  operation(node, ctx) {
-    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: 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) : null
-    const faker =
-      parser === 'faker' && fakerPlugin
-        ? resolveFakerMeta(node, {
-            root,
-            fakerResolver: driver.getResolver(pluginFakerName),
-            fakerOutput: fakerPlugin.options?.output ?? output,
-            fakerGroup: fakerPlugin.options?.group ?? null,
-          })
-        : null
-
-    const pluginTs = driver.getPlugin(pluginTsName)
-    if (!pluginTs) return null
-    const tsResolver = driver.getResolver(pluginTsName)
-
-    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 ?? undefined },
-      ),
-      responseName: tsResolver.resolveResponseName(node),
-    }
-
-    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) : null
-
-    return (
-      <File
-        baseName={mock.file.baseName}
-        path={mock.file.path}
-        meta={mock.file.meta}
-        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" />
-        <File.Import
-          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.Import name={[faker.name]} root={mock.file.path} path={faker.file.path} />}
-
-        {types
-          .filter(([code]) => code !== 'default')
-          .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 +0,0 @@
-export { default, pluginMsw, pluginMswName } from './plugin.ts'
-export type { PluginMsw } from './types.ts'

package/src/plugin.ts

@@ -1,94 +0,0 @@
-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', barrel: { type: 'named' } },
-    group,
-    exclude = [],
-    include,
-    override = [],
-    handlers = false,
-    parser = 'data',
-    baseURL,
-    resolver: userResolver,
-    transformer: userTransformer,
-    generators: userGenerators = [],
-  } = options
-
-  const groupConfig = createGroupConfig(group)
-
-  return {
-    name: pluginMswName,
-    options,
-    dependencies: [pluginTsName, parser === 'faker' ? pluginFakerName : null].filter((dependency): dependency is string => Boolean(dependency)),
-    hooks: {
-      'kubb:plugin:setup'(ctx) {
-        const resolver = userResolver ? { ...resolverMsw, ...userResolver } : resolverMsw
-
-        ctx.setOptions({
-          output,
-          parser,
-          baseURL,
-          group: groupConfig,
-          exclude,
-          include,
-          override,
-          handlers,
-          resolver,
-        })
-        ctx.setResolver(resolver)
-        if (userTransformer) {
-          ctx.setTransformer(userTransformer)
-        }
-
-        ctx.addGenerator(mswGenerator)
-        if (handlers) {
-          ctx.addGenerator(handlersGenerator)
-        }
-        for (const gen of userGenerators) {
-          ctx.addGenerator(gen)
-        }
-      },
-    },
-  }
-})
-
-export default pluginMsw

package/src/resolvers/resolverMsw.ts

@@ -1,35 +0,0 @@
-import { camelCase, toFilePath } from '@internals/utils'
-import { defineResolver } from '@kubb/core'
-import type { PluginMsw } from '../types.ts'
-
-/**
- * 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`.
- *
- * @example Resolve a handler name
- * ```ts
- * import { resolverMsw } from '@kubb/plugin-msw'
- *
- * resolverMsw.resolveName('addPet') // 'addPetHandler'
- * ```
- */
-export const resolverMsw = defineResolver<PluginMsw>(() => ({
-  name: 'default',
-  pluginName: 'plugin-msw',
-  default(name, type) {
-    return type === 'file' ? toFilePath(name) : camelCase(name)
-  },
-  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,98 +0,0 @@
-import type { ast, Exclude, Generator, Group, Include, Output, OutputOptions, Override, PluginFactoryOptions, Resolver } from '@kubb/core'
-
-/**
- * Resolver for MSW that provides naming methods for handler functions.
- */
-export type ResolverMsw = Resolver & {
-  /**
-   * 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
-}
-
-/**
- * Where the generated MSW handlers are written and how they are exported, plus the optional
- * `group` strategy. The `group` option organizes `output.mode: 'directory'` output into per-tag or per-path subdirectories.
- *
- * @default { path: 'handlers', barrel: { type: 'named' } }
- */
-export type Options = OutputOptions & {
-  /**
-   * 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
-  /**
-   * Skip operations matching at least one entry in the list.
-   */
-  exclude?: Array<Exclude>
-  /**
-   * Restrict generation to operations matching at least one entry in the list.
-   */
-  include?: Array<Include>
-  /**
-   * Apply a different options object to operations matching a pattern.
-   */
-  override?: Array<Override<ResolvedOptions>>
-  /**
-   * Override how handler names and file paths are built.
-   */
-  resolver?: Partial<ResolverMsw> & ThisType<ResolverMsw>
-  /**
-   * AST visitor applied to operation nodes before printing.
-   */
-  transformer?: ast.Visitor
-  /**
-   * 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
-  /**
-   * 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'
-  /**
-   * Custom generators that run alongside the built-in MSW generators.
-   */
-  generators?: Array<Generator<PluginMsw>>
-}
-
-type ResolvedOptions = {
-  output: Output
-  group: Group | null
-  exclude: NonNullable<Options['exclude']>
-  include: Options['include']
-  override: NonNullable<Options['override']>
-  parser: NonNullable<Options['parser']>
-  baseURL: Options['baseURL'] | undefined
-  handlers: boolean
-  resolver: ResolverMsw
-}
-
-export type PluginMsw = PluginFactoryOptions<'plugin-msw', Options, ResolvedOptions, ResolverMsw>
-
-declare global {
-  namespace Kubb {
-    interface PluginRegistry {
-      'plugin-msw': PluginMsw
-    }
-  }
-}

package/src/utils.ts

@@ -1,74 +0,0 @@
-import { ast } from '@kubb/core'
-import type { ResolverFaker } from '@kubb/plugin-faker'
-import type { PluginMsw } from './types.ts'
-
-/**
- * Gets the content type from a response, defaulting to 'application/json' if a schema exists.
- */
-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 | null | undefined): boolean {
-  const schema = response?.content?.find((entry) => entry.schema)?.schema
-  return !!schema && schema.type !== 'void' && schema.type !== 'any'
-}
-
-/**
- * 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.
- */
-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 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 ast.isHttpOperationNode(node) ? 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 ?? undefined },
-    ),
-  }
-}