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

package/README.md

@@ -1,18 +1,15 @@
 <div align="center">
-  <h1>@kubb/plugin-msw</h1>
   <a href="https://kubb.dev" target="_blank" rel="noopener noreferrer">
-    <img width="180" src="https://raw.githubusercontent.com/kubb-labs/kubb/main/assets/logo.png" alt="Kubb logo">
+    <img src="https://kubb.dev/og.png" alt="Kubb banner">
   </a>
 
 [![npm version][npm-version-src]][npm-version-href]
 [![npm downloads][npm-downloads-src]][npm-downloads-href]
-[![Coverage][coverage-src]][coverage-href]
+[![Stars][stars-src]][stars-href]
 [![License][license-src]][license-href]
-[![Sponsors][sponsors-src]][sponsors-href]
+[![Node][node-src]][node-href]
 
 <h4>
-<a href="https://codesandbox.io/s/github/kubb-labs/plugins/tree/main/examples/msw" target="_blank">View Demo</a>
-<span> · </span>
 <a href="https://kubb.dev/plugins/msw" target="_blank">Documentation</a>
 <span> · </span>
 <a href="https://github.com/kubb-labs/kubb/issues/" target="_blank">Report Bug</a>
@@ -21,14 +18,13 @@
 </h4>
 </div>
 
-`@kubb/plugin-msw` generates Mock Service Worker (MSW) request handlers from your OpenAPI specification. The handlers work in both browser and Node.js environments via MSW v2.
+<br />
+
+# @kubb/plugin-msw
 
-## Features
+### Generate MSW request handlers with Kubb
 
-- Generates one handler per OpenAPI operation
-- Infers request and response types from the spec
-- Works in both browser (via service worker) and Node.js test environments
-- Works with `@kubb/plugin-faker` to serve realistic response data
+`@kubb/plugin-msw` generates Mock Service Worker (MSW) request handlers with Kubb. The handlers work in both browser and Node.js environments via MSW v2.
 
 ## Installation
 
