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

package/dist/index.js

@@ -1,84 +1,514 @@
-import "./chunk--u3MIqq1.js";
-import { a as camelCase } from "./components-DgtTZkWX.js";
-import { n as handlersGenerator, t as mswGenerator } from "./generators-CvyZTxOm.js";
-import path from "node:path";
-import { createPlugin, getBarrelFiles, getMode } from "@kubb/core";
+import "./rolldown-runtime-C0LytTxp.js";
+import { Resolver, Url, ast, createResolver, defineGenerator, definePlugin } from "kubb/kit";
 import { pluginFakerName } from "@kubb/plugin-faker";
-import { OperationGenerator, pluginOasName } from "@kubb/plugin-oas";
-import { pluginTsName } from "@kubb/plugin-ts";
+import { createFunctionParameter, createFunctionParameters, functionPrinter, pluginTsName } from "@kubb/plugin-ts";
+import { File, Function, jsxRenderer } from "kubb/jsx";
+import { jsx, jsxs } from "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 = 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 ast.factory.createImport({
+				name: [operationName],
+				root: file.path,
+				path: operationFile.path
+			});
+		});
+		const handlers = nodes.map((node) => `${resolver.handler.name(node)}()`);
+		return [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: [ast.factory.createSource({
+				name: handlersName,
+				isIndexable: true,
+				isExportable: true,
+				nodes: [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 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 = 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 = ast.isHttpOperationNode(node) ? 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(createFunctionParameters({ params: [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__ */ jsx(File.Source, {
+		name,
+		isIndexable: true,
+		isExportable: true,
+		children: /* @__PURE__ */ 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 = 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 responseName = `${name}Response${statusCode}`;
+	return /* @__PURE__ */ jsx(File.Source, {
+		name: responseName,
+		isIndexable: true,
+		isExportable: true,
+		children: /* @__PURE__ */ 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 = defineGenerator({
+	name: "msw",
+	renderer: jsxRenderer,
+	operation(node, ctx) {
+		if (!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(pluginFakerName) : null;
+		const faker = parser === "faker" && fakerPlugin ? resolveFakerMeta(node, {
+			root,
+			fakerResolver: driver.getResolver(pluginFakerName),
+			fakerOutput: fakerPlugin.options?.output ?? output,
+			fakerGroup: fakerPlugin.options?.group ?? null
+		}) : null;
+		const pluginTs = driver.getPlugin(pluginTsName);
+		if (!pluginTs) return null;
+		const tsResolver = driver.getResolver(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__ */ jsxs(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__ */ jsx(File.Import, {
+					name: ["http"],
+					path: "msw"
+				}),
+				/* @__PURE__ */ jsx(File.Import, {
+					name: ["HttpResponseResolver"],
+					isTypeOnly: true,
+					path: "msw"
+				}),
+				/* @__PURE__ */ 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__ */ 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__ */ jsx(Response, {
+						typeName,
+						response,
+						name: mock.name
+					}, typeName);
+				}),
+				parser === "faker" && faker && hasSuccessSchema ? /* @__PURE__ */ jsx(Mock, {
+					name: mock.name,
+					typeName: type.responseName,
+					requestTypeName: requestName,
+					fakerName: faker.name,
+					node,
+					baseURL
+				}) : /* @__PURE__ */ jsx(Mock, {
+					name: mock.name,
+					typeName: type.responseName,
+					requestTypeName: requestName,
+					node,
+					baseURL
+				})
+			]
+		});
+	}
+});
+//#endregion
+//#region src/resolvers/resolverMsw.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'
+* ```
+*/
+const resolverMsw = createResolver({
+	pluginName: "plugin-msw",
+	name(name) {
+		return camelCase(name, { suffix: "handler" });
+	},
+	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 = createPlugin((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 = definePlugin((options) => {
 	const { output = {
 		path: "handlers",
-		barrelType: "named"
-	}, group, exclude = [], include, override = [], transformers = {}, handlers = false, parser = "data", generators = [mswGenerator, handlers ? handlersGenerator : void 0].filter(Boolean), contentType, baseURL } = options;
+		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: {
-			output,
-			parser,
-			group,
-			baseURL
-		},
-		pre: [
-			pluginOasName,
-			pluginTsName,
-			parser === "faker" ? pluginFakerName : void 0
-		].filter(Boolean),
-		resolvePath(baseName, pathMode, options) {
-			const root = path.resolve(this.config.root, this.config.output.path);
-			if ((pathMode ?? getMode(path.resolve(root, output.path))) === "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 : (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" : void 0,
-				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 files = await new OperationGenerator(this.plugin.options, {
-				fabric: this.fabric,
-				oas,
-				driver: this.driver,
-				events: this.events,
-				plugin: this.plugin,
-				contentType,
+		options,
+		dependencies: [pluginTsName, parser === "faker" ? pluginFakerName : null].filter((dependency) => Boolean(dependency)),
+		hooks: { "kubb:plugin:setup"(ctx) {
+			const resolver = userResolver ? Resolver.merge(resolverMsw, userResolver) : resolverMsw;
+			ctx.setOptions({
+				output,
+				parser,
+				baseURL,
+				group: groupConfig,
 				exclude,
 				include,
 				override,
-				mode
-			}).build(...generators);
-			await this.upsertFile(...files);
-			const barrelFiles = await getBarrelFiles(this.fabric.files, {
-				type: output.barrelType ?? "named",
-				root,
-				output,
-				meta: { pluginName: this.plugin.name }
+				handlers,
+				resolver
 			});
-			await this.upsertFile(...barrelFiles);
-		}
+			ctx.setResolver(resolver);
+			if (userMacros?.length) ctx.setMacros(userMacros);
+			ctx.addGenerator(mswGenerator);
+			if (handlers) ctx.addGenerator(handlersGenerator);
+		} }
 	};
 });
 //#endregion
-export { pluginMsw, pluginMswName };
+export { pluginMsw as default, pluginMsw, pluginMswName, resolverMsw };
 
 //# sourceMappingURL=index.js.map