@kubb/plugin-msw 5.0.0-alpha.9 → 5.0.0-beta.100

package/src/components/MockWithFaker.tsx

@@ -1,57 +0,0 @@
-import { URLPath } from '@internals/utils'
-import type { OasTypes, Operation } from '@kubb/oas'
-import { File, Function, FunctionParams } from '@kubb/react-fabric'
-import type { FabricReactNode } from '@kubb/react-fabric/types'
-
-type Props = {
-  /**
-   * Name of the function
-   */
-  name: string
-  typeName: string
-  fakerName: string
-  baseURL: string | undefined
-  operation: Operation
-}
-
-export function MockWithFaker({ baseURL = '', name, fakerName, typeName, operation }: Props): FabricReactNode {
-  const method = operation.method
-  const successStatusCodes = operation.getResponseStatusCodes().filter((code) => code.startsWith('2'))
-  const statusCode = successStatusCodes.length > 0 ? Number(successStatusCodes[0]) : 200
-
-  const responseObject = operation.getResponseByStatusCode(statusCode) as OasTypes.ResponseObject
-  const contentType = Object.keys(responseObject.content || {})?.[0]
-  const url = new URLPath(operation.path).toURLPath().replace(/([^/]):/g, '$1\\\\:')
-
-  const headers = [contentType ? `'Content-Type': '${contentType}'` : undefined].filter(Boolean)
-
-  const params = FunctionParams.factory({
-    data: {
-      type: `${typeName} | ((
-        info: Parameters<Parameters<typeof http.${method}>[1]>[0],
-      ) => Response | Promise<Response>)`,
-      optional: true,
-    },
-  })
-
-  return (
-    <File.Source name={name} isIndexable isExportable>
-      <Function name={name} export params={params.toConstructor()}>
-        {`return http.${method}('${baseURL}${url.replace(/([^/]):/g, '$1\\\\:')}', function handler(info) {
-    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,46 +0,0 @@
-import type { OasTypes, Operation } from '@kubb/oas'
-import { File, Function, FunctionParams } from '@kubb/react-fabric'
-import type { FabricReactNode } from '@kubb/react-fabric/types'
-
-type Props = {
-  typeName: string
-  operation: Operation
-  name: string
-  statusCode: number
-}
-
-export function Response({ name, typeName, operation, statusCode }: Props): FabricReactNode {
-  const responseObject = operation.getResponseByStatusCode(statusCode) as OasTypes.ResponseObject
-  const contentType = Object.keys(responseObject.content || {})?.[0]
-
-  const headers = [contentType ? `'Content-Type': '${contentType}'` : undefined].filter(Boolean)
-
-  const hasResponseSchema = contentType && responseObject?.content?.[contentType]?.schema !== undefined
-
-  const params = FunctionParams.factory({
-    data: {
-      type: `${typeName}`,
-      optional: !hasResponseSchema,
-    },
-  })
-
-  const responseName = `${name}Response${statusCode}`
-
-  return (
-    <File.Source name={responseName} isIndexable isExportable>
-      <Function name={responseName} export params={params.toConstructor()}>
-        {`
-    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 { 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 { Handlers } from '../components/Handlers.tsx'
-import type { PluginMsw } from '../types'
-
-export const handlersGenerator = createReactGenerator<PluginMsw>({
-  name: 'plugin-msw',
-  Operations({ operations, generator, plugin }) {
-    const driver = usePluginDriver()
-
-    const oas = useOas()
-    const { getName, getFile } = useOperationManager(generator)
-
-    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' })
-
-      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 })}()`)
-
-    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 })}
-      >
-        {imports}
-        <Handlers name={'handlers'} 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,96 +0,0 @@
-import { usePluginDriver } from '@kubb/core/hooks'
-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 { Mock, MockWithFaker, Response } from '../components'
-import type { PluginMsw } from '../types'
-
-export const mswGenerator = createReactGenerator<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)
-
-    const mock = {
-      name: getName(operation, { type: 'function' }),
-      file: getFile(operation),
-    }
-
-    const faker = {
-      file: getFile(operation, { pluginName: pluginFakerName }),
-      schemas: getSchemas(operation, { pluginName: pluginFakerName, type: 'function' }),
-    }
-
-    const type = {
-      file: getFile(operation, { pluginName: pluginTsName }),
-      schemas: getSchemas(operation, { pluginName: pluginTsName, type: 'type' }),
-    }
-
-    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
-      }
-
-      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])
-    }
-
-    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 })}
-      >
-        <File.Import name={['http']} path="msw" />
-        <File.Import name={['ResponseResolver']} isTypeOnly path="msw" />
-        <File.Import
-          name={Array.from(new Set([type.schemas.response.name, ...types.map((t) => t[1])]))}
-          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} />
-        )}
-
-        {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} />
-        )}
-      </File>
-    )
-  },
-})

package/src/index.ts

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

package/src/plugin.ts

@@ -1,115 +0,0 @@
-import path from 'node:path'
-import { camelCase } from '@internals/utils'
-import { createPlugin, type Group, getBarrelFiles, getMode } 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 type { PluginMsw } from './types.ts'
-
-export const pluginMswName = 'plugin-msw' satisfies PluginMsw['name']
-
-export const pluginMsw = createPlugin<PluginMsw>((options) => {
-  const {
-    output = { path: 'handlers', barrelType: 'named' },
-    group,
-    exclude = [],
-    include,
-    override = [],
-    transformers = {},
-    handlers = false,
-    parser = 'data',
-    generators = [mswGenerator, handlers ? handlersGenerator : undefined].filter(Boolean),
-    contentType,
-    baseURL,
-  } = 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
-          ? group.name
-          : (ctx) => {
-              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',
-      })
-
-      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)
-
-      const barrelFiles = await getBarrelFiles(this.fabric.files, {
-        type: output.barrelType ?? 'named',
-        root,
-        output,
-        meta: {
-          pluginName: this.plugin.name,
-        },
-      })
-
-      await this.upsertFile(...barrelFiles)
-    },
-  }
-})

package/src/types.ts

@@ -1,65 +0,0 @@
-import type { Group, Output, PluginFactoryOptions, ResolveNameParams } 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'
-
-export type Options = {
-  /**
-   * Specify the export location for the files and define the behavior of the output
-   * @default { path: 'mocks', barrelType: 'named' }
-   */
-  output?: Output<Oas>
-  /**
-   * Define which contentType should be used.
-   * By default, the first JSON valid mediaType is used
-   */
-  contentType?: contentType
-  baseURL?: string
-  /**
-   * Group the MSW mocks based on the provided name.
-   */
-  group?: Group
-  /**
-   * Array containing exclude parameters to exclude/skip tags/operations/methods/paths.
-   */
-  exclude?: Array<Exclude>
-  /**
-   * Array containing include parameters to include tags/operations/methods/paths.
-   */
-  include?: Array<Include>
-  /**
-   * Array containing override parameters to override `options` based on tags/operations/methods/paths.
-   */
-  override?: Array<Override<ResolvedOptions>>
-  transformers?: {
-    /**
-     * Customize the names based on the type that is provided by the plugin.
-     */
-    name?: (name: ResolveNameParams['name'], type?: ResolveNameParams['type']) => string
-  }
-  /**
-   * 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.
-   * @default 'data'
-   */
-  parser?: 'data' | 'faker'
-  /**
-   * Define some generators next to the msw generators
-   */
-  generators?: Array<Generator<PluginMsw>>
-}
-type ResolvedOptions = {
-  output: Output<Oas>
-  group: Options['group']
-  parser: NonNullable<Options['parser']>
-  baseURL: Options['baseURL'] | undefined
-}
-
-export type PluginMsw = PluginFactoryOptions<'plugin-msw', Options, ResolvedOptions, never, ResolvePathOptions>