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

package/src/plugin.ts

@@ -1,115 +1,76 @@
-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,
     exclude = [],
     include,
     override = [],
-    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((dependency): dependency is string => Boolean(dependency)),
+    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,
+          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,28 @@
+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>(() => ({
+  name: 'default',
+  pluginName: 'plugin-msw',
+  default(name, type) {
+    return camelCase(name, { isFile: type === 'file' })
+  },
+  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,65 +1,93 @@
-import type { Group, Output, PluginFactoryOptions, ResolveNameParams } from '@kubb/core'
+import type { ast, Exclude, Generator, Group, Include, Output, Override, PluginFactoryOptions, 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 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: 'mocks', barrelType: 'named' }
-   */
-  output?: Output<Oas>
-  /**
-   * Define which contentType should be used.
-   * By default, the first JSON valid mediaType is used
+   * @default { path: 'handlers', barrelType: 'named' }
    */
-  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.
-     */
-    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
+  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,58 @@
+import type { 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 | 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
+}
+
+/**
+ * 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 }),
+  }
+}