@kubb/plugin-msw 5.1.0 → 5.1.3

package/dist/index.d.cts

@@ -0,0 +1,141 @@
+import { Exclude, Group, Include, Output, OutputOptions, Override, PluginType, Resolver, ResolverPatch, ast } from "kubb/kit";
+//#region src/types.d.ts
+/**
+ * Resolver for MSW that provides naming methods for handler functions.
+ */
+type ResolverMsw = Resolver & {
+  /**
+   * Naming for generated MSW handlers.
+   */
+  handler: {
+    /**
+     * Resolves the handler function name for an operation.
+     */
+    name(node: ast.OperationNode): string;
+    /**
+     * Resolves the exported handlers collection name.
+     */
+    listName(): 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' } }
+ */
+type Options = OutputOptions & {
+  /**
+   * Base URL prepended to every handler's request URL. When omitted, handlers match the
+   * operation path only (for example `/pets/:petId`). The adapter's server URL is not used.
+   */
+  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?: ResolverPatch<ResolverMsw>;
+  /**
+   * Macros applied to operation nodes before printing.
+   */
+  macros?: Array<ast.Macro>;
+  /**
+   * Emit a `handlers.ts` file that re-exports every handler in operation order.
+   * 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';
+};
+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;
+};
+type PluginMsw = PluginType<'plugin-msw', Options, ResolvedOptions, ResolverMsw>;
+declare global {
+  namespace Kubb {
+    interface PluginRegistry {
+      'plugin-msw': PluginMsw;
+    }
+  }
+}
+//#endregion
+//#region src/plugin.d.ts
+/**
+ * Canonical plugin name for `@kubb/plugin-msw`. Used for driver lookups and
+ * cross-plugin dependency references.
+ */
+export declare const pluginMswName = "plugin-msw";
+/**
+ * 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,
+ *     }),
+ *   ],
+ * })
+ * ```
+ */
+export declare const pluginMsw: import("kubb/kit").PluginFactory<PluginMsw>;
+//#endregion
+//#region src/resolvers/resolverMsw.d.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`.
+ *
+ * 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'
+ *
+ * resolverMsw.name('addPet') // 'addPetHandler'
+ * ```
+ */
+export declare const resolverMsw: ResolverMsw;
+//#endregion
+export { type PluginMsw, type ResolverMsw, pluginMsw as default };
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.ts

@@ -1,4 +1,3 @@
-import { t as __name } from "./rolldown-runtime-C0LytTxp.js";
 import { Exclude, Group, Include, Output, OutputOptions, Override, PluginType, Resolver, ResolverPatch, ast } from "kubb/kit";
 //#region src/types.d.ts
 /**
@@ -76,7 +75,6 @@ type ResolvedOptions = {
   parser: NonNullable<Options['parser']>;
   baseURL: Options['baseURL'] | undefined;
   handlers: boolean;
-  resolver: ResolverMsw;
 };
 type PluginMsw = PluginType<'plugin-msw', Options, ResolvedOptions, ResolverMsw>;
 declare global {

package/dist/index.js

@@ -1,9 +1,9 @@
-import "./rolldown-runtime-C0LytTxp.js";
-import { Resolver, Url, addGenerator, ast, createResolver, defineExtension, defineGenerator, setMacros, setResolver } from "kubb/kit";
+import { Resolver, Url, addGenerator, assertPluginOption, ast, createResolver, defineExtension, defineGenerator, setMacros, setResolver } from "kubb/kit";
 import { pluginFakerName } from "@kubb/plugin-faker";
-import { createFunctionParameter, createFunctionParameters, functionPrinter, pluginTsName } from "@kubb/plugin-ts";
+import { enumTypeName, pluginTsName } from "@kubb/plugin-ts";
 import { File, Function, jsxRenderer } from "kubb/jsx";
 import { jsx, jsxs } from "kubb/jsx/jsx-runtime";
+//#endregion
 //#region ../../internals/shared/src/operation.ts
 /**
 * Builds the `ResolverFileParams` every operation generator passes to
@@ -102,20 +102,6 @@ function camelCase(text, { prefix = "", suffix = "" } = {}) {
 	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false);
 }
 //#endregion
-//#region ../../internals/shared/src/refs.ts
-/**
-* Collects the resolved target name of every pointer-carrying ref in a schema tree, in
-* first-occurrence order. Use this for name-only checks (e.g. redeclaration detection) where
-* `resolver.imports` would resolve file paths that are then discarded.
-*/
-function collectRefNames(schema) {
-	return ast.collectSync(schema, { schema: (node) => {
-		const refNode = ast.narrowSchema(node, "ref");
-		if (!refNode?.ref) return null;
-		return ast.resolveRefName(refNode);
-	} });
-}
-//#endregion
 //#region ../../internals/shared/src/group.ts
 /**
 * Builds the `group` config a Kubb plugin passes to `ctx.setOptions`, applying the
@@ -150,11 +136,11 @@ function createGroupConfig(group) {
 //#region kubb-extension.json
 var compatibility = {
 	"kubb": ">=5.8.3",
-	"node": ">=22"
+	"node": ">=22.12"
 };
 //#endregion
 //#region package.json
-var version = "5.1.0";
+var version = "5.1.3";
 //#endregion
 //#region src/generators/handlersGenerator.ts
 /**
@@ -176,8 +162,9 @@ const handlersGenerator = defineGenerator({
 			output,
 			group: group ?? void 0
 		});
-		const imports = nodes.map((node) => {
-			const operationName = resolver.handler.name(node);
+		const handlerNames = nodes.map((node) => resolver.handler.name(node));
+		const imports = nodes.map((node, index) => {
+			const operationName = handlerNames[index];
 			const operationFile = resolver.file({
 				name: resolver.name(node.operationId),
 				extname: ".ts",
@@ -193,7 +180,7 @@ const handlersGenerator = defineGenerator({
 				path: operationFile.path
 			});
 		});
-		const handlers = nodes.map((node) => `${resolver.handler.name(node)}()`);
+		const handlers = handlerNames.map((name) => `${name}()`);
 		return [ast.factory.createFile({
 			baseName: file.baseName,
 			path: file.path,
@@ -253,62 +240,41 @@ function getResponseContentType(response) {
 	return typeof value === "string" && value.length > 0 ? value : null;
 }
 /**
-* Whether the operation uses the HTTP QUERY method (RFC 10008).
-*/
-function isQueryOperation(node) {
-	return ast.isHttpOperationNode(node) && node.method === "QUERY";
-}
-/**
 * Converts an HTTP method to its lowercase MSW equivalent (e.g., 'POST' → 'post'). MSW has no
 * `http.query`, so a QUERY operation maps to `http.all` and its handler checks the method itself.
 */
 function getMswMethod(node) {
-	if (!ast.isHttpOperationNode(node)) return "";
-	return isQueryOperation(node) ? "all" : node.method.toLowerCase();
+	return node.method === "QUERY" ? "all" : node.method.toLowerCase();
 }
 /**
-* Resolves faker metadata for an MSW operation, including response name and file path.
+* The `headers` entry of a mocked `Response` init, or an empty string when there is no content type.
 */
-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
-		})
-	};
+function headersBlock(contentType) {
+	return contentType ? `\n      headers: {\n        'Content-Type': '${contentType}'\n      },` : "";
+}
+/**
+* The `new Response(...)` expression a mocked handler returns.
+*/
+function responseLiteral(body, status, contentType) {
+	return `new Response(${body}, {
+      status: ${status},${headersBlock(contentType)}
+    })`;
 }
 //#endregion
 //#region src/components/Mock.tsx
-const declarationPrinter$1 = functionPrinter({ mode: "declaration" });
 function Mock({ baseURL = "", name, fakerName, typeName, requestTypeName, node }) {
 	const method = getMswMethod(node);
-	const methodGuard = isQueryOperation(node) ? `if (info.request.method !== 'QUERY') return\n\n    ` : "";
+	const methodGuard = node.method === "QUERY" ? `if (info.request.method !== 'QUERY') return\n\n    ` : "";
 	const successResponse = getPrimarySuccessResponse(node);
 	const statusCode = successResponse ? Number(successResponse.statusCode) : 200;
 	const contentType = getContentType(successResponse);
-	const url = ast.isHttpOperationNode(node) ? Url.toPath(node.path) : "";
-	const headers = [contentType ? `'Content-Type': '${contentType}'` : null].filter(Boolean);
+	const url = Url.toPath(node.path);
 	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(createFunctionParameters({ params: [createFunctionParameter({
-		name: "data",
-		type: `${paramType} | ${callbackType}`,
-		optional: true
-	})] }));
+	const params = `data?: ${fakerName ? typeName : dataType} | ${requestTypeName ? `HttpResponseResolver<Record<string, string>, ${requestTypeName}>` : `((info: Parameters<Parameters<typeof http.${method}>[1]>[0]) => Response | Promise<Response>)`}`;
 	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)";
-	const headersBlock = headers.length ? `\n      headers: {\n        ${headers.join(", \n")}\n      },` : "";
 	return /* @__PURE__ */ jsx(File.Source, {
 		name,
 		isIndexable: true,
@@ -316,31 +282,22 @@ function Mock({ baseURL = "", name, fakerName, typeName, requestTypeName, node }
 		children: /* @__PURE__ */ jsx(Function, {
 			name,
 			export: true,
-			params: params ?? "",
+			params,
 			children: `return ${httpCall}(${urlLiteral}, function handler(info) {
     ${methodGuard}if(typeof data === 'function') return data(info)
 
-    return new Response(${responseBody}, {
-      status: ${statusCode},${headersBlock}
-    })
+    return ${responseLiteral(responseBody, statusCode, contentType)}
   })`
 		})
 	});
 }
 //#endregion
 //#region src/components/Response.tsx
-const declarationPrinter = 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(createFunctionParameters({ params: [createFunctionParameter({
-		name: "data",
-		type: typeName,
-		optional: !hasResponseSchema(response)
-	})] }));
+	const params = `data${hasResponseSchema(response) ? "" : "?"}: ${typeName}`;
 	const responseName = `${name}Response${statusCode}`;
-	const headersBlock = headers.length ? `\n      headers: {\n        ${headers.join(", \n")}\n      },` : "";
 	return /* @__PURE__ */ jsx(File.Source, {
 		name: responseName,
 		isIndexable: true,
@@ -348,11 +305,9 @@ function Response({ name, typeName, response }) {
 		children: /* @__PURE__ */ jsx(Function, {
 			name: responseName,
 			export: true,
-			params: params ?? "",
+			params,
 			children: `
-    return new Response(JSON.stringify(data), {
-      status: ${statusCode},${headersBlock}
-    })`
+    return ${responseLiteral("JSON.stringify(data)", statusCode, contentType)}`
 		})
 	});
 }
@@ -385,12 +340,19 @@ const mswGenerator = defineGenerator({
 			})
 		};
 		const fakerPlugin = parser === "faker" ? ctx.requirePlugin(pluginFakerName) : null;
-		const faker = fakerPlugin ? resolveFakerMeta(node, {
-			root,
-			fakerResolver: driver.getResolver(pluginFakerName),
-			fakerOutput: fakerPlugin.options?.output ?? output,
-			fakerGroup: fakerPlugin.options?.group ?? null
-		}) : null;
+		const fakerResolver = fakerPlugin ? driver.getResolver(pluginFakerName) : null;
+		const faker = fakerPlugin && fakerResolver ? {
+			name: fakerResolver.response.response(node),
+			file: fakerResolver.file({
+				name: node.operationId,
+				extname: ".ts",
+				tag: node.tags[0] ?? "default",
+				path: node.path,
+				root,
+				output: fakerPlugin.options?.output ?? output,
+				group: fakerPlugin.options?.group ?? void 0
+			})
+		} : null;
 		const pluginTs = ctx.requirePlugin(pluginTsName);
 		const tsResolver = driver.getResolver(pluginTsName);
 		const type = {
@@ -405,11 +367,16 @@ const mswGenerator = defineGenerator({
 			responseName: tsResolver.response.response(node)
 		};
 		const successResponses = getOperationSuccessResponses(node);
-		const referencedNames = node.responses.flatMap((response) => (response.content ?? []).flatMap((entry) => entry.schema ? collectRefNames(entry.schema) : []));
+		const referencedNames = node.responses.flatMap((response) => (response.content ?? []).flatMap((entry) => entry.schema ? ast.collectImportedRefNames(entry.schema) : []));
 		const enumOptions = pluginTs.options?.enum;
 		const enumNames = new Set(ctx.meta.enumNames);
 		const hasResponseNameCollision = referencedNames.some((name) => {
-			return (enumOptions?.type === "asConst" && enumOptions.typeSuffix && enumNames.has(name) ? tsResolver.enum.keyName({ name }, enumOptions.typeSuffix) : tsResolver.name(name)) === type.responseName;
+			return enumTypeName({
+				resolver: tsResolver,
+				name,
+				enumOptions,
+				isEnum: enumNames.has(name)
+			}) === type.responseName;
 		});
 		const types = resolveResponseTypes(node, tsResolver).map(([code, typeName]) => {
 			const successResponse = successResponses.find((response) => response.statusCode === String(code));
@@ -459,7 +426,7 @@ const mswGenerator = defineGenerator({
 					root: mock.file.path,
 					isTypeOnly: true
 				}),
-				parser === "faker" && faker && hasSuccessSchema && /* @__PURE__ */ jsx(File.Import, {
+				faker && hasSuccessSchema && /* @__PURE__ */ jsx(File.Import, {
 					name: [faker.name],
 					root: mock.file.path,
 					path: faker.file.path
@@ -473,17 +440,11 @@ const mswGenerator = defineGenerator({
 						name: mock.name
 					}, typeName);
 				}),
-				parser === "faker" && faker && hasSuccessSchema ? /* @__PURE__ */ jsx(Mock, {
-					name: mock.name,
-					typeName: mockResponseName,
-					requestTypeName: requestName,
-					fakerName: faker.name,
-					node,
-					baseURL
-				}) : /* @__PURE__ */ jsx(Mock, {
+				/* @__PURE__ */ jsx(Mock, {
 					name: mock.name,
 					typeName: mockResponseName,
 					requestTypeName: requestName,
+					fakerName: faker && hasSuccessSchema ? faker.name : void 0,
 					node,
 					baseURL
 				})
@@ -571,6 +532,12 @@ const pluginMsw = defineExtension({
 			path: "handlers",
 			barrel: { type: "named" }
 		}, group, exclude = [], include, override = [], handlers = false, parser = "data", baseURL, resolver: userResolver, macros: userMacros } = options;
+		assertPluginOption({
+			plugin: pluginMswName,
+			option: "parser",
+			value: parser,
+			allowed: ["data", "faker"]
+		});
 		const resolver = userResolver ? Resolver.merge(resolverMsw, userResolver) : resolverMsw;
 		setResolver(resolver);
 		if (userMacros?.length) setMacros(userMacros);
@@ -584,8 +551,7 @@ const pluginMsw = defineExtension({
 			exclude,
 			include,
 			override,
-			handlers,
-			resolver
+			handlers
 		};
 	}
 });