@@ -46,7 +42,7 @@ See the [full documentation](https://kubb.dev/plugins/msw) for configuration opt
 
 ## Supporting Kubb
 
-Kubb is an MIT-licensed open source project with its ongoing development made possible entirely by the support of Sponsors. If you would like to become a sponsor, please consider:
+Kubb is an open source project, and its development is funded entirely by sponsors. If you would like to become a sponsor, please consider:
 
 - [Become a Sponsor on GitHub](https://github.com/sponsors/stijnvanhulle)
 
@@ -56,19 +52,19 @@ Kubb is an MIT-licensed open source project with its ongoing development made po
   </a>
 </p>
 
+## License
+
+[MIT](https://github.com/kubb-labs/plugins/blob/main/LICENSE)
+
 <!-- Badges -->
 
-[npm-version-src]: https://img.shields.io/npm/v/@kubb/plugin-msw?flat&colorA=18181B&colorB=f58517
-[npm-version-href]: https://npmjs.com/package/@kubb/plugin-msw
-[npm-downloads-src]: https://img.shields.io/npm/dm/@kubb/plugin-msw?flat&colorA=18181B&colorB=f58517
-[npm-downloads-href]: https://npmjs.com/package/@kubb/plugin-msw
-[license-src]: https://img.shields.io/github/license/kubb-labs/kubb.svg?flat&colorA=18181B&colorB=f58517
+[npm-version-src]: https://shieldcn.dev/npm/v/@kubb/plugin-msw.svg?variant=secondary&size=xs&theme=zinc&mode=dark
+[npm-version-href]: https://npmx.dev/package/@kubb/plugin-msw
+[npm-downloads-src]: https://shieldcn.dev/npm/dm/@kubb/plugin-msw.svg?variant=secondary&size=xs&theme=zinc&mode=dark
+[npm-downloads-href]: https://npmx.dev/package/@kubb/plugin-msw
+[stars-src]: https://shieldcn.dev/github/stars/kubb-labs/kubb.svg?variant=secondary&size=xs&theme=zinc&mode=dark
+[stars-href]: https://github.com/kubb-labs/kubb
+[license-src]: https://shieldcn.dev/npm/license/@kubb/plugin-msw.svg?variant=secondary&size=xs&theme=zinc
 [license-href]: https://github.com/kubb-labs/kubb/blob/main/LICENSE
-[build-src]: https://img.shields.io/github/actions/workflow/status/kubb-labs/kubb/ci.yaml?style=flat&colorA=18181B&colorB=f58517
-[build-href]: https://www.npmjs.com/package/@kubb/plugin-msw
-[minified-src]: https://img.shields.io/bundlephobia/min/@kubb/plugin-msw?style=flat&colorA=18181B&colorB=f58517
-[minified-href]: https://www.npmjs.com/package/@kubb/plugin-msw
-[coverage-src]: https://img.shields.io/codecov/c/github/kubb-labs/kubb?style=flat&colorA=18181B&colorB=f58517
-[coverage-href]: https://www.npmjs.com/package/@kubb/plugin-msw
-[sponsors-src]: https://img.shields.io/github/sponsors/stijnvanhulle?style=flat&colorA=18181B&colorB=f58517
-[sponsors-href]: https://github.com/sponsors/stijnvanhulle/
+[node-src]: https://shieldcn.dev/npm/node/@kubb/plugin-msw.svg?variant=secondary&size=xs&theme=zinc&mode=dark
+[node-href]: https://npmx.dev/package/@kubb/plugin-msw

package/dist/index.cjs

@@ -2,60 +2,498 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_components = require("./components-BYvgvrY7.cjs");
-const require_generators = require("./generators-rZ99WaWQ.cjs");
-let _kubb_core = require("@kubb/core");
+//#endregion
+let kubb_kit = require("kubb/kit");
 let _kubb_plugin_faker = require("@kubb/plugin-faker");
 let _kubb_plugin_ts = require("@kubb/plugin-ts");
+let kubb_jsx = require("kubb/jsx");
+let kubb_jsx_jsx_runtime = require("kubb/jsx/jsx-runtime");
+//#region ../../internals/shared/src/operation.ts
+function getStatusCodeNumber(statusCode) {
+	const code = Number(statusCode);
+	return Number.isNaN(code) ? null : code;
+}
+function isSuccessStatusCode(statusCode) {
+	const code = getStatusCodeNumber(statusCode);
+	return code !== null && code >= 200 && code < 300;
+}
+function getSuccessResponses(responses) {
+	return responses.filter((response) => isSuccessStatusCode(response.statusCode));
+}
+function getOperationSuccessResponses(node) {
+	return getSuccessResponses(node.responses);
+}
+function getPrimarySuccessResponse(node) {
+	return getOperationSuccessResponses(node)[0] ?? null;
+}
+function resolveResponseTypes(node, resolver) {
+	const types = [];
+	for (const response of node.responses) {
+		if (response.statusCode === "default") {
+			types.push(["default", resolver.response.response(node)]);
+			continue;
+		}
+		const code = getStatusCodeNumber(response.statusCode);
+		if (code === null) continue;
+		types.push([code, isSuccessStatusCode(code) ? resolver.response.response(node) : resolver.response.status(node, response.statusCode)]);
+	}
+	return types;
+}
+//#endregion
+//#region ../../internals/utils/src/casing.ts
+/**
+* Shared implementation for camelCase and PascalCase conversion.
+* Splits on common word boundaries (spaces, hyphens, underscores, dots, slashes, colons)
+* and capitalizes each word according to `pascal`.
+*
+* When `pascal` is `true` the first word is also capitalized (PascalCase), otherwise only subsequent words are.
+*/
+function toCamelOrPascal(text, pascal) {
+	return text.trim().replace(/([a-z\d])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/(\d)([a-z])/g, "$1 $2").split(/[\s\-_./\\:]+/).filter(Boolean).map((word, i) => {
+		if (word.length > 1 && word === word.toUpperCase()) return word;
+		return (i === 0 && !pascal ? word.charAt(0).toLowerCase() : word.charAt(0).toUpperCase()) + word.slice(1);
+	}).join("").replace(/[^a-zA-Z0-9]/g, "");
+}
+/**
+* Converts `text` to camelCase.
+*
+* @example Word boundaries
+* `camelCase('hello-world') // 'helloWorld'`
+*
+* @example With a prefix
+* `camelCase('tag', { prefix: 'create' }) // 'createTag'`
+*/
+function camelCase(text, { prefix = "", suffix = "" } = {}) {
+	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false);
+}
+//#endregion
+//#region ../../internals/shared/src/group.ts
+/**
+* Builds the `group` config a Kubb plugin passes to `ctx.setOptions`, applying the
+* shared default naming so every plugin groups output consistently:
+*
+* - `path` groups use the second path segment (`/pet/findByStatus` → `pet`).
+* - other groups use the camelCased group (`pet store` → `petStore`).
+*
+* A user-provided `group.name` always wins over the default namer, so callers stay in
+* control of their output folders. Returns `null` when grouping is disabled, matching the
+* per-plugin convention.
+*
+* @param group - The user-supplied group option, or `undefined` to disable grouping.
+*
+* @example
+* ```ts
+* createGroupConfig(group) // shared across every plugin
+* ```
+*/
+function createGroupConfig(group) {
+	if (!group) return null;
+	const defaultName = (ctx) => {
+		if (group.type === "path") return `${ctx.group.split("/")[1]}`;
+		return camelCase(ctx.group);
+	};
+	return {
+		...group,
+		name: group.name ? group.name : defaultName
+	};
+}
+//#endregion
+//#region src/generators/handlersGenerator.ts
+/**
+* Aggregate generator enabled by `pluginMsw({ handlers: true })`. Emits a
+* `handlers.ts` file that re-exports every generated handler in operation
+* order, ready to spread into `setupServer(...handlers)` or
+* `setupWorker(...handlers)`.
+*/
+const handlersGenerator = (0, kubb_kit.defineGenerator)({
+	name: "plugin-msw",
+	operations(nodes, ctx) {
+		const { resolver, config, root } = ctx;
+		const { output, group } = ctx.options;
+		const handlersName = resolver.handler.listName();
+		const file = resolver.file({
+			name: handlersName,
+			extname: ".ts",
+			root,
+			output,
+			group: group ?? void 0
+		});
+		const imports = nodes.map((node) => {
+			const operationName = resolver.handler.name(node);
+			const operationFile = resolver.file({
+				name: resolver.name(node.operationId),
+				extname: ".ts",
+				tag: node.tags[0] ?? "default",
+				path: node.path,
+				root,
+				output,
+				group: group ?? void 0
+			});
+			return kubb_kit.ast.factory.createImport({
+				name: [operationName],
+				root: file.path,
+				path: operationFile.path
+			});
+		});
+		const handlers = nodes.map((node) => `${resolver.handler.name(node)}()`);
+		return [kubb_kit.ast.factory.createFile({
+			baseName: file.baseName,
+			path: file.path,
+			meta: file.meta,
+			banner: resolver.default.banner(ctx.meta, {
+				output,
+				config,
+				file: {
+					path: file.path,
+					baseName: file.baseName
+				}
+			}),
+			footer: resolver.default.footer(ctx.meta, {
+				output,
+				config,
+				file: {
+					path: file.path,
+					baseName: file.baseName
+				}
+			}),
+			imports,
+			sources: [kubb_kit.ast.factory.createSource({
+				name: handlersName,
+				isIndexable: true,
+				isExportable: true,
+				nodes: [kubb_kit.ast.factory.createText(`export const ${handlersName} = ${JSON.stringify(handlers).replaceAll("\"", "")} as const`)]
+			})]
+		})];
+	}
+});
+//#endregion
+//#region src/utils.ts
+/**
+* Gets the content type from a response, defaulting to 'application/json' if a schema exists.
+*/
+function getContentType(response) {
+	if (!hasResponseSchema(response)) return null;
+	return getResponseContentType(response) ?? "application/json";
+}
+/**
+* Determines if a response has a schema that is not void or any.
+*/
+function hasResponseSchema(response) {
+	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) {
+	const contents = response?.content ?? [];
+	const value = (contents.find((entry) => {
+		const baseType = entry.contentType?.split(";")[0]?.trim().toLowerCase();
+		return baseType === "application/json" || baseType?.endsWith("+json");
+	}) ?? 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').
+*/
+function getMswMethod(node) {
+	return kubb_kit.ast.isHttpOperationNode(node) ? node.method.toLowerCase() : "";
+}
+/**
+* Resolves faker metadata for an MSW operation, including response name and file path.
+*/
+function resolveFakerMeta(node, options) {
+	const { root, fakerResolver, fakerOutput, fakerGroup } = options;
+	const tag = node.tags[0] ?? "default";
+	return {
+		name: fakerResolver.response.response(node),
+		file: fakerResolver.file({
+			name: node.operationId,
+			extname: ".ts",
+			tag,
+			path: node.path,
+			root,
+			output: fakerOutput,
+			group: fakerGroup ?? void 0
+		})
+	};
+}
+//#endregion
+//#region src/components/Mock.tsx
+const declarationPrinter$1 = (0, _kubb_plugin_ts.functionPrinter)({ mode: "declaration" });
+function Mock({ baseURL = "", name, fakerName, typeName, requestTypeName, node }) {
+	const method = getMswMethod(node);
+	const successResponse = getPrimarySuccessResponse(node);
+	const statusCode = successResponse ? Number(successResponse.statusCode) : 200;
+	const contentType = getContentType(successResponse);
+	const url = kubb_kit.ast.isHttpOperationNode(node) ? kubb_kit.Url.toPath(node.path) : "";
+	const headers = [contentType ? `'Content-Type': '${contentType}'` : null].filter(Boolean);
+	const dataType = hasResponseSchema(successResponse) ? typeName : "string | number | boolean | null | object";
+	const paramType = fakerName ? typeName : dataType;
+	const callbackType = requestTypeName ? `HttpResponseResolver<Record<string, string>, ${requestTypeName}>` : `((info: Parameters<Parameters<typeof http.${method}>[1]>[0]) => Response | Promise<Response>)`;
+	const params = declarationPrinter$1.print((0, _kubb_plugin_ts.createFunctionParameters)({ params: [(0, _kubb_plugin_ts.createFunctionParameter)({
+		name: "data",
+		type: `${paramType} | ${callbackType}`,
+		optional: true
+	})] }));
+	const httpCall = requestTypeName ? `http.${method}<Record<string, string>, ${requestTypeName}>` : `http.${method}`;
+	const requestUrl = `${baseURL}${url.replace(/([^/]):/g, "$1\\\\:")}`;
+	const urlLiteral = fakerName ? `'${requestUrl}'` : `\`${requestUrl}\``;
+	const responseBody = fakerName ? `JSON.stringify(data || ${fakerName}(data))` : "JSON.stringify(data)";
+	return /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Source, {
+		name,
+		isIndexable: true,
+		isExportable: true,
+		children: /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.Function, {
+			name,
+			export: true,
+			params: params ?? "",
+			children: `return ${httpCall}(${urlLiteral}, function handler(info) {
+    if(typeof data === 'function') return data(info)
+
+    return new Response(${responseBody}, {
+      status: ${statusCode},
+      ${headers.length ? `  headers: {
+        ${headers.join(", \n")}
+      },` : ""}
+    })
+  })`
+		})
+	});
+}
+//#endregion
+//#region src/components/Response.tsx
+const declarationPrinter = (0, _kubb_plugin_ts.functionPrinter)({ mode: "declaration" });
+function Response({ name, typeName, response }) {
+	const statusCode = Number(response.statusCode);
+	const contentType = getContentType(response);
+	const headers = [contentType ? `'Content-Type': '${contentType}'` : null].filter(Boolean);
+	const params = declarationPrinter.print((0, _kubb_plugin_ts.createFunctionParameters)({ params: [(0, _kubb_plugin_ts.createFunctionParameter)({
+		name: "data",
+		type: typeName,
+		optional: !hasResponseSchema(response)
+	})] }));
+	const responseName = `${name}Response${statusCode}`;
+	return /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Source, {
+		name: responseName,
+		isIndexable: true,
+		isExportable: true,
+		children: /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.Function, {
+			name: responseName,
+			export: true,
+			params: params ?? "",
+			children: `
+    return new Response(JSON.stringify(data), {
+      status: ${statusCode},
+      ${headers.length ? `  headers: {
+        ${headers.join(", \n")}
+      },` : ""}
+    })`
+		})
+	});
+}
+//#endregion
+//#region src/generators/mswGenerator.tsx
+/**
+* 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.
+*/
+const mswGenerator = (0, kubb_kit.defineGenerator)({
+	name: "msw",
+	renderer: kubb_jsx.jsxRenderer,
+	operation(node, ctx) {
+		if (!kubb_kit.ast.isHttpOperationNode(node)) return null;
+		const { driver, resolver, config, root } = ctx;
+		const { output, parser, baseURL, group } = ctx.options;
+		const fileName = resolver.name(node.operationId);
+		const mock = {
+			name: resolver.handler.name(node),
+			file: resolver.file({
+				name: fileName,
+				extname: ".ts",
+				tag: node.tags[0] ?? "default",
+				path: node.path,
+				root,
+				output,
+				group: group ?? void 0
+			})
+		};
+		const fakerPlugin = parser === "faker" ? driver.getPlugin(_kubb_plugin_faker.pluginFakerName) : null;
+		const faker = parser === "faker" && fakerPlugin ? resolveFakerMeta(node, {
+			root,
+			fakerResolver: driver.getResolver(_kubb_plugin_faker.pluginFakerName),
+			fakerOutput: fakerPlugin.options?.output ?? output,
+			fakerGroup: fakerPlugin.options?.group ?? null
+		}) : null;
+		const pluginTs = driver.getPlugin(_kubb_plugin_ts.pluginTsName);
+		if (!pluginTs) return null;
+		const tsResolver = driver.getResolver(_kubb_plugin_ts.pluginTsName);
+		const type = {
+			file: tsResolver.file({
+				name: node.operationId,
+				extname: ".ts",
+				tag: node.tags[0] ?? "default",
+				path: node.path,
+				root,
+				output: pluginTs.options?.output ?? output,
+				group: pluginTs.options?.group ?? void 0
+			}),
+			responseName: tsResolver.response.response(node)
+		};
+		const types = resolveResponseTypes(node, tsResolver);
+		const hasSuccessSchema = getOperationSuccessResponses(node).some((response) => !!response.content?.[0]?.schema);
+		const requestName = node.requestBody?.content?.[0]?.schema ? tsResolver.response.body(node) : null;
+		return /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsxs)(kubb_jsx.File, {
+			baseName: mock.file.baseName,
+			path: mock.file.path,
+			meta: mock.file.meta,
+			banner: resolver.default.banner(ctx.meta, {
+				output,
+				config,
+				file: {
+					path: mock.file.path,
+					baseName: mock.file.baseName
+				}
+			}),
+			footer: resolver.default.footer(ctx.meta, {
+				output,
+				config,
+				file: {
+					path: mock.file.path,
+					baseName: mock.file.baseName
+				}
+			}),
+			children: [
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+					name: ["http"],
+					path: "msw"
+				}),
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+					name: ["HttpResponseResolver"],
+					isTypeOnly: true,
+					path: "msw"
+				}),
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+					name: Array.from(/* @__PURE__ */ new Set([
+						type.responseName,
+						...types.map((t) => t[1]),
+						...requestName ? [requestName] : []
+					])),
+					path: type.file.path,
+					root: mock.file.path,
+					isTypeOnly: true
+				}),
+				parser === "faker" && faker && /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.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 /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(Response, {
+						typeName,
+						response,
+						name: mock.name
+					}, typeName);
+				}),
+				parser === "faker" && faker && hasSuccessSchema ? /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(Mock, {
+					name: mock.name,
+					typeName: type.responseName,
+					requestTypeName: requestName,
+					fakerName: faker.name,
+					node,
+					baseURL
+				}) : /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(Mock, {
+					name: mock.name,
+					typeName: type.responseName,
+					requestTypeName: requestName,
+					node,
+					baseURL
+				})
+			]
+		});
+	}
+});
+//#endregion
 //#region src/resolvers/resolverMsw.ts
 /**
-* Naming convention resolver for MSW plugin.
+* 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`.
+*
+* The top-level `name` applies the `handler` suffix, and `file` falls back to the built-in
+* `toFilePath` casing. Operation-specific naming is grouped under the `handler` namespace.
+*
+* @example Resolve a handler name
+* ```ts
+* import { resolverMsw } from '@kubb/plugin-msw'
 *
-* Provides default naming helpers using camelCase with a `handler` suffix.
+* resolverMsw.name('addPet') // 'addPetHandler'
+* ```
 */
-const resolverMsw = (0, _kubb_core.defineResolver)(() => ({
-	name: "default",
+const resolverMsw = (0, kubb_kit.createResolver)({
 	pluginName: "plugin-msw",
-	default(name, type) {
-		return require_components.camelCase(name, { isFile: type === "file" });
+	name(name) {
+		return camelCase(name, { suffix: "handler" });
 	},
-	resolveName(name) {
-		return require_components.camelCase(name, { suffix: "handler" });
-	},
-	resolvePathName(name, type) {
-		return this.default(name, type);
-	},
-	resolveHandlerName(node) {
-		return this.resolveName(node.operationId);
-	},
-	resolveHandlersName() {
-		return "handlers";
+	handler: {
+		name(node) {
+			return this.name(node.operationId);
+		},
+		listName() {
+			return "handlers";
+		}
 	}
-}));
+});
 //#endregion
 //#region src/plugin.ts
+/**
+* Canonical plugin name for `@kubb/plugin-msw`. Used for driver lookups and
+* cross-plugin dependency references.
+*/
 const pluginMswName = "plugin-msw";
-const pluginMsw = (0, _kubb_core.definePlugin)((options) => {
+/**
+* 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/config'
+* import { pluginTs } from '@kubb/plugin-ts'
+* import { pluginMsw } from '@kubb/plugin-msw'
+*
+* export default defineConfig({
+*   input: './petStore.yaml',
+*   output: { path: './src/gen' },
+*   plugins: [
+*     pluginTs(),
+*     pluginMsw({
+*       output: { path: './handlers' },
+*       handlers: true,
+*     }),
+*   ],
+* })
+* ```
+*/
+const pluginMsw = (0, kubb_kit.definePlugin)((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) => {
-			if (group.type === "path") return `${ctx.group.split("/")[1]}`;
-			return `${require_components.camelCase(ctx.group)}Controller`;
-		}
-	} : void 0;
+		barrel: { type: "named" }
+	}, group, exclude = [], include, override = [], handlers = false, parser = "data", baseURL, resolver: userResolver, macros: userMacros } = options;
+	const groupConfig = createGroupConfig(group);
 	return {
 		name: pluginMswName,
 		options,
-		dependencies: [_kubb_plugin_ts.pluginTsName, parser === "faker" ? _kubb_plugin_faker.pluginFakerName : void 0].filter((dependency) => Boolean(dependency)),
+		dependencies: [_kubb_plugin_ts.pluginTsName, parser === "faker" ? _kubb_plugin_faker.pluginFakerName : null].filter((dependency) => Boolean(dependency)),
 		hooks: { "kubb:plugin:setup"(ctx) {
-			const resolver = userResolver ? {
-				...resolverMsw,
-				...userResolver
-			} : resolverMsw;
+			const resolver = userResolver ? kubb_kit.Resolver.merge(resolverMsw, userResolver) : resolverMsw;
 			ctx.setOptions({
 				output,
 				parser,
@@ -68,10 +506,9 @@ const pluginMsw = (0, _kubb_core.definePlugin)((options) => {
 				resolver
 			});
 			ctx.setResolver(resolver);
-			if (userTransformer) ctx.setTransformer(userTransformer);
-			ctx.addGenerator(require_generators.mswGenerator);
-			if (handlers) ctx.addGenerator(require_generators.handlersGenerator);
-			for (const gen of userGenerators) ctx.addGenerator(gen);
+			if (userMacros?.length) ctx.setMacros(userMacros);
+			ctx.addGenerator(mswGenerator);
+			if (handlers) ctx.addGenerator(handlersGenerator);
 		} }
 	};
 });
@@ -79,5 +516,6 @@ const pluginMsw = (0, _kubb_core.definePlugin)((options) => {
 exports.default = pluginMsw;
 exports.pluginMsw = pluginMsw;
 exports.pluginMswName = pluginMswName;
+exports.resolverMsw = resolverMsw;
 
 //# sourceMappingURL=index.cjs.map