@kubb/plugin-msw 5.0.0-beta.10 → 5.0.0-beta.100

package/extension.yaml

@@ -1,233 +0,0 @@
-$schema: https://kubb.dev/schemas/extension.json
-kind: plugin
-id: plugin-msw
-name: MSW
-description: Generate Mock Service Worker (MSW) handlers from OpenAPI specifications.
-category: mocks
-type: official
-npmPackage: '@kubb/plugin-msw'
-docsPath: /plugins/plugin-msw
-repo: https://github.com/kubb-labs/plugins
-maintainers:
-  - name: Stijn Van Hulle
-    github: stijnvanhulle
-compatibility:
-  kubb: '>=5.0.0'
-  node: '>=22'
-tags:
-  - msw
-  - mock-service-worker
-  - api-mocking
-  - mocks
-  - testing
-  - codegen
-  - openapi
-dependencies:
-  - plugin-ts
-  - plugin-faker
-resources:
-  documentation: https://kubb.dev/plugins/plugin-msw
-  repository: https://github.com/kubb-labs/plugins
-  issues: https://github.com/kubb-labs/plugins/issues
-  changelog: https://github.com/kubb-labs/plugins/blob/main/packages/plugin-msw/CHANGELOG.md
-  codesandbox: https://codesandbox.io/p/github/kubb-labs/plugins/main/examples/msw
-featured: false
-icon:
-  light: https://kubb.dev/feature/msw.svg
-intro: |
-  # @kubb/plugin-msw
-
-  Generate [MSW](https://mswjs.io/) API mock handlers from your OpenAPI schema. Mock API requests in development and tests with type-safe handlers.
-options:
-  - name: output
-    type: Output
-    required: false
-    default: "{ path: 'handlers', barrel: { type: 'named' } }"
-    description: Specify the export location for the files and define the behavior of the output.
-    properties:
-      - name: path
-        type: string
-        required: true
-        description: Output directory or file for the generated code, relative to the global `output.path`.
-        tip: |
-          if `output.path` is a file, `group` cannot be used.
-        default: "'handlers'"
-      - name: barrel
-        type: "{ type: 'named' | 'all', nested?: boolean } | false"
-        required: false
-        default: "{ type: 'named' }"
-        description: "Configure barrel file export strategy. Use `type` to control named vs. wildcard exports; set `nested: true` to generate hierarchical barrels in subdirectories."
-        examples:
-          - name: all
-            files:
-              - lang: typescript
-                code: |
-                  export * from './gen/petService.ts'
-                twoslash: false
-          - name: named
-            files:
-              - lang: typescript
-                code: |
-                  export { PetService } from './gen/petService.ts'
-                twoslash: false
-          - name: 'false'
-            files:
-              - lang: typescript
-                code: ''
-                twoslash: false
-      - name: banner
-        type: 'string | ((node: RootNode) => string)'
-        required: false
-        description: Add a banner comment at the top of every generated file. Accepts a static string or a function that receives the `RootNode` and returns a string.
-      - name: footer
-        type: 'string | ((node: RootNode) => string)'
-        required: false
-        description: Add a footer comment at the end of every generated file. Accepts a static string or a function that receives the `RootNode` and returns a string.
-      - name: override
-        type: boolean
-        required: false
-        default: 'false'
-        description: Whether Kubb overrides existing external files that can be generated if they already exist.
-  - name: handlers
-    type: boolean
-    required: false
-    default: 'false'
-    description: Create a `handlers.ts` file with all handlers grouped by methods.
-  - name: baseURL
-    type: string
-    required: false
-    description: Sets a custom base URL for all generated calls. When not set, the base URL is automatically taken from the OAS spec via the adapter (e.g. the `servers[0].url` field).
-  - name: group
-    type: Group
-    required: false
-    description: |
-      Grouping combines files in a folder based on a specific `type`.
-    examples:
-      - name: kubb.config.ts
-        files:
-          - lang: typescript
-            code: |
-              group: {
-                type: 'tag',
-                name({ group }) {
-                  return `${group}Controller`
-                }
-              }
-            twoslash: false
-    body: |
-      With the configuration above, the generator emits:
-
-      ```text
-      .
-      ├── src/
-      │   └── petController/
-      │   │   ├── addPet.ts
-      │   │   └── getPet.ts
-      │   └── storeController/
-      │       ├── createStore.ts
-      │       └── getStoreById.ts
-      ├── petStore.yaml
-      ├── kubb.config.ts
-      └── package.json
-      ```
-    properties:
-      - name: type
-        type: "'tag'"
-        required: true
-        description: Specify the property to group files by. Required when `group` is defined.
-        note: |
-          `Required: true*` means this is required only when the `group` option is used. The `group` option itself is optional.
-        body: |
-          - `'tag'`: Uses the first tag from `operation.getTags().at(0)?.name`
-      - name: name
-        type: '(context: GroupContext) => string'
-        required: false
-        default: (ctx) => `${ctx.group}Controller`
-        description: Return the name of a group based on the group name. This is used for file and identifier generation.
-  - name: parser
-    type: "'data' | 'faker'"
-    required: false
-    default: "'data'"
-    description: Choose which parser to use when generating response data.
-    body: |
-      - `'faker'` will use `@kubb/plugin-faker` to generate the data for the response.
-      - `'data'` will use your custom data to generate the data for the response.
-  - name: include
-    type: Array<Include>
-    required: false
-    description: Array containing include parameters to include tags, operations, methods, paths, or content types.
-    codeBlock:
-      lang: typescript
-      title: Include
-      code: |
-        export type Include = {
-          type: 'tag' | 'operationId' | 'path' | 'method' | 'contentType'
-          pattern: string | RegExp
-        }
-  - name: exclude
-    type: Array<Exclude>
-    required: false
-    description: Array containing exclude parameters to exclude or skip tags, operations, methods, paths, or content types.
-    codeBlock:
-      lang: typescript
-      title: Exclude
-      code: |
-        export type Exclude = {
-          type: 'tag' | 'operationId' | 'path' | 'method' | 'contentType'
-          pattern: string | RegExp
-        }
-  - name: override
-    type: Array<Override>
-    required: false
-    description: Array containing override parameters to override `options` based on tags, operations, methods, paths, or content types.
-    codeBlock:
-      lang: typescript
-      title: Override
-      code: |
-        export type Override = {
-          type: 'tag' | 'operationId' | 'path' | 'method' | 'contentType'
-          pattern: string | RegExp
-          options: PluginOptions
-        }
-  - name: generators
-    type: Array<Generator<PluginMsw>>
-    required: false
-    experimental: true
-    description: |
-      Define additional generators next to the built-in generators.
-
-      See [Generators](https://kubb.dev/docs/5.x/guides/creating-plugins) for more information on how to use generators.
-examples:
-  - name: kubb.config.ts
-    files:
-      - lang: typescript
-        code: |
-          import { defineConfig } from 'kubb'
-          import { pluginMsw } from '@kubb/plugin-msw'
-          import { pluginTs } from '@kubb/plugin-ts'
-
-          export default defineConfig({
-            input: {
-              path: './petStore.yaml',
-            },
-            output: {
-              path: './src/gen',
-            },
-            plugins: [
-              pluginTs(),
-              pluginMsw({
-                output: {
-                  path: './mocks',
-                  barrel: { type: 'named' },
-                  banner: '/* eslint-disable no-alert, no-console */',
-                  footer: '',
-                },
-                group: {
-                  type: 'tag',
-                  name: ({ group }) => `${group}Service`,
-                },
-                handlers: true,
-              }),
-            ],
-          })
-        twoslash: false

package/src/components/Handlers.tsx

@@ -1,19 +0,0 @@
-import { File } from '@kubb/renderer-jsx'
-import type { KubbReactNode } from '@kubb/renderer-jsx/types'
-
-type HandlersProps = {
-  /**
-   * Name of the function
-   */
-  name: string
-  // custom
-  handlers: string[]
-}
-
-export function Handlers({ name, handlers }: HandlersProps): KubbReactNode {
-  return (
-    <File.Source name={name} isIndexable isExportable>
-      {`export const ${name} = ${JSON.stringify(handlers).replaceAll(`"`, '')} as const`}
-    </File.Source>
-  )
-}

package/src/components/Mock.tsx

@@ -1,71 +0,0 @@
-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, hasResponseSchema } from '../utils.ts'
-
-type Props = {
-  name: string
-  typeName: string
-  requestTypeName?: string
-  baseURL: string | undefined
-  node: ast.OperationNode
-}
-
-const declarationPrinter = functionPrinter({ mode: 'declaration' })
-
-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 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: `${dataType} | ${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), {
-      status: ${statusCode},
-      ${
-        headers.length
-          ? `  headers: {
-        ${headers.join(', \n')}
-      },`
-          : ''
-      }
-    })
-  })`}
-      </Function>
-    </File.Source>
-  )
-}

package/src/components/MockWithFaker.tsx

@@ -1,70 +0,0 @@
-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 } from '../utils.ts'
-
-type Props = {
-  name: string
-  typeName: string
-  requestTypeName?: string
-  fakerName: string
-  baseURL: string | 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 = new URLPath(getMswUrl(node)).toURLPath()
-
-  const headers = [contentType ? `'Content-Type': '${contentType}'` : undefined].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}'` : undefined].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,4 +0,0 @@
-export { Handlers } from './Handlers.tsx'
-export { Mock } from './Mock.tsx'
-export { MockWithFaker } from './MockWithFaker.tsx'
-export { Response } from './Response.tsx'

package/src/generators/handlersGenerator.tsx

@@ -1,41 +0,0 @@
-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 = defineGenerator<PluginMsw>({
-  name: 'plugin-msw',
-  renderer: jsxRenderer,
-  operations(nodes, ctx) {
-    const { resolver, config, root, adapter } = ctx
-    const { output, group } = ctx.options
-
-    const handlersName = resolver.resolveHandlersName()
-    const file = resolver.resolveFile({ name: resolver.resolvePathName(handlersName, 'file'), extname: '.ts' }, { root, output, group })
-
-    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 = 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 })}
-      >
-        {imports}
-        <Handlers name={handlersName} handlers={handlers} />
-      </File>
-    )
-  },
-})

package/src/generators/index.ts

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

package/src/generators/mswGenerator.tsx

@@ -1,86 +0,0 @@
-import { getOperationSuccessResponses, resolveResponseTypes } from '@internals/shared'
-import { 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'
-
-export const mswGenerator = defineGenerator<PluginMsw>({
-  name: 'msw',
-  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: resolver.resolveHandlerName(node),
-      file: resolver.resolveFile({ name: fileName, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path }, { root, output, group }),
-    }
-
-    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: 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 types = resolveResponseTypes(node, tsResolver)
-    const successResponses = getOperationSuccessResponses(node)
-    const hasSuccessSchema = successResponses.some((response) => !!response.schema)
-
-    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={resolver.resolveBanner(adapter.inputNode, { output, config })}
-        footer={resolver.resolveFooter(adapter.inputNode, { output, config })}
-      >
-        <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,76 +0,0 @@
-import { camelCase } from '@internals/utils'
-import { definePlugin, type Group } 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'
-
-export const pluginMswName = 'plugin-msw' satisfies PluginMsw['name']
-
-export const pluginMsw = definePlugin<PluginMsw>((options) => {
-  const {
-    output = { path: 'handlers', barrelType: 'named' },
-    group,
-    exclude = [],
-    include,
-    override = [],
-    handlers = false,
-    parser = 'data',
-    baseURL,
-    resolver: userResolver,
-    transformer: userTransformer,
-    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
-
-  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
-
-        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