@kubb/plugin-fetch 5.0.0-beta.98 → 5.0.0-beta.99

package/dist/index.cjs

@@ -228,33 +228,17 @@ function buildJSDoc(comments, options = {}) {
 }
 //#endregion
 //#region ../../internals/utils/src/url.ts
-function transformParam(raw, casing) {
-	const param = isValidVarName(raw) ? raw : camelCase(raw);
-	return casing === "camelcase" ? camelCase(param) : param;
-}
-function toParamsObject(path, { replacer, casing } = {}) {
-	const params = {};
-	for (const match of path.matchAll(/\{([^}]+)\}/g)) {
-		const param = transformParam(match[1], casing);
-		const key = replacer ? replacer(param) : param;
-		params[key] = key;
-	}
-	return Object.keys(params).length > 0 ? params : null;
+/**
+* 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);
 }
 /**
-* Helpers for OpenAPI/Swagger paths, plus a thin wrapper over the native `URL`.
+* Helpers for OpenAPI/Swagger paths.
 */
 var Url = class Url {
-	/**
-	* Reports whether `url` is a parseable absolute URL. Delegates to the native `URL.canParse`.
-	*
-	* @example
-	* Url.canParse('https://petstore.swagger.io/v2') // true
-	* Url.canParse('/pet/{petId}')                   // false
-	*/
-	static canParse(url, base) {
-		return URL.canParse(url, base);
-	}
 	/**
 	* Converts an OpenAPI/Swagger path to Express-style colon syntax.
 	*
@@ -270,15 +254,14 @@ var Url = class Url {
 	* key.
 	*
 	* @example
-	* Url.toCasedTemplate('/projects/{project_id}', { casing: 'camelcase' }) // '/projects/{projectId}'
+	* Url.toSafeTemplate('/user/{monetary-account-id}') // '/user/{monetaryAccountId}'
 	*/
-	static toCasedTemplate(path, { casing } = {}) {
-		return path.replace(/\{([^}]+)\}/g, (_, name) => `{${transformParam(name, casing)}}`);
+	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, `replacer` transforms each parameter name,
-	* and `casing` controls parameter identifier casing.
+	* `prefix` is prepended inside the literal, and `replacer` transforms each parameter name.
 	*
 	* @example
 	* Url.toTemplateString('/pet/{petId}') // '`/pet/${petId}`'
@@ -286,10 +269,10 @@ var Url = class Url {
 	* @example
 	* Url.toTemplateString('/pet/{petId}', { prefix: 'https://api' }) // '`https://api/pet/${petId}`'
 	*/
-	static toTemplateString(path, { prefix, replacer, casing } = {}) {
+	static toTemplateString(path, { prefix, replacer } = {}) {
 		const result = path.split(/\{([^}]+)\}/).map((part, i) => {
 			if (i % 2 === 0) return part;
-			const param = transformParam(part, casing);
+			const param = transformParam(part);
 			return `\${${replacer ? replacer(param) : param}}`;
 		}).join("");
 		return `\`${prefix ?? ""}${result}\``;
@@ -297,8 +280,8 @@ var Url = class Url {
 	/**
 	* 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.
+	* 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}`'
@@ -306,103 +289,28 @@ var Url = class Url {
 	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.
-	*
-	* @example
-	* Url.toObject('/pet/{petId}')
-	* // { url: '/pet/:petId', params: { petId: 'petId' } }
-	*/
-	static toObject(path, { type = "path", replacer, stringify, casing } = {}) {
-		const object = {
-			url: type === "path" ? Url.toPath(path) : Url.toTemplateString(path, {
-				replacer,
-				casing
-			}),
-			params: toParamsObject(path, {
-				replacer,
-				casing
-			})
-		};
-		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;
-	}
 };
 //#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;
-}
 /**
-* Drops parameters that collapse to the same property identity once camelCased, keeping the first.
+* Drops parameters that share the same name, keeping the first.
 *
-* Some specs declare the same parameter twice under different casings (for example AWS S3 lists both
-* `max-uploads` and `MaxUploads`). Both resolve to one output property, so emitting both would yield
-* an object type with a duplicate member, which TypeScript rejects. De-duplicate by the camelCased
-* identity so the resulting group is collision-free regardless of the names each caller carries.
+* 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 dedupeByCasedName(params) {
+function dedupeParams(params) {
 	const seen = /* @__PURE__ */ new Set();
 	return params.filter((param) => {
-		const key = camelCase(param.name);
-		if (seen.has(key)) return false;
-		seen.add(key);
+		if (seen.has(param.name)) return false;
+		seen.add(param.name);
 		return true;
 	});
 }
-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;
-}
-function toAccess(object, name) {
-	return isValidVarName(name) ? `${object}.${name}` : `${object}[${JSON.stringify(name)}]`;
-}
-/**
-* Renders the object-literal expression that renames the camelCased keys of a grouped request
-* option back to the names the OpenAPI document declares, guarded so an omitted optional group
-* stays omitted. Shared by the client and cypress generators, which pass a `buildParamsMapping`
-* result and the source expression to read the keys from.
-*
-* @example
-* ```ts
-* buildParamsRemapExpression({ source: 'config.query', mapping: { include_deleted: 'includeDeleted' } })
-* // 'config.query ? { "include_deleted": config.query.includeDeleted } : config.query'
-* ```
-*/
-function buildParamsRemapExpression({ source, mapping }) {
-	return `${source} ? { ${Object.entries(mapping).map(([originalName, casedName]) => `${JSON.stringify(originalName)}: ${toAccess(source, casedName)}`).join(", ")} } : ${source}`;
-}
 //#endregion
 //#region ../../internals/shared/src/operation.ts
 /**
@@ -536,13 +444,15 @@ function buildOperationComments(node, options = {}) {
 	if (!splitLines) return filteredComments;
 	return filteredComments.flatMap((text) => text.split(/\r?\n/).map((line) => line.trim())).filter((comment) => Boolean(comment));
 }
-function getOperationParameters(node, options = {}) {
-	const params = caseParams(node.parameters, options.paramsCasing === "original" ? void 0 : "camelcase");
+function getOperationParameters(node) {
 	return {
-		path: dedupeByCasedName(params.filter((param) => param.in === "path")),
-		query: dedupeByCasedName(params.filter((param) => param.in === "query")),
-		header: dedupeByCasedName(params.filter((param) => param.in === "header")),
-		cookie: dedupeByCasedName(params.filter((param) => param.in === "cookie"))
+		path: dedupeParams(node.parameters.filter((param) => param.in === "path").map((param) => isValidVarName(param.name) ? param : {
+			...param,
+			name: camelCase(param.name)
+		})),
+		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) {
@@ -594,38 +504,6 @@ function createGroupConfig(group) {
 	};
 }
 //#endregion
-//#region ../../internals/client/src/builders/paramsRemap.ts
-/**
-* Builds the call-config entries that rename the camelCased `query` and `headers` keys back to the
-* names the OpenAPI document declares, so the wire format follows the spec while the generated
-* types keep camelCase keys. Returns an empty array when no name changes. Path parameters need no
-* remap because the URL template placeholders are renamed in sync with the `path` keys. Emit the
-* entries after the `...config` spread so they override the camelCased groups the caller passes in.
-*
-* @example
-* ```ts
-* // a query param named include_deleted in the spec
-* buildParamsRemap({ node }) // ['query: config.query ? { "include_deleted": config.query.includeDeleted } : config.query']
-* ```
-*/
-function buildParamsRemap({ node }) {
-	if (!kubb_kit.ast.isHttpOperationNode(node)) return [];
-	const original = getOperationParameters(node, { paramsCasing: "original" });
-	const cased = getOperationParameters(node);
-	const queryMapping = buildParamsMapping(original.query, cased.query);
-	const headerMapping = buildParamsMapping(original.header, cased.header);
-	const entries = [];
-	if (queryMapping) entries.push(`query: ${buildParamsRemapExpression({
-		source: "config.query",
-		mapping: queryMapping
-	})}`);
-	if (headerMapping) entries.push(`headers: ${buildParamsRemapExpression({
-		source: "config.headers",
-		mapping: headerMapping
-	})}`);
-	return entries;
-}
-//#endregion
 //#region ../../internals/client/src/builders/generics.ts
 /**
 * Builds the `RequestResult` generic arguments for one operation: the plugin-ts per-status responses
@@ -857,11 +735,10 @@ function buildCallConfig({ node, validator, zodResolver, security }) {
 	const securityLiteral = buildSecurityMetadata({ security });
 	return `{ ${[
 		`method: '${node.method.toUpperCase()}'`,
-		`url: '${Url.toCasedTemplate(node.path, { casing: "camelcase" })}'`,
+		`url: '${Url.toSafeTemplate(node.path)}'`,
 		securityLiteral ? `security: ${securityLiteral}` : null,
 		validatorLiteral,
-		"...config",
-		...buildParamsRemap({ node })
+		"...config"
 	].filter(Boolean).join(", ")} }`;
 }
 /**
@@ -987,14 +864,13 @@ function Operation({ name, node, tsResolver, zodResolver, validator, security, i
 	const validatorLiteral = validatorEntries.length ? `validator: { ${validatorEntries.join(", ")} }` : null;
 	const callConfig = `{ ${[
 		`method: '${node.method.toUpperCase()}'`,
-		`url: '${Url.toCasedTemplate(node.path, { casing: "camelcase" })}'`,
+		`url: '${Url.toSafeTemplate(node.path)}'`,
 		securityLiteral ? `security: ${securityLiteral}` : null,
 		stylesLiteral ? `styles: ${stylesLiteral}` : null,
 		validatorLiteral,
 		contentTypeLiteral,
 		responseTypeLiteral,
-		"...config",
-		...buildParamsRemap({ node })
+		"...config"
 	].filter(Boolean).join(", ")} }`;
 	const eventType = `SuccessOf<${tsResolver.response.responses(node)}>`;
 	const returnType = eventStream ? `Promise<EventStreamResult<${eventType}>>` : signature.returnType;
@@ -1087,7 +963,7 @@ function resolveTypeImportNames(node, tsResolver) {
 	return [tsResolver.response.options(node), tsResolver.response.responses(node)];
 }
 function resolveZodImportNames(node, zodResolver, validator) {
-	const { query: queryParams } = getOperationParameters(node, { paramsCasing: "original" });
+	const { query: queryParams } = getOperationParameters(node);
 	return [
 		resolveResponseValidator(validator) === "zod" ? zodResolver.response.response(node) : null,
 		resolveResponseValidator(validator) === "zod" ? buildZodErrorParse(node, zodResolver)?.expression ?? null : null,