@kubb/plugin-cypress 5.0.0-beta.64 → 5.0.0-beta.74

package/dist/index.d.ts

@@ -1,8 +1,31 @@
-import { t as __name } from "./chunk-C0LytTxp.js";
-import { Exclude, Generator, Group, Include, Output, OutputOptions, Override, PluginFactoryOptions, Resolver, ast } from "@kubb/core";
+import { t as __name } from "./rolldown-runtime-C0LytTxp.js";
+import { Exclude, Group, Include, Output, OutputOptions, Override, PluginFactoryOptions, Resolver, ast } from "@kubb/core";
 import { ResolverTs } from "@kubb/plugin-ts";
 import { KubbReactNode } from "@kubb/renderer-jsx/types";
 
+//#region src/components/Request.d.ts
+type Props = {
+  /**
+   * Name of the function
+   */
+  name: string;
+  /**
+   * AST operation node
+   */
+  node: ast.OperationNode;
+  /**
+   * TypeScript resolver for resolving param/data/response type names
+   */
+  resolver: ResolverTs;
+  baseURL: string | null | undefined;
+};
+declare function Request({
+  baseURL,
+  name,
+  resolver,
+  node
+}: Props): KubbReactNode;
+//#endregion
 //#region src/types.d.ts
 /**
  * Resolver for Cypress that provides naming methods for test functions.
@@ -20,32 +43,6 @@ type ResolverCypress = Resolver & {
    */
   resolvePathName(this: ResolverCypress, name: string, type?: 'file' | 'function' | 'type' | 'const'): string;
 };
-/**
- * Parameter handling mode that determines how path params and query/body params are arranged in function signatures.
- */
-type ParamsTypeOptions = {
-  /**
-   * Every operation parameter is wrapped in a single destructured object argument.
-   */
-  paramsType: 'object';
-  /**
-   * `pathParamsType` has no effect when `paramsType` is `'object'`.
-   */
-  pathParamsType?: never;
-} | {
-  /**
-   * Each parameter group is emitted as a separate positional function argument.
-   */
-  paramsType?: 'inline';
-  /**
-   * How URL path parameters are arranged inside the inline argument list.
-   * - `'object'` groups them into one destructured object.
-   * - `'inline'` emits each path param as its own argument.
-   *
-   * @default 'inline'
-   */
-  pathParamsType?: 'object' | 'inline';
-};
 /**
  * Where the generated Cypress helpers 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.
@@ -53,20 +50,6 @@ type ParamsTypeOptions = {
  * @default { path: 'cypress', barrel: { type: 'named' } }
  */
 type Options = OutputOptions & {
-  /**
-   * Shape of the value returned from each helper.
-   * - `'data'` — only the response body.
-   * - `'full'` — the full Cypress response object (headers, status, body).
-   *
-   * @default 'data'
-   */
-  dataReturnType?: 'data' | 'full';
-  /**
-   * Rename parameter properties in the generated helpers (path, query, headers).
-   *
-   * @note Must match the value of `paramsCasing` on `@kubb/plugin-ts`.
-   */
-  paramsCasing?: 'camelcase';
   /**
    * Base URL prepended to every request URL. When omitted, falls back to the
    * adapter's server URL (typically `servers[0].url`).
@@ -92,11 +75,7 @@ type Options = OutputOptions & {
    * Macros applied to each operation node before printing.
    */
   macros?: Array<ast.Macro>;
-  /**
-   * Custom generators that run alongside the built-in Cypress generators.
-   */
-  generators?: Array<Generator<PluginCypress>>;
-} & ParamsTypeOptions;
+};
 type ResolvedOptions = {
   output: Output;
   exclude: Array<Exclude>;
@@ -104,10 +83,6 @@ type ResolvedOptions = {
   override: Array<Override<ResolvedOptions>>;
   group: Group | null;
   baseURL: Options['baseURL'] | undefined;
-  dataReturnType: NonNullable<Options['dataReturnType']>;
-  pathParamsType: NonNullable<NonNullable<Options['pathParamsType']>>;
-  paramsType: NonNullable<Options['paramsType']>;
-  paramsCasing: Options['paramsCasing'];
   resolver: ResolverCypress;
 };
 type PluginCypress = PluginFactoryOptions<'plugin-cypress', Options, ResolvedOptions, ResolverCypress>;
@@ -119,37 +94,6 @@ declare global {
   }
 }
 //#endregion
-//#region src/components/Request.d.ts
-type Props = {
-  /**
-   * Name of the function
-   */
-  name: string;
-  /**
-   * AST operation node
-   */
-  node: ast.OperationNode;
-  /**
-   * TypeScript resolver for resolving param/data/response type names
-   */
-  resolver: ResolverTs;
-  baseURL: string | null | undefined;
-  dataReturnType: PluginCypress['resolvedOptions']['dataReturnType'];
-  paramsCasing: PluginCypress['resolvedOptions']['paramsCasing'];
-  paramsType: PluginCypress['resolvedOptions']['paramsType'];
-  pathParamsType: PluginCypress['resolvedOptions']['pathParamsType'];
-};
-declare function Request({
-  baseURL,
-  name,
-  dataReturnType,
-  resolver,
-  node,
-  paramsType,
-  pathParamsType,
-  paramsCasing
-}: Props): KubbReactNode;
-//#endregion
 //#region src/generators/cypressGenerator.d.ts
 /**
  * Built-in generator for `@kubb/plugin-cypress`. Emits one typed
@@ -193,7 +137,7 @@ declare const pluginCypress: (options?: Options | undefined) => import("@kubb/co
 /**
  * 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-client`.
+ * camelCase, matching the convention from `@kubb/plugin-axios` and `@kubb/plugin-fetch`.
  *
  * @example Resolve a helper name
  * ```ts

package/dist/index.js

@@ -1,9 +1,8 @@
-import "./chunk-C0LytTxp.js";
+import "./rolldown-runtime-C0LytTxp.js";
 import { ast, defineGenerator, definePlugin, defineResolver } from "@kubb/core";
-import { caseParams, createOperationParams } from "@kubb/ast/utils";
-import { functionPrinter, pluginTsName } from "@kubb/plugin-ts";
 import { File, Function, jsxRenderer } from "@kubb/renderer-jsx";
 import { jsx, jsxs } from "@kubb/renderer-jsx/jsx-runtime";
+import { pluginTsName } from "@kubb/plugin-ts";
 //#region ../../internals/utils/src/casing.ts
 /**
 * Shared implementation for camelCase and PascalCase conversion.
@@ -216,6 +215,22 @@ var Url = class Url {
 		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 are camelCased to 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,
+			casing: "camelcase",
+			replacer: (name) => `path.${name}`
+		});
+	}
+	/**
 	* Returns the path and its extracted params as a structured `URLObject`, or as a stringified
 	* expression when `stringify` is set.
 	*
@@ -243,9 +258,108 @@ var Url = class Url {
 	}
 };
 //#endregion
+//#region ../../internals/shared/src/params.ts
+const caseParamsCache = /* @__PURE__ */ new WeakMap();
+/**
+* Applies camelCase to parameter names and returns a new array without mutating the input.
+*
+* Run it before handing parameters to schema builders so output property keys get the right casing
+* while `OperationNode.parameters` stays intact for other consumers. When `casing` is unset, the
+* original array is returned unchanged. Results are cached per input array.
+*/
+function caseParams(params, casing) {
+	if (!casing) return params;
+	const cached = caseParamsCache.get(params);
+	if (cached) return cached;
+	const result = params.map((param) => ({
+		...param,
+		name: camelCase(param.name)
+	}));
+	caseParamsCache.set(params, result);
+	return result;
+}
+function buildParamsMapping(originalParams, mappedParams) {
+	const mapping = {};
+	let hasChanged = false;
+	originalParams.forEach((param, i) => {
+		const mappedName = mappedParams[i]?.name ?? param.name;
+		mapping[param.name] = mappedName;
+		if (param.name !== mappedName) hasChanged = true;
+	});
+	return hasChanged ? mapping : null;
+}
+//#endregion
 //#region ../../internals/shared/src/operation.ts
+function getContentTypeInfo(node) {
+	const contentTypes = node.requestBody?.content?.map((e) => e.contentType) ?? [];
+	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 buildRequestConfigType(node) {
+	const { isMultipleContentTypes, contentTypeUnion } = getContentTypeInfo(node);
+	const configType = `Partial<Omit<RequestConfig, 'path' | 'query' | 'body' | 'headers' | 'url'>>`;
+	const contentTypeProp = isMultipleContentTypes ? `contentType?: ${contentTypeUnion}` : null;
+	return contentTypeProp ? `${configType} & { ${contentTypeProp} }` : configType;
+}
+/**
+* Which of the grouped request options an operation carries.
+*/
+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
+	};
+}
+/**
+* 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 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
+	};
+}
+/**
+* Builds the grouped `{ path, query, body, headers }` parameter for a generated client
+* function, typed from the operation's `RequestConfig` (minus `url`). Only the groups the
+* operation actually has are destructured. The trailing `config` parameter carries the
+* runtime `RequestConfig` overrides plus `client`.
+*/
+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.resolveRequestConfigName(node)}${isOptional ? " = {}" : ""}` : null, isConfigurable ? `config: ${buildRequestConfigType(node)} = {}` : null].filter(Boolean).join(", "),
+		groups
+	};
+}
 function getOperationParameters(node, options = {}) {
-	const params = caseParams(node.parameters, options.paramsCasing);
+	const params = caseParams(node.parameters, options.paramsCasing === "original" ? void 0 : "camelcase");
 	return {
 		path: params.filter((param) => param.in === "path"),
 		query: params.filter((param) => param.in === "query"),
@@ -269,7 +383,7 @@ function resolveStatusCodeNames(node, resolver) {
 }
 const typeNamesByResolver = /* @__PURE__ */ new WeakMap();
 function resolveOperationTypeNames(node, resolver, options = {}) {
-	const cacheKey = `${node.operationId}\0${options.paramsCasing ?? ""}\0${options.order ?? ""}\0${options.responseStatusNames ?? ""}\0${(options.exclude ?? []).join(",")}`;
+	const cacheKey = `${node.operationId}\0${options.paramsCasing ?? ""}\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);
@@ -281,7 +395,7 @@ function resolveOperationTypeNames(node, resolver, options = {}) {
 	const { path, query, header } = getOperationParameters(node, { paramsCasing: options.paramsCasing });
 	const responseStatusNames = options.responseStatusNames === "error" ? resolveErrorNames(node, resolver) : options.responseStatusNames === false ? [] : resolveStatusCodeNames(node, resolver);
 	const exclude = new Set(options.exclude ?? []);
-	const paramNames = [
+	const paramNames = options.includeParams === false ? [] : [
 		...path.map((param) => resolver.resolvePathParamsName(node, param)),
 		...query.map((param) => resolver.resolveQueryParamsName(node, param)),
 		...header.map((param) => resolver.resolveHeaderParamsName(node, param))
@@ -332,49 +446,31 @@ function createGroupConfig(group) {
 }
 //#endregion
 //#region src/components/Request.tsx
-const declarationPrinter = functionPrinter({ mode: "declaration" });
-function Request({ baseURL = "", name, dataReturnType, resolver, node, paramsType, pathParamsType, paramsCasing }) {
+function Request({ baseURL = "", name, resolver, node }) {
 	if (!ast.isHttpOperationNode(node)) return null;
-	const paramsNode = createOperationParams(node, {
-		paramsType,
-		pathParamsType,
-		paramsCasing,
-		resolver,
-		extraParams: [ast.factory.createFunctionParameter({
-			name: "options",
-			type: "Partial<Cypress.RequestOptions>",
-			default: "{}"
-		})]
-	});
-	const paramsSignature = declarationPrinter.print(paramsNode) ?? "";
+	const { query: originalQueryParams, header: originalHeaderParams } = getOperationParameters(node, { paramsCasing: "original" });
+	const { query: casedQueryParams, header: casedHeaderParams } = getOperationParameters(node);
+	const queryParamsMapping = buildParamsMapping(originalQueryParams, casedQueryParams);
+	const headerParamsMapping = buildParamsMapping(originalHeaderParams, casedHeaderParams);
+	const { signature, groups } = buildRequestParamsSignature(node, resolver, { isConfigurable: false });
+	const paramsSignature = [signature, "options: Partial<Cypress.RequestOptions> = {}"].filter(Boolean).join(", ");
 	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 = Url.toTemplateString(node.path, {
-		prefix: baseURL,
-		replacer: (param) => pathParamNameMap.get(camelCase(param)) ?? param,
-		casing: paramsCasing
-	});
+	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) if (queryParamsMapping) {
+		const pairs = Object.entries(queryParamsMapping).map(([originalName, camelCaseName]) => `${originalName}: query.${camelCaseName}`).join(", ");
+		requestOptions.push(`qs: query ? { ${pairs} } : undefined`);
+	} else requestOptions.push("qs: query");
+	if (groups.headers) if (headerParamsMapping) {
+		const pairs = Object.entries(headerParamsMapping).map(([originalName, camelCaseName]) => `'${originalName}': headers.${camelCaseName}`).join(", ");
+		requestOptions.push(`headers: headers ? { ${pairs} } : undefined`);
+	} else 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,
@@ -384,11 +480,7 @@ 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
 		})
 	});
 }
@@ -405,11 +497,11 @@ const cypressGenerator = defineGenerator({
 	operation(node, ctx) {
 		if (!ast.isHttpOperationNode(node)) return null;
 		const { config, resolver, driver, root } = ctx;
-		const { output, baseURL, dataReturnType, paramsCasing, paramsType, pathParamsType, group } = ctx.options;
+		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.resolveRequestConfigName(node), ...resolveOperationTypeNames(node, tsResolver, { includeParams: false })];
 		const meta = {
 			name: resolver.resolveName(node.operationId),
 			file: resolver.resolveFile({
@@ -462,10 +554,6 @@ const cypressGenerator = defineGenerator({
 				name: meta.name,
 				node,
 				resolver: tsResolver,
-				dataReturnType,
-				paramsCasing,
-				paramsType,
-				pathParamsType,
 				baseURL
 			})]
 		});
@@ -476,7 +564,7 @@ const cypressGenerator = defineGenerator({
 /**
 * 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-client`.
+* camelCase, matching the convention from `@kubb/plugin-axios` and `@kubb/plugin-fetch`.
 *
 * @example Resolve a helper name
 * ```ts
@@ -532,7 +620,7 @@ const pluginCypress = definePlugin((options) => {
 	const { output = {
 		path: "cypress",
 		barrel: { type: "named" }
-	}, group, exclude = [], include, override = [], dataReturnType = "data", baseURL, paramsCasing, paramsType = "inline", pathParamsType = paramsType === "object" ? "object" : options.pathParamsType || "inline", resolver: userResolver, macros: userMacros, generators: userGenerators = [] } = options;
+	}, group, exclude = [], include, override = [], baseURL, resolver: userResolver, macros: userMacros } = options;
 	const groupConfig = createGroupConfig(group);
 	return {
 		name: pluginCypressName,
@@ -548,18 +636,13 @@ const pluginCypress = definePlugin((options) => {
 				exclude,
 				include,
 				override,
-				dataReturnType,
 				group: groupConfig,
 				baseURL,
-				paramsCasing,
-				paramsType,
-				pathParamsType,
 				resolver
 			});
 			ctx.setResolver(resolver);
 			if (userMacros?.length) ctx.setMacros(userMacros);
 			ctx.addGenerator(cypressGenerator);
-			for (const gen of userGenerators) ctx.addGenerator(gen);
 		} }
 	};
 });