@kubb/plugin-cypress 5.0.0-beta.10 → 5.0.0-beta.101

package/dist/index.js

@@ -1,335 +1,165 @@
-import "./chunk--u3MIqq1.js";
-import { ast, defineGenerator, definePlugin, defineResolver } from "@kubb/core";
-import { functionPrinter, pluginTsName } from "@kubb/plugin-ts";
-import { File, Function, jsxRenderer } from "@kubb/renderer-jsx";
-import { jsx, jsxs } from "@kubb/renderer-jsx/jsx-runtime";
-//#region ../../internals/utils/src/casing.ts
+import "./rolldown-runtime-C0LytTxp.js";
+import { Resolver, Url, ast, createResolver, defineGenerator, definePlugin } from "kubb/kit";
+import { File, Function, jsxRenderer } from "kubb/jsx";
+import { jsx, jsxs } from "kubb/jsx/jsx-runtime";
+import { pluginTsName } from "@kubb/plugin-ts";
+//#region ../../internals/shared/src/params.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`.
+* Drops parameters that share the same name, keeping the first.
 *
-* When `pascal` is `true` the first word is also capitalized (PascalCase), otherwise only subsequent words are.
+* A malformed spec can declare the same parameter name twice within one `in` location. Both would
+* resolve to the same output property, so emitting both would yield an object type with a duplicate
+* member, which TypeScript rejects. This is a defensive guard against that case, not a casing guard:
+* parameter names flow through unchanged, so no two distinct names ever collide here anymore.
 */
-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;
-		if (i === 0 && !pascal) return word.charAt(0).toLowerCase() + word.slice(1);
-		return word.charAt(0).toUpperCase() + word.slice(1);
-	}).join("").replace(/[^a-zA-Z0-9]/g, "");
+function dedupeParams(params) {
+	const seen = /* @__PURE__ */ new Set();
+	return params.filter((param) => {
+		if (seen.has(param.name)) return false;
+		seen.add(param.name);
+		return true;
+	});
 }
+//#endregion
+//#region ../../internals/shared/src/operation.ts
 /**
-* Splits `text` on `.` and applies `transformPart` to each segment.
-* The last segment receives `isLast = true`, all earlier segments receive `false`.
-* Segments are joined with `/` to form a file path.
-*
-* Only splits on dots followed by a letter so that version numbers
-* embedded in operationIds (e.g. `v2025.0`) are kept intact.
+* Derives the shared `ContentTypeInfo` shape from a list of content types, tracking whether several
+* are present and the union, default, and form-data flags the client uses to pick one.
 */
-function applyToFileParts(text, transformPart) {
-	const parts = text.split(/\.(?=[a-zA-Z])/);
-	return parts.map((part, i) => transformPart(part, i === parts.length - 1)).join("/");
+function buildContentTypeInfo(contentTypes) {
+	const isMultipleContentTypes = contentTypes.length > 1;
+	return {
+		contentTypes,
+		isMultipleContentTypes,
+		contentTypeUnion: isMultipleContentTypes ? contentTypes.map((ct) => JSON.stringify(ct)).join(" | ") : "",
+		defaultContentType: contentTypes[0] ?? "application/json",
+		hasFormData: contentTypes.some((ct) => ct === "multipart/form-data")
+	};
+}
+function getContentTypeInfo(node) {
+	return buildContentTypeInfo(node.requestBody?.content?.map((e) => e.contentType) ?? []);
 }
 /**
-* Converts `text` to camelCase.
-* When `isFile` is `true`, dot-separated segments are each cased independently and joined with `/`.
-*
-* @example
-* camelCase('hello-world')                   // 'helloWorld'
-* camelCase('pet.petId', { isFile: true })   // 'pet/petId'
+* The request-body counterpart for the primary success response: the content types it documents and
+* whether several are present, so the client can let a caller pick which one to accept.
 */
-function camelCase(text, { isFile, prefix = "", suffix = "" } = {}) {
-	if (isFile) return applyToFileParts(text, (part, isLast) => camelCase(part, isLast ? {
-		prefix,
-		suffix
-	} : {}));
-	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false);
+function getResponseContentTypeInfo(node) {
+	return buildContentTypeInfo(getPrimarySuccessResponse(node)?.content?.map((e) => e.contentType) ?? []);
+}
+function buildRequestConfigType(node) {
+	const request = getContentTypeInfo(node);
+	const response = getResponseContentTypeInfo(node);
+	const configType = `Partial<Omit<RequestConfig, 'path' | 'query' | 'body' | 'headers' | 'url'>>`;
+	const members = [request.isMultipleContentTypes ? `request?: ${request.contentTypeUnion}` : null, response.isMultipleContentTypes ? `response?: ${response.contentTypeUnion}` : null].filter(Boolean);
+	return members.length ? `${configType} & { contentType?: { ${members.join("; ")} } }` : configType;
 }
-//#endregion
-//#region ../../internals/utils/src/reserved.ts
 /**
-* JavaScript and Java reserved words.
-* @link https://github.com/jonschlinkert/reserved/blob/master/index.js
+* Which of the grouped request options an operation carries.
 */
-const reservedWords = 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"
-]);
+function getRequestGroups(node) {
+	const { path, query, header } = getOperationParameters(node);
+	return {
+		path: path.length > 0,
+		query: query.length > 0,
+		body: Boolean(node.requestBody?.content?.[0]?.schema),
+		headers: header.length > 0
+	};
+}
 /**
-* Returns `true` when `name` is a syntactically valid JavaScript variable name.
-*
-* @example
-* ```ts
-* isValidVarName('status')  // true
-* isValidVarName('class')   // false (reserved word)
-* isValidVarName('42foo')   // false (starts with digit)
-* ```
+* Resolves which grouped request options an operation carries together with whether each group
+* holds a required member. The grouped parameter stays optional only when nothing inside it is
+* required, matching the generated `RequestConfig` type.
 */
-function isValidVarName(name) {
-	if (!name || reservedWords.has(name)) return false;
-	return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
+function getRequestGroupOptionality(node) {
+	const groups = getRequestGroups(node);
+	const { path, query, header } = getOperationParameters(node);
+	const hasRequiredPath = path.some((param) => param.required);
+	const hasRequiredQuery = query.some((param) => param.required);
+	const hasRequiredHeader = header.some((param) => param.required);
+	return {
+		groups,
+		hasRequiredPath,
+		hasRequiredQuery,
+		hasRequiredHeader,
+		isOptional: !hasRequiredPath && !hasRequiredQuery && !hasRequiredHeader && !groups.body
+	};
 }
-//#endregion
-//#region ../../internals/utils/src/urlPath.ts
 /**
-* Parses and transforms an OpenAPI/Swagger path string into various URL formats.
-*
-* @example
-* const p = new URLPath('/pet/{petId}')
-* p.URL      // '/pet/:petId'
-* p.template // '`/pet/${petId}`'
+* Builds the grouped `{ path, query, body, headers }` parameter for a generated client
+* function, typed from the operation's `Options` (minus `url`). Only the groups the
+* operation actually has are destructured. The trailing `config` parameter carries the
+* runtime `RequestConfig` overrides plus `client`.
 */
-var URLPath = class {
-	/**
-	* The raw OpenAPI/Swagger path string, e.g. `/pet/{petId}`.
-	*/
-	path;
-	#options;
-	constructor(path, options = {}) {
-		this.path = path;
-		this.#options = options;
-	}
-	/** Converts the OpenAPI path to Express-style colon syntax, e.g. `/pet/{petId}` → `/pet/:petId`.
-	*
-	* @example
-	* ```ts
-	* new URLPath('/pet/{petId}').URL // '/pet/:petId'
-	* ```
-	*/
-	get URL() {
-		return this.toURLPath();
-	}
-	/** Returns `true` when `path` is a fully-qualified URL (e.g. starts with `https://`).
-	*
-	* @example
-	* ```ts
-	* new URLPath('https://petstore.swagger.io/v2/pet').isURL // true
-	* new URLPath('/pet/{petId}').isURL                       // false
-	* ```
-	*/
-	get isURL() {
-		try {
-			return !!new URL(this.path).href;
-		} catch {
-			return false;
-		}
-	}
-	/**
-	* Converts the OpenAPI path to a TypeScript template literal string.
-	*
-	* @example
-	* new URLPath('/pet/{petId}').template              // '`/pet/${petId}`'
-	* new URLPath('/account/monetary-accountID').template // '`/account/${monetaryAccountId}`'
-	*/
-	get template() {
-		return this.toTemplateString();
-	}
-	/** Returns the path and its extracted params as a structured `URLObject`, or as a stringified expression when `stringify` is set.
-	*
-	* @example
-	* ```ts
-	* new URLPath('/pet/{petId}').object
-	* // { url: '/pet/:petId', params: { petId: 'petId' } }
-	* ```
-	*/
-	get object() {
-		return this.toObject();
-	}
-	/** Returns a map of path parameter names, or `undefined` when the path has no parameters.
-	*
-	* @example
-	* ```ts
-	* new URLPath('/pet/{petId}').params // { petId: 'petId' }
-	* new URLPath('/pet').params         // undefined
-	* ```
-	*/
-	get params() {
-		return this.toParamsObject();
-	}
-	#transformParam(raw) {
-		const param = isValidVarName(raw) ? raw : camelCase(raw);
-		return this.#options.casing === "camelcase" ? camelCase(param) : param;
-	}
-	/**
-	* Iterates over every `{param}` token in `path`, calling `fn` with the raw token and transformed name.
-	*/
-	#eachParam(fn) {
-		for (const match of this.path.matchAll(/\{([^}]+)\}/g)) {
-			const raw = match[1];
-			fn(raw, this.#transformParam(raw));
-		}
-	}
-	toObject({ type = "path", replacer, stringify } = {}) {
-		const object = {
-			url: type === "path" ? this.toURLPath() : this.toTemplateString({ replacer }),
-			params: this.toParamsObject()
-		};
-		if (stringify) {
-			if (type === "template") return JSON.stringify(object).replaceAll("'", "").replaceAll(`"`, "");
-			if (object.params) return `{ url: '${object.url}', params: ${JSON.stringify(object.params).replaceAll("'", "").replaceAll(`"`, "")} }`;
-			return `{ url: '${object.url}' }`;
-		}
-		return object;
-	}
-	/**
-	* Converts the OpenAPI path to a TypeScript template literal string.
-	* An optional `replacer` can transform each extracted parameter name before interpolation.
-	*
-	* @example
-	* new URLPath('/pet/{petId}').toTemplateString() // '`/pet/${petId}`'
-	*/
-	toTemplateString({ prefix = "", replacer } = {}) {
-		return `\`${prefix}${this.path.split(/\{([^}]+)\}/).map((part, i) => {
-			if (i % 2 === 0) return part;
-			const param = this.#transformParam(part);
-			return `\${${replacer ? replacer(param) : param}}`;
-		}).join("")}\``;
-	}
-	/**
-	* Extracts all `{param}` segments from the path and returns them as a key-value map.
-	* An optional `replacer` transforms each parameter name in both key and value positions.
-	* Returns `undefined` when no path parameters are found.
-	*
-	* @example
-	* ```ts
-	* new URLPath('/pet/{petId}/tag/{tagId}').toParamsObject()
-	* // { petId: 'petId', tagId: 'tagId' }
-	* ```
-	*/
-	toParamsObject(replacer) {
-		const params = {};
-		this.#eachParam((_raw, param) => {
-			const key = replacer ? replacer(param) : param;
-			params[key] = key;
-		});
-		return Object.keys(params).length > 0 ? params : void 0;
-	}
-	/** Converts the OpenAPI path to Express-style colon syntax.
-	*
-	* @example
-	* ```ts
-	* new URLPath('/pet/{petId}').toURLPath() // '/pet/:petId'
-	* ```
-	*/
-	toURLPath() {
-		return this.path.replace(/\{([^}]+)\}/g, ":$1");
-	}
-};
-//#endregion
-//#region ../../internals/shared/src/operation.ts
-function getOperationParameters(node, options = {}) {
-	const params = ast.caseParams(node.parameters, options.paramsCasing);
+function buildRequestParamsSignature(node, resolver, options = {}) {
+	const { isConfigurable = true } = options;
+	const { groups, isOptional } = getRequestGroupOptionality(node);
+	const names = [
+		"path",
+		"query",
+		"body",
+		"headers"
+	].filter((key) => groups[key]);
+	return {
+		signature: [names.length > 0 ? `{ ${names.join(", ")} }: ${resolver.response.options(node)}${isOptional ? " = {}" : ""}` : null, isConfigurable ? `config: ${buildRequestConfigType(node)} = {}` : null].filter(Boolean).join(", "),
+		groups
+	};
+}
+function getOperationParameters(node) {
 	return {
-		path: params.filter((param) => param.in === "path"),
-		query: params.filter((param) => param.in === "query"),
-		header: params.filter((param) => param.in === "header"),
-		cookie: params.filter((param) => param.in === "cookie")
+		path: dedupeParams(node.parameters.filter((param) => param.in === "path")),
+		query: dedupeParams(node.parameters.filter((param) => param.in === "query")),
+		header: dedupeParams(node.parameters.filter((param) => param.in === "header")),
+		cookie: dedupeParams(node.parameters.filter((param) => param.in === "cookie"))
 	};
 }
 function getStatusCodeNumber(statusCode) {
 	const code = Number(statusCode);
-	return Number.isNaN(code) ? void 0 : code;
+	return Number.isNaN(code) ? null : code;
+}
+function isSuccessStatusCode(statusCode) {
+	const code = getStatusCodeNumber(statusCode);
+	return code !== null && code >= 200 && code < 300;
 }
 function isErrorStatusCode(statusCode) {
 	const code = getStatusCodeNumber(statusCode);
-	return code !== void 0 && code >= 400;
+	return code !== null && code >= 400;
+}
+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 resolveErrorNames(node, resolver) {
-	return node.responses.filter((response) => isErrorStatusCode(response.statusCode)).map((response) => resolver.resolveResponseStatusName(node, response.statusCode));
+	return node.responses.filter((response) => isErrorStatusCode(response.statusCode)).map((response) => resolver.response.status(node, response.statusCode));
 }
 function resolveStatusCodeNames(node, resolver) {
-	return node.responses.map((response) => resolver.resolveResponseStatusName(node, response.statusCode));
+	return node.responses.map((response) => resolver.response.status(node, response.statusCode));
 }
+const typeNamesByResolver = /* @__PURE__ */ new WeakMap();
 function resolveOperationTypeNames(node, resolver, options = {}) {
-	const { path, query, header } = getOperationParameters(node, { paramsCasing: options.paramsCasing });
+	const cacheKey = `${node.operationId}\0${options.order ?? ""}\0${options.responseStatusNames ?? ""}\0${options.includeParams === false ? "noparams" : ""}\0${(options.exclude ?? []).join(",")}`;
+	let byResolver = typeNamesByResolver.get(resolver);
+	if (byResolver) {
+		const cached = byResolver.get(cacheKey);
+		if (cached) return cached;
+	} else {
+		byResolver = /* @__PURE__ */ new Map();
+		typeNamesByResolver.set(resolver, byResolver);
+	}
+	const { path, query, header } = getOperationParameters(node);
 	const responseStatusNames = options.responseStatusNames === "error" ? resolveErrorNames(node, resolver) : options.responseStatusNames === false ? [] : resolveStatusCodeNames(node, resolver);
 	const exclude = new Set(options.exclude ?? []);
-	const paramNames = [
-		...path.map((param) => resolver.resolvePathParamsName(node, param)),
-		...query.map((param) => resolver.resolveQueryParamsName(node, param)),
-		...header.map((param) => resolver.resolveHeaderParamsName(node, param))
+	const paramNames = options.includeParams === false ? [] : [
+		...path.map((param) => resolver.param.path(node, param)),
+		...query.map((param) => resolver.param.query(node, param)),
+		...header.map((param) => resolver.param.headers(node, param))
 	];
-	const bodyAndResponseNames = [node.requestBody?.content?.[0]?.schema ? resolver.resolveDataName(node) : void 0, resolver.resolveResponseName(node)];
-	return (options.order === "body-response-first" ? [
+	const bodyAndResponseNames = [node.requestBody?.content?.[0]?.schema ? resolver.response.body(node) : null, resolver.response.response(node)];
+	const result = (options.order === "body-response-first" ? [
 		...bodyAndResponseNames,
 		...paramNames,
 		...responseStatusNames
@@ -338,53 +168,84 @@ function resolveOperationTypeNames(node, resolver, options = {}) {
 		...bodyAndResponseNames,
 		...responseStatusNames
 	]).filter((name) => Boolean(name) && !exclude.has(name));
+	byResolver.set(cacheKey, result);
+	return result;
+}
+//#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/components/Request.tsx
-const declarationPrinter = functionPrinter({ mode: "declaration" });
-function Request({ baseURL = "", name, dataReturnType, resolver, node, paramsType, pathParamsType, paramsCasing }) {
-	const paramsNode = ast.createOperationParams(node, {
-		paramsType,
-		pathParamsType,
-		paramsCasing,
-		resolver,
-		extraParams: [ast.createFunctionParameter({
-			name: "options",
-			type: ast.createParamsType({
-				variant: "reference",
-				name: "Partial<Cypress.RequestOptions>"
-			}),
-			default: "{}"
-		})]
-	});
-	const paramsSignature = declarationPrinter.print(paramsNode) ?? "";
-	const responseType = resolver.resolveResponseName(node);
-	const returnType = dataReturnType === "data" ? `Cypress.Chainable<${responseType}>` : `Cypress.Chainable<Cypress.Response<${responseType}>>`;
-	const casedPathParams = getOperationParameters(node, { paramsCasing }).path;
-	const pathParamNameMap = new Map(casedPathParams.map((p) => [camelCase(p.name), p.name]));
-	const urlTemplate = new URLPath(node.path, { casing: paramsCasing }).toTemplateString({
-		prefix: baseURL,
-		replacer: (param) => pathParamNameMap.get(camelCase(param)) ?? param
-	});
+function Request({ baseURL = "", name, resolver, node }) {
+	if (!ast.isHttpOperationNode(node)) return null;
+	const { signature, groups } = buildRequestParamsSignature(node, resolver, { isConfigurable: false });
+	const paramsSignature = [signature, "options: Partial<Cypress.RequestOptions> = {}"].filter(Boolean).join(", ");
+	const responseType = resolver.response.response(node);
+	const returnType = `Cypress.Chainable<${responseType}>`;
+	const urlTemplate = Url.toGroupedTemplateString(node.path, { prefix: baseURL });
 	const requestOptions = [`method: '${node.method}'`, `url: ${urlTemplate}`];
-	const queryParams = getOperationParameters(node).query;
-	if (queryParams.length > 0) {
-		const casedQueryParams = getOperationParameters(node, { paramsCasing }).query;
-		if (casedQueryParams.some((p, i) => p.name !== queryParams[i].name)) {
-			const pairs = queryParams.map((orig, i) => `${orig.name}: params.${casedQueryParams[i].name}`).join(", ");
-			requestOptions.push(`qs: params ? { ${pairs} } : undefined`);
-		} else requestOptions.push("qs: params");
-	}
-	const headerParams = getOperationParameters(node).header;
-	if (headerParams.length > 0) {
-		const casedHeaderParams = getOperationParameters(node, { paramsCasing }).header;
-		if (casedHeaderParams.some((p, i) => p.name !== headerParams[i].name)) {
-			const pairs = headerParams.map((orig, i) => `'${orig.name}': headers.${casedHeaderParams[i].name}`).join(", ");
-			requestOptions.push(`headers: headers ? { ${pairs} } : undefined`);
-		} else requestOptions.push("headers");
-	}
-	if (node.requestBody?.content?.[0]?.schema) requestOptions.push("body: data");
+	if (groups.query) requestOptions.push("qs: query");
+	if (groups.headers) requestOptions.push("headers");
+	if (groups.body) requestOptions.push("body");
 	requestOptions.push("...options");
+	const requestCall = `return cy.request<${responseType}>({
+  ${requestOptions.join(",\n  ")}
+}).then((res) => res.body)`;
 	return /* @__PURE__ */ jsx(File.Source, {
 		name,
 		isIndexable: true,
@@ -394,62 +255,70 @@ function Request({ baseURL = "", name, dataReturnType, resolver, node, paramsTyp
 			export: true,
 			params: paramsSignature,
 			returnType,
-			children: dataReturnType === "data" ? `return cy.request<${responseType}>({
-  ${requestOptions.join(",\n  ")}
-}).then((res) => res.body)` : `return cy.request<${responseType}>({
-  ${requestOptions.join(",\n  ")}
-})`
+			children: requestCall
 		})
 	});
 }
 //#endregion
 //#region src/generators/cypressGenerator.tsx
+/**
+* Built-in generator for `@kubb/plugin-cypress`. Emits one typed
+* `cy.request()` wrapper per OpenAPI operation, ready to call inside Cypress
+* test specs and custom commands.
+*/
 const cypressGenerator = defineGenerator({
 	name: "cypress",
 	renderer: jsxRenderer,
 	operation(node, ctx) {
-		const { adapter, config, resolver, driver, root } = ctx;
-		const { output, baseURL, dataReturnType, paramsCasing, paramsType, pathParamsType, group } = ctx.options;
+		if (!ast.isHttpOperationNode(node)) return null;
+		const { config, resolver, driver, root } = ctx;
+		const { output, baseURL, group } = ctx.options;
 		const pluginTs = driver.getPlugin(pluginTsName);
 		if (!pluginTs) return null;
 		const tsResolver = driver.getResolver(pluginTsName);
-		const importedTypeNames = resolveOperationTypeNames(node, tsResolver, { paramsCasing });
+		const importedTypeNames = [tsResolver.response.options(node), ...resolveOperationTypeNames(node, tsResolver, { includeParams: false })];
 		const meta = {
-			name: resolver.resolveName(node.operationId),
-			file: resolver.resolveFile({
+			name: resolver.name(node.operationId),
+			file: resolver.file({
 				name: node.operationId,
 				extname: ".ts",
 				tag: node.tags[0] ?? "default",
-				path: node.path
-			}, {
+				path: node.path,
 				root,
 				output,
-				group
+				group: group ?? void 0
 			}),
-			fileTs: tsResolver.resolveFile({
+			fileTs: 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
+				group: pluginTs.options?.group ?? void 0
 			})
 		};
 		return /* @__PURE__ */ jsxs(File, {
 			baseName: meta.file.baseName,
 			path: meta.file.path,
 			meta: meta.file.meta,
-			banner: resolver.resolveBanner(adapter.inputNode, {
+			banner: resolver.default.banner(ctx.meta, {
 				output,
-				config
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
 			}),
-			footer: resolver.resolveFooter(adapter.inputNode, {
+			footer: resolver.default.footer(ctx.meta, {
 				output,
-				config
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
 			}),
-			children: [meta.fileTs && importedTypeNames.length > 0 && /* @__PURE__ */ jsx(File.Import, {
+			children: [importedTypeNames.length > 0 && /* @__PURE__ */ jsx(File.Import, {
 				name: importedTypeNames,
 				root: meta.file.path,
 				path: meta.fileTs.path,
@@ -458,10 +327,6 @@ const cypressGenerator = defineGenerator({
 				name: meta.name,
 				node,
 				resolver: tsResolver,
-				dataReturnType,
-				paramsCasing,
-				paramsType,
-				pathParamsType,
 				baseURL
 			})]
 		});
@@ -470,87 +335,72 @@ const cypressGenerator = defineGenerator({
 //#endregion
 //#region src/resolvers/resolverCypress.ts
 /**
-* Naming convention resolver for Cypress plugin.
+* Default resolver used by `@kubb/plugin-cypress`. Decides the names and file
+* paths for every generated `cy.request()` wrapper. Functions and files use
+* camelCase, matching the convention from `@kubb/plugin-axios` and `@kubb/plugin-fetch`.
 *
-* Provides default naming helpers using camelCase for functions and file paths.
+* @example Resolve a helper name
+* ```ts
+* import { resolverCypress } from '@kubb/plugin-cypress'
 *
-* @example
-* `resolverCypress.default('list pets', 'function')  // → 'listPets'`
+* resolverCypress.name('list pets') // 'listPets'
+* ```
 */
-const resolverCypress = defineResolver(() => ({
-	name: "default",
-	pluginName: "plugin-cypress",
-	default(name, type) {
-		return camelCase(name, { isFile: type === "file" });
-	},
-	resolveName(name) {
-		return this.default(name, "function");
-	},
-	resolvePathName(name, type) {
-		return this.default(name, type);
-	}
-}));
+const resolverCypress = createResolver({ pluginName: "plugin-cypress" });
 //#endregion
 //#region src/plugin.ts
 /**
-* Canonical plugin name for `@kubb/plugin-cypress`, used to identify the plugin
-* in driver lookups and warnings.
+* Canonical plugin name for `@kubb/plugin-cypress`. Used for driver lookups and
+* cross-plugin dependency references.
 */
 const pluginCypressName = "plugin-cypress";
 /**
-* The `@kubb/plugin-cypress` plugin factory.
-*
-* Generates Cypress `cy.request()` test functions from an OpenAPI/AST `RootNode`.
-* Walks operations, delegates rendering to the active generators,
-* and writes barrel files based on `output.barrelType`.
+* Generates one typed `cy.request()` wrapper per OpenAPI operation. Each helper
+* has typed path params, body, query, and a typed response, so failing API
+* calls in Cypress show up at compile time instead of inside the test runner.
 *
 * @example
 * ```ts
-* import pluginCypress from '@kubb/plugin-cypress'
+* import { defineConfig } from 'kubb/config'
+* import { pluginTs } from '@kubb/plugin-ts'
+* import { pluginCypress } from '@kubb/plugin-cypress'
 *
 * export default defineConfig({
-*   plugins: [pluginCypress({ output: { path: 'cypress' } })],
+*   input: './petStore.yaml',
+*   output: { path: './src/gen' },
+*   plugins: [
+*     pluginTs(),
+*     pluginCypress({
+*       output: { path: './cypress' },
+*     }),
+*   ],
 * })
 * ```
 */
 const pluginCypress = definePlugin((options) => {
 	const { output = {
 		path: "cypress",
-		barrelType: "named"
-	}, group, exclude = [], include, override = [], dataReturnType = "data", baseURL, paramsCasing, paramsType = "inline", pathParamsType = paramsType === "object" ? "object" : options.pathParamsType || "inline", 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 `${camelCase(ctx.group)}Requests`;
-		}
-	} : void 0;
+		barrel: { type: "named" }
+	}, group, exclude = [], include, override = [], baseURL, resolver: userResolver, macros: userMacros } = options;
+	const groupConfig = createGroupConfig(group);
 	return {
 		name: pluginCypressName,
 		options,
 		dependencies: [pluginTsName],
 		hooks: { "kubb:plugin:setup"(ctx) {
-			const resolver = userResolver ? {
-				...resolverCypress,
-				...userResolver
-			} : resolverCypress;
+			const resolver = userResolver ? Resolver.merge(resolverCypress, userResolver) : resolverCypress;
 			ctx.setOptions({
 				output,
 				exclude,
 				include,
 				override,
-				dataReturnType,
 				group: groupConfig,
 				baseURL,
-				paramsCasing,
-				paramsType,
-				pathParamsType,
 				resolver
 			});
 			ctx.setResolver(resolver);
-			if (userTransformer) ctx.setTransformer(userTransformer);
+			if (userMacros?.length) ctx.setMacros(userMacros);
 			ctx.addGenerator(cypressGenerator);
-			for (const gen of userGenerators) ctx.addGenerator(gen);
 		} }
 	};
 });