@kubb/plugin-msw 5.0.0-beta.84 → 5.0.0-beta.86

package/dist/index.js

@@ -1,5 +1,5 @@
 import "./rolldown-runtime-C0LytTxp.js";
-import { ast, defineGenerator, definePlugin, defineResolver } from "kubb/kit";
+import { Resolver, ast, createResolver, defineGenerator, definePlugin } from "kubb/kit";
 import { pluginFakerName } from "@kubb/plugin-faker";
 import { createFunctionParameter, createFunctionParameters, functionPrinter, pluginTsName } from "@kubb/plugin-ts";
 import { File, Function, jsxRenderer } from "kubb/jsx";
@@ -31,31 +31,6 @@ function camelCase(text, { prefix = "", suffix = "" } = {}) {
 	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false);
 }
 //#endregion
-//#region ../../internals/utils/src/fs.ts
-/**
-* Builds a nested file path from a dotted name. Splits on dots that precede a letter
-* (so version numbers embedded in operationIds like `v2025.0` stay intact), camelCases
-* every earlier segment, applies `caseLast` to the final segment, and joins with `/`.
-*
-* Empty segments are dropped before joining. They arise when the name starts with a dot
-* followed by a letter (e.g. `..Schema` splits into `['..', 'Schema']` and `'..'` cases to
-* an empty string). Without this a leading `/` would form, which `path.resolve` reads as an
-* absolute path, letting generated files escape the configured output directory.
-*
-* @example Nested path from a dotted name
-* `toFilePath('pet.petId') // 'pet/petId'`
-*
-* @example PascalCase the final segment
-* `toFilePath('pet.Pet', pascalCase) // 'pet/Pet'`
-*
-* @example Suffix applied to the final segment only
-* `toFilePath('tag.tag', (part) => camelCase(part, { suffix: 'schema' })) // 'tag/tagSchema'`
-*/
-function toFilePath(name, caseLast = camelCase) {
-	const parts = name.split(/\.(?=[a-zA-Z])/);
-	return parts.map((part, i) => i === parts.length - 1 ? caseLast(part) : camelCase(part)).filter(Boolean).join("/");
-}
-//#endregion
 //#region ../../internals/utils/src/reserved.ts
 /**
 * JavaScript and Java reserved words.
@@ -156,6 +131,22 @@ const reservedWords = /* @__PURE__ */ new Set([
 */
 function isValidVarName(name) {
 	if (!name || reservedWords.has(name)) return false;
+	return isIdentifier(name);
+}
+/**
+* Returns `true` when `name` is syntactically a valid identifier, ignoring reserved words.
+*
+* Reserved words and globals (`class`, `name`, `Date`, …) are valid as bare object-literal keys
+* even though they are not valid variable names, so use this (not {@link isValidVarName}) when
+* deciding whether an object key needs quoting.
+*
+* @example
+* ```ts
+* isIdentifier('name')   // true
+* isIdentifier('x-total')// false
+* ```
+*/
+function isIdentifier(name) {
 	return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
 }
 //#endregion
@@ -292,12 +283,12 @@ function resolveResponseTypes(node, resolver) {
 	const types = [];
 	for (const response of node.responses) {
 		if (response.statusCode === "default") {
-			types.push(["default", resolver.resolveResponseName(node)]);
+			types.push(["default", resolver.response.response(node)]);
 			continue;
 		}
 		const code = getStatusCodeNumber(response.statusCode);
 		if (code === null) continue;
-		types.push([code, isSuccessStatusCode(code) ? resolver.resolveResponseName(node) : resolver.resolveResponseStatusName(node, response.statusCode)]);
+		types.push([code, isSuccessStatusCode(code) ? resolver.response.response(node) : resolver.response.status(node, response.statusCode)]);
 	}
 	return types;
 }
@@ -345,23 +336,21 @@ const handlersGenerator = defineGenerator({
 	operations(nodes, ctx) {
 		const { resolver, config, root } = ctx;
 		const { output, group } = ctx.options;
-		const handlersName = resolver.resolveHandlersName();
-		const file = resolver.resolveFile({
-			name: resolver.resolvePathName(handlersName, "file"),
-			extname: ".ts"
-		}, {
+		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.resolveHandlerName(node);
-			const operationFile = resolver.resolveFile({
-				name: resolver.resolveName(node.operationId),
+			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
-			}, {
+				path: node.path,
 				root,
 				output,
 				group: group ?? void 0
@@ -372,12 +361,12 @@ const handlersGenerator = defineGenerator({
 				path: operationFile.path
 			});
 		});
-		const handlers = nodes.map((node) => `${resolver.resolveHandlerName(node)}()`);
+		const handlers = nodes.map((node) => `${resolver.handler.name(node)}()`);
 		return [ast.factory.createFile({
 			baseName: file.baseName,
 			path: file.path,
 			meta: file.meta,
-			banner: resolver.resolveBanner(ctx.meta, {
+			banner: resolver.default.banner(ctx.meta, {
 				output,
 				config,
 				file: {
@@ -385,7 +374,7 @@ const handlersGenerator = defineGenerator({
 					baseName: file.baseName
 				}
 			}),
-			footer: resolver.resolveFooter(ctx.meta, {
+			footer: resolver.default.footer(ctx.meta, {
 				output,
 				config,
 				file: {
@@ -450,13 +439,12 @@ function resolveFakerMeta(node, options) {
 	const { root, fakerResolver, fakerOutput, fakerGroup } = options;
 	const tag = node.tags[0] ?? "default";
 	return {
-		name: fakerResolver.resolveResponseName(node),
-		file: fakerResolver.resolveFile({
+		name: fakerResolver.response.response(node),
+		file: fakerResolver.file({
 			name: node.operationId,
 			extname: ".ts",
 			tag,
-			path: node.path
-		}, {
+			path: node.path,
 			root,
 			output: fakerOutput,
 			group: fakerGroup ?? void 0
@@ -465,60 +453,26 @@ function resolveFakerMeta(node, options) {
 }
 //#endregion
 //#region src/components/Mock.tsx
-const declarationPrinter$2 = functionPrinter({ mode: "declaration" });
-function Mock({ baseURL = "", name, typeName, requestTypeName, node }) {
-	const method = getMswMethod(node);
-	const successResponse = getPrimarySuccessResponse(node);
-	const statusCode = successResponse ? Number(successResponse.statusCode) : 200;
-	const contentType = getContentType(successResponse);
-	const url = Url.toPath(getMswUrl(node));
-	const headers = [contentType ? `'Content-Type': '${contentType}'` : null].filter(Boolean);
-	const dataType = hasResponseSchema(successResponse) ? typeName : "string | number | boolean | null | object";
-	const callbackType = requestTypeName ? `HttpResponseResolver<Record<string, string>, ${requestTypeName}>` : `((info: Parameters<Parameters<typeof http.${method}>[1]>[0]) => Response | Promise<Response>)`;
-	const params = declarationPrinter$2.print(createFunctionParameters({ params: [createFunctionParameter({
-		name: "data",
-		type: `${dataType} | ${callbackType}`,
-		optional: true
-	})] }));
-	const httpCall = requestTypeName ? `http.${method}<Record<string, string>, ${requestTypeName}>` : `http.${method}`;
-	return /* @__PURE__ */ jsx(File.Source, {
-		name,
-		isIndexable: true,
-		isExportable: true,
-		children: /* @__PURE__ */ jsx(Function, {
-			name,
-			export: true,
-			params: params ?? "",
-			children: `return ${httpCall}(\`${baseURL}${url.replace(/([^/]):/g, "$1\\\\:")}\`, function handler(info) {
-    if(typeof data === 'function') return data(info)
-
-    return new Response(JSON.stringify(data), {
-      status: ${statusCode},
-      ${headers.length ? `  headers: {
-        ${headers.join(", \n")}
-      },` : ""}
-    })
-  })`
-		})
-	});
-}
-//#endregion
-//#region src/components/MockWithFaker.tsx
 const declarationPrinter$1 = functionPrinter({ mode: "declaration" });
-function MockWithFaker({ baseURL = "", name, fakerName, typeName, requestTypeName, node }) {
+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 = Url.toPath(getMswUrl(node));
 	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: `${typeName} | ${callbackType}`,
+		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,
@@ -527,10 +481,10 @@ function MockWithFaker({ baseURL = "", name, fakerName, typeName, requestTypeNam
 			name,
 			export: true,
 			params: params ?? "",
-			children: `return ${httpCall}('${baseURL}${url.replace(/([^/]):/g, "$1\\\\:")}', function handler(info) {
+			children: `return ${httpCall}(${urlLiteral}, function handler(info) {
     if(typeof data === 'function') return data(info)
 
-    return new Response(JSON.stringify(data || ${fakerName}(data)), {
+    return new Response(${responseBody}, {
       status: ${statusCode},
       ${headers.length ? `  headers: {
         ${headers.join(", \n")}
@@ -586,15 +540,14 @@ const mswGenerator = defineGenerator({
 		if (!ast.isHttpOperationNode(node)) return null;
 		const { driver, resolver, config, root } = ctx;
 		const { output, parser, baseURL, group } = ctx.options;
-		const fileName = resolver.resolveName(node.operationId);
+		const fileName = resolver.name(node.operationId);
 		const mock = {
-			name: resolver.resolveHandlerName(node),
-			file: resolver.resolveFile({
+			name: resolver.handler.name(node),
+			file: resolver.file({
 				name: fileName,
 				extname: ".ts",
 				tag: node.tags[0] ?? "default",
-				path: node.path
-			}, {
+				path: node.path,
 				root,
 				output,
 				group: group ?? void 0
@@ -611,26 +564,25 @@ const mswGenerator = defineGenerator({
 		if (!pluginTs) return null;
 		const tsResolver = driver.getResolver(pluginTsName);
 		const type = {
-			file: tsResolver.resolveFile({
+			file: tsResolver.file({
 				name: node.operationId,
 				extname: ".ts",
 				tag: node.tags[0] ?? "default",
-				path: node.path
-			}, {
+				path: node.path,
 				root,
 				output: pluginTs.options?.output ?? output,
 				group: pluginTs.options?.group ?? void 0
 			}),
-			responseName: tsResolver.resolveResponseName(node)
+			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.resolveDataName(node) : null;
+		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.resolveBanner(ctx.meta, {
+			banner: resolver.default.banner(ctx.meta, {
 				output,
 				config,
 				file: {
@@ -638,7 +590,7 @@ const mswGenerator = defineGenerator({
 					baseName: mock.file.baseName
 				}
 			}),
-			footer: resolver.resolveFooter(ctx.meta, {
+			footer: resolver.default.footer(ctx.meta, {
 				output,
 				config,
 				file: {
@@ -680,7 +632,7 @@ const mswGenerator = defineGenerator({
 						name: mock.name
 					}, typeName);
 				}),
-				parser === "faker" && faker && hasSuccessSchema ? /* @__PURE__ */ jsx(MockWithFaker, {
+				parser === "faker" && faker && hasSuccessSchema ? /* @__PURE__ */ jsx(Mock, {
 					name: mock.name,
 					typeName: type.responseName,
 					requestTypeName: requestName,
@@ -705,32 +657,30 @@ const mswGenerator = defineGenerator({
 * 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.resolveName('addPet') // 'addPetHandler'
+* resolverMsw.name('addPet') // 'addPetHandler'
 * ```
 */
-const resolverMsw = defineResolver(() => ({
-	name: "default",
+const resolverMsw = createResolver({
 	pluginName: "plugin-msw",
-	default(name, type) {
-		return type === "file" ? toFilePath(name) : camelCase(name);
-	},
-	resolveName(name) {
+	name(name) {
 		return 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
 /**
@@ -775,10 +725,7 @@ const pluginMsw = definePlugin((options) => {
 		options,
 		dependencies: [pluginTsName, parser === "faker" ? pluginFakerName : null].filter((dependency) => Boolean(dependency)),
 		hooks: { "kubb:plugin:setup"(ctx) {
-			const resolver = userResolver ? {
-				...resolverMsw,
-				...userResolver
-			} : resolverMsw;
+			const resolver = userResolver ? Resolver.merge(resolverMsw, userResolver) : resolverMsw;
 			ctx.setOptions({
 				output,
 				parser,