@kubb/plugin-msw 5.0.0-beta.99 → 5.0.1

package/dist/index.cjs

@@ -8,220 +8,46 @@ 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/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/utils/src/reserved.ts
-/**
-* JavaScript and Java reserved words.
-* @link https://github.com/jonschlinkert/reserved/blob/master/index.js
-*/
-const reservedWords = /* @__PURE__ */ new Set([
-	"abstract",
-	"arguments",
-	"boolean",
-	"break",
-	"byte",
-	"case",
-	"catch",
-	"char",
-	"class",
-	"const",
-	"continue",
-	"debugger",
-	"default",
-	"delete",
-	"do",
-	"double",
-	"else",
-	"enum",
-	"eval",
-	"export",
-	"extends",
-	"false",
-	"final",
-	"finally",
-	"float",
-	"for",
-	"function",
-	"goto",
-	"if",
-	"implements",
-	"import",
-	"in",
-	"instanceof",
-	"int",
-	"interface",
-	"let",
-	"long",
-	"native",
-	"new",
-	"null",
-	"package",
-	"private",
-	"protected",
-	"public",
-	"return",
-	"short",
-	"static",
-	"super",
-	"switch",
-	"synchronized",
-	"this",
-	"throw",
-	"throws",
-	"transient",
-	"true",
-	"try",
-	"typeof",
-	"var",
-	"void",
-	"volatile",
-	"while",
-	"with",
-	"yield",
-	"Array",
-	"Date",
-	"hasOwnProperty",
-	"Infinity",
-	"isFinite",
-	"isNaN",
-	"isPrototypeOf",
-	"length",
-	"Math",
-	"name",
-	"NaN",
-	"Number",
-	"Object",
-	"prototype",
-	"String",
-	"toString",
-	"undefined",
-	"valueOf"
-]);
+//#region ../../internals/shared/src/operation.ts
 /**
-* Returns `true` when `name` is a syntactically valid JavaScript variable name.
+* Builds the `ResolverFileParams` every operation generator passes to
+* `resolver.file`: a file named `name`, tagged by the operation's first
+* tag (or `'default'`), at the operation's path. Centralizes the entry object
+* that was repeated at dozens of call sites across the client and query plugins.
 *
 * @example
 * ```ts
-* isValidVarName('status')  // true
-* isValidVarName('class')   // false (reserved word)
-* isValidVarName('42foo')   // false (starts with digit)
+* resolver.file(operationFileEntry(node, node.operationId), { root, output, group })
 * ```
 */
-function isValidVarName(name) {
-	if (!name || reservedWords.has(name)) return false;
-	return isIdentifier(name);
+function operationFileEntry(node, name, extname = ".ts") {
+	return {
+		name,
+		extname,
+		tag: node.tags[0] ?? "default",
+		path: node.path
+	};
 }
 /**
-* 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.
+* Resolves a dependency plugin's generated file for `node.operationId`, cached in `cache` (the
+* current node's `ctx.cache`) under the resolver's own plugin name. Several dependents reading the
+* same dependency for the same operation in one pass (a query plugin's several hook generators, the
+* MCP handler, ...) share one computed name and path instead of each calling `resolver.file` again.
 *
-* @example
+* @example Cache `plugin-ts`'s file for the current operation
 * ```ts
-* isIdentifier('name')   // true
-* isIdentifier('x-total')// false
+* const fileTs = resolveDependencyOperationFile({ cache: ctx.cache, node, resolver: tsResolver, root, output })
 * ```
 */
-function isIdentifier(name) {
-	return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
-}
-//#endregion
-//#region ../../internals/utils/src/url.ts
-/**
-* Keeps the OpenAPI parameter name as-is when it is already a valid JS identifier, and
-* camelCases it only enough to become one otherwise (for example a hyphenated path segment).
-*/
-function transformParam(raw) {
-	return isValidVarName(raw) ? raw : camelCase(raw);
+function resolveDependencyOperationFile(options) {
+	const { cache, node, resolver, root, output, group } = options;
+	return cache.ensureItem(`${resolver.pluginName}:operationFile`, () => resolver.file({
+		...operationFileEntry(node, node.operationId),
+		root,
+		output,
+		group: group ?? void 0
+	}));
 }
-/**
-* Helpers for OpenAPI/Swagger paths.
-*/
-var Url = class Url {
-	/**
-	* Converts an OpenAPI/Swagger path to Express-style colon syntax.
-	*
-	* @example
-	* Url.toPath('/pet/{petId}') // '/pet/:petId'
-	*/
-	static toPath(path) {
-		return path.replace(/\{([^}]+)\}/g, ":$1");
-	}
-	/**
-	* Rewrites OpenAPI placeholder names while keeping the `{...}` braces, so the generated `url`
-	* literal aligns with the grouped `path` request option that the runtime client interpolates by
-	* key.
-	*
-	* @example
-	* Url.toSafeTemplate('/user/{monetary-account-id}') // '/user/{monetaryAccountId}'
-	*/
-	static toSafeTemplate(path) {
-		return path.replace(/\{([^}]+)\}/g, (_, name) => `{${transformParam(name)}}`);
-	}
-	/**
-	* Converts an OpenAPI/Swagger path to a TypeScript template literal string.
-	* `prefix` is prepended inside the literal, and `replacer` transforms each parameter name.
-	*
-	* @example
-	* Url.toTemplateString('/pet/{petId}') // '`/pet/${petId}`'
-	*
-	* @example
-	* Url.toTemplateString('/pet/{petId}', { prefix: 'https://api' }) // '`https://api/pet/${petId}`'
-	*/
-	static toTemplateString(path, { prefix, replacer } = {}) {
-		const result = path.split(/\{([^}]+)\}/).map((part, i) => {
-			if (i % 2 === 0) return part;
-			const param = transformParam(part);
-			return `\${${replacer ? replacer(param) : param}}`;
-		}).join("");
-		return `\`${prefix ?? ""}${result}\``;
-	}
-	/**
-	* Converts an OpenAPI/Swagger path to a template literal that reads each parameter off the
-	* grouped `path` request option, e.g. `/pet/{petId}` becomes `` `/pet/${path.petId}` ``. Parameter
-	* names match the generated `path` type, and `prefix` is prepended inside the literal. Shared by
-	* the client and cypress generators that pass a grouped `path` object.
-	*
-	* @example
-	* Url.toGroupedTemplateString('/pet/{petId}') // '`/pet/${path.petId}`'
-	*/
-	static toGroupedTemplateString(path, { prefix } = {}) {
-		return Url.toTemplateString(path, {
-			prefix,
-			replacer: (name) => `path.${name}`
-		});
-	}
-};
-//#endregion
-//#region ../../internals/shared/src/operation.ts
 function getStatusCodeNumber(statusCode) {
 	const code = Number(statusCode);
 	return Number.isNaN(code) ? null : code;
@@ -253,6 +79,33 @@ function resolveResponseTypes(node, resolver) {
 	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
@@ -387,12 +240,6 @@ function getMswMethod(node) {
 	return kubb_kit.ast.isHttpOperationNode(node) ? node.method.toLowerCase() : "";
 }
 /**
-* Converts an OpenAPI-style path to an Express/MSW-style path by replacing `{param}` with `:param`.
-*/
-function getMswUrl(node) {
-	return kubb_kit.ast.isHttpOperationNode(node) ? node.path.replaceAll("{", ":").replaceAll("}", "") : "";
-}
-/**
 * Resolves faker metadata for an MSW operation, including response name and file path.
 */
 function resolveFakerMeta(node, options) {
@@ -419,7 +266,7 @@ function Mock({ baseURL = "", name, fakerName, typeName, requestTypeName, node }
 	const successResponse = getPrimarySuccessResponse(node);
 	const statusCode = successResponse ? Number(successResponse.statusCode) : 200;
 	const contentType = getContentType(successResponse);
-	const url = Url.toPath(getMswUrl(node));
+	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;
@@ -433,6 +280,7 @@ function Mock({ baseURL = "", name, fakerName, typeName, requestTypeName, node }
 	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__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Source, {
 		name,
 		isIndexable: true,
@@ -445,10 +293,7 @@ function Mock({ baseURL = "", name, fakerName, typeName, requestTypeName, node }
     if(typeof data === 'function') return data(info)
 
     return new Response(${responseBody}, {
-      status: ${statusCode},
-      ${headers.length ? `  headers: {
-        ${headers.join(", \n")}
-      },` : ""}
+      status: ${statusCode},${headersBlock}
     })
   })`
 		})
@@ -467,6 +312,7 @@ function Response({ name, typeName, response }) {
 		optional: !hasResponseSchema(response)
 	})] }));
 	const responseName = `${name}Response${statusCode}`;
+	const headersBlock = headers.length ? `\n      headers: {\n        ${headers.join(", \n")}\n      },` : "";
 	return /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Source, {
 		name: responseName,
 		isIndexable: true,
@@ -477,10 +323,7 @@ function Response({ name, typeName, response }) {
 			params: params ?? "",
 			children: `
     return new Response(JSON.stringify(data), {
-      status: ${statusCode},
-      ${headers.length ? `  headers: {
-        ${headers.join(", \n")}
-      },` : ""}
+      status: ${statusCode},${headersBlock}
     })`
 		})
 	});
@@ -524,14 +367,13 @@ const mswGenerator = (0, kubb_kit.defineGenerator)({
 		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,
+			file: resolveDependencyOperationFile({
+				cache: ctx.cache,
+				node,
+				resolver: tsResolver,
 				root,
 				output: pluginTs.options?.output ?? output,
-				group: pluginTs.options?.group ?? void 0
+				group: pluginTs.options?.group
 			}),
 			responseName: tsResolver.response.response(node)
 		};