@kubb/plugin-ts 5.0.0-beta.98 → 5.0.0

package/dist/index.d.ts

@@ -845,10 +845,6 @@ type CreateOperationParamsOptions = {
    * - `'inlineSpread'` emits a single rest parameter `...pathParams: PathParams`
    */
   pathParamsType: 'object' | 'inline' | 'inlineSpread';
-  /**
-   * Converts parameter names to camelCase before output.
-   */
-  paramsCasing?: 'camelcase';
   /**
    * Resolver for parameter and request body type names.
    * Pass `ResolverTs` from `@kubb/plugin-ts` directly.

package/dist/index.js

@@ -1,7 +1,7 @@
 import { n as __name, t as __exportAll } from "./rolldown-runtime-CNktS9qV.js";
 import { parserTs } from "@kubb/parser-ts";
 import { File, jsxRenderer } from "kubb/jsx";
-import { Resolver, ast, createResolver, defineGenerator, definePlugin } from "kubb/kit";
+import { Resolver, ast, createResolver, defineGenerator, definePlugin, isStringType, syncSchemaRef } from "kubb/kit";
 import ts from "typescript";
 import { Fragment, jsx, jsxs } from "kubb/jsx/jsx-runtime";
 //#region ../../internals/utils/src/casing.ts
@@ -817,7 +817,7 @@ function buildTupleNode(node, print) {
 */
 function buildPropertyType(schema, baseType, optionalType, optional) {
 	const addsUndefined = OPTIONAL_ADDS_UNDEFINED.has(optionalType);
-	const meta = ast.syncSchemaRef(schema);
+	const meta = syncSchemaRef(schema);
 	let type = baseType;
 	if (meta.nullable) type = createUnionDeclaration({ nodes: [type, keywordTypeNodes.null] });
 	if ((optional || meta.nullish || meta.optional) && addsUndefined) type = createUnionDeclaration({ nodes: [type, keywordTypeNodes.undefined] });
@@ -912,39 +912,19 @@ function Enum({ node, enum: enumOptions, resolver }) {
 }
 //#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.
+* Drops parameters that share the same name, keeping the first.
 *
-* 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.
+* 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 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.
-*
-* 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.
-*/
-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;
 	});
 }
@@ -998,14 +978,81 @@ function resolveContentTypeVariants(entries, baseName) {
 		};
 	});
 }
-function getOperationParameters(node, options = {}) {
-	const params = caseParams(node.parameters, options.paramsCasing === "original" ? void 0 : "camelcase");
-	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"))
+const operationParameterGroupsByNode = /* @__PURE__ */ new WeakMap();
+/**
+* Groups an operation's parameters by location (`path`/`query`/`header`/`cookie`), deduping each
+* group by name. Every plugin generator visiting the same `OperationNode` shares one AST instance
+* (see `KubbDriver`), so the result is cached per node to avoid re-filtering and re-deduping the
+* same parameters once per plugin.
+*/
+function getOperationParameters(node) {
+	const cached = operationParameterGroupsByNode.get(node);
+	if (cached) return cached;
+	const groups = {
+		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"))
 	};
+	operationParameterGroupsByNode.set(node, groups);
+	return groups;
+}
+/**
+* Builds the combined `{ body, path, query, headers }` options object schema for an operation,
+* referencing the already-resolved body and grouped param names. Shared by `@kubb/plugin-ts`'s
+* `Options` type and `@kubb/plugin-zod`'s inferred options schema, so both printers emit the same
+* shape from the same inputs. `primitive: 'object'` is a no-op for the TS printer and tells the Zod
+* printer to emit `z.object(…)` rather than a record.
+*/
+function buildOptionsSchema(node, resolver) {
+	const { path, query, header } = getOperationParameters(node);
+	const hasBody = Boolean(node.requestBody?.content?.[0]?.schema);
+	const createNever = () => ast.factory.createSchema({
+		type: "never",
+		primitive: void 0,
+		optional: true
+	});
+	const groups = [
+		{
+			name: "path",
+			params: path,
+			resolve: resolver.param.path
+		},
+		{
+			name: "query",
+			params: query,
+			resolve: resolver.param.query
+		},
+		{
+			name: "headers",
+			params: header,
+			resolve: resolver.param.headers
+		}
+	];
+	return ast.factory.createSchema({
+		type: "object",
+		primitive: "object",
+		deprecated: node.deprecated,
+		properties: [ast.factory.createProperty({
+			name: "body",
+			required: hasBody,
+			schema: hasBody ? ast.factory.createSchema({
+				type: "ref",
+				name: resolver.response.body(node)
+			}) : createNever()
+		}), ...groups.map(({ name, params, resolve }) => {
+			const required = params.some((param) => param.required);
+			return ast.factory.createProperty({
+				name,
+				required,
+				schema: params.length > 0 ? ast.factory.createSchema({
+					type: "ref",
+					name: resolve.call(resolver.param, node, params[0]),
+					optional: !required
+				}) : createNever()
+			});
+		})]
+	});
 }
 //#endregion
 //#region ../../internals/shared/src/resolver.ts
@@ -1090,7 +1137,7 @@ function createCasedFile(caseLast) {
 * `resolver.imports` would resolve file paths that are then discarded.
 */
 function collectRefNames(schema) {
-	return ast.collect(schema, { schema: (node) => {
+	return ast.collectSync(schema, { schema: (node) => {
 		const refNode = ast.narrowSchema(node, "ref");
 		if (!refNode?.ref) return null;
 		return ast.resolveRefName(refNode);
@@ -1128,6 +1175,35 @@ function createGroupConfig(group) {
 	};
 }
 //#endregion
+//#region ../../internals/shared/src/schemaTraversal.ts
+/**
+* Maps each property of an object schema to its transformed output. Pairs every result with the
+* original property so the printer keeps full control over modifiers, getters, and key syntax.
+*
+* @example
+* ```ts
+* const entries = mapSchemaProperties(node, (schema) => this.transform(schema))
+* // entries: [{ name: 'id', property, output: 'z.number()' }, ...]
+* ```
+*/
+function mapSchemaProperties(node, transform) {
+	return node.properties.map((property) => ({
+		name: property.name,
+		property,
+		output: transform(property.schema)
+	}));
+}
+/**
+* Maps each item of an array or tuple schema to its transformed output, pairing every result with
+* the original item.
+*/
+function mapSchemaItems(node, transform) {
+	return (node.items ?? []).map((schema) => ({
+		schema,
+		output: transform(schema)
+	}));
+}
+//#endregion
 //#region src/utils.ts
 /**
 * Tells whether a `const` (single-value enum) should render as a bare literal type (`'active'`)
@@ -1156,12 +1232,12 @@ function formatExample(value) {
 	return (JSON.stringify(value) ?? String(value)).replaceAll("*/", "*\\/");
 }
 function buildPropertyJSDocComments(schema, optional) {
-	const meta = ast.syncSchemaRef(schema);
+	const meta = syncSchemaRef(schema);
 	const isArray = meta?.primitive === "array";
 	const hasDescription = meta && "description" in meta && meta.description;
 	const formatComment = meta && "format" in meta && meta.format ? hasDescription ? [" ", `Format: \`${meta.format}\``] : ["@description", `Format: \`${meta.format}\``] : [];
 	const exampleValues = meta?.examples ?? [];
-	return [
+	const comments = [
 		hasDescription ? `@description ${jsStringEscape(meta.description)}` : null,
 		...formatComment,
 		meta && "deprecated" in meta && meta.deprecated ? "@deprecated" : null,
@@ -1169,9 +1245,10 @@ function buildPropertyJSDocComments(schema, optional) {
 		!isArray && meta && "max" in meta && meta.max !== void 0 ? `@maxLength ${meta.max}` : null,
 		meta && "pattern" in meta && meta.pattern ? `@pattern ${meta.pattern}` : null,
 		meta && "default" in meta && meta.default !== void 0 ? `@default ${"primitive" in meta && meta.primitive === "string" && typeof meta.default === "string" ? stringify(meta.default) : meta.default}` : null,
-		...exampleValues.map((example) => `@example ${formatExample(example)}`),
-		meta && "primitive" in meta && meta.primitive ? [`@type ${meta.primitive}`, optional ?? isSchemaOptional(schema) ? " | undefined" : null].filter(Boolean).join("") : null
+		...exampleValues.map((example) => `@example ${formatExample(example)}`)
 	].filter(Boolean);
+	const typeTag = comments.length && meta && "primitive" in meta && meta.primitive ? [`@type ${meta.primitive}`, optional ?? isSchemaOptional(schema) ? " | undefined" : null].filter(Boolean).join("") : null;
+	return [...comments, typeTag].filter(Boolean);
 }
 /**
 * Builds the object schema for a group of parameters sharing one `in` location (path, query, or
@@ -1191,70 +1268,6 @@ function buildParams({ params }) {
 		}))
 	});
 }
-function buildOptions(node, { resolver }) {
-	const { path: pathParams, query: queryParams, header: headerParams } = getOperationParameters(node, { paramsCasing: "original" });
-	const hasBody = Boolean(node.requestBody?.content?.[0]?.schema);
-	const hasRequiredPath = pathParams.some((param) => param.required);
-	const hasRequiredQuery = queryParams.some((param) => param.required);
-	const hasRequiredHeader = headerParams.some((param) => param.required);
-	return ast.factory.createSchema({
-		type: "object",
-		deprecated: node.deprecated,
-		properties: [
-			ast.factory.createProperty({
-				name: "body",
-				required: hasBody,
-				schema: hasBody ? ast.factory.createSchema({
-					type: "ref",
-					name: resolver.response.body(node)
-				}) : ast.factory.createSchema({
-					type: "never",
-					primitive: void 0,
-					optional: true
-				})
-			}),
-			ast.factory.createProperty({
-				name: "path",
-				required: hasRequiredPath,
-				schema: pathParams.length > 0 ? ast.factory.createSchema({
-					type: "ref",
-					name: resolver.param.path(node, pathParams[0]),
-					optional: !hasRequiredPath
-				}) : ast.factory.createSchema({
-					type: "never",
-					primitive: void 0,
-					optional: true
-				})
-			}),
-			ast.factory.createProperty({
-				name: "query",
-				required: hasRequiredQuery,
-				schema: queryParams.length > 0 ? ast.factory.createSchema({
-					type: "ref",
-					name: resolver.param.query(node, queryParams[0]),
-					optional: !hasRequiredQuery
-				}) : ast.factory.createSchema({
-					type: "never",
-					primitive: void 0,
-					optional: true
-				})
-			}),
-			ast.factory.createProperty({
-				name: "headers",
-				required: hasRequiredHeader,
-				schema: headerParams.length > 0 ? ast.factory.createSchema({
-					type: "ref",
-					name: resolver.param.headers(node, headerParams[0]),
-					optional: !hasRequiredHeader
-				}) : ast.factory.createSchema({
-					type: "never",
-					primitive: void 0,
-					optional: true
-				})
-			})
-		]
-	});
-}
 /**
 * The schema a status occupies in the `<Name>Responses` record. A status that documents several
 * content types becomes a `{ contentType; data }` union so the runtime can surface the negotiated type
@@ -1314,7 +1327,7 @@ function buildResponseUnion(node, { resolver }) {
 //#endregion
 //#region src/components/Type.tsx
 function Type({ name, node, printer, enum: enumOptions, resolver }) {
-	const enumSchemaNodes = ast.collect(node, { schema(n) {
+	const enumSchemaNodes = ast.collectSync(node, { schema(n) {
 		const enumNode = ast.narrowSchema(n, ast.schemaTypes.enum);
 		if (enumNode?.name && !isInlineConstEnum(enumNode, printer.options.enumSchemaNames)) return enumNode;
 	} });
@@ -1419,11 +1432,11 @@ const printerTs = ast.createPrinter((options) => {
 				const hasStringLiteral = members.some((m) => {
 					return ast.narrowSchema(m, ast.schemaTypes.enum)?.primitive === "string";
 				});
-				const hasPlainString = members.some((m) => ast.isStringType(m));
+				const hasPlainString = members.some((m) => isStringType(m));
 				if (hasStringLiteral && hasPlainString) return createUnionDeclaration({
 					withParentheses: true,
 					nodes: members.map((m) => {
-						if (ast.isStringType(m)) return createIntersectionDeclaration({
+						if (isStringType(m)) return createIntersectionDeclaration({
 							nodes: [keywordTypeNodes.string, createTypeLiteralNode([])],
 							withParentheses: true
 						});
@@ -1443,7 +1456,7 @@ const printerTs = ast.createPrinter((options) => {
 			},
 			array(node) {
 				return createArrayDeclaration({
-					nodes: ast.mapSchemaItems(node, (item) => this.transform(item)).map(({ output }) => output).filter(isNonNullable),
+					nodes: mapSchemaItems(node, (item) => this.transform(item)).map(({ output }) => output).filter(isNonNullable),
 					arrayType: this.options.arrayType
 				}) ?? null;
 			},
@@ -1453,11 +1466,11 @@ const printerTs = ast.createPrinter((options) => {
 			object(node) {
 				const { transform, options } = this;
 				const addsQuestionToken = OPTIONAL_ADDS_QUESTION_TOKEN.has(options.optionalType);
-				const propertyNodes = ast.mapSchemaProperties(node, (schema) => transform(schema)).map(({ name, property, output }) => {
+				const propertyNodes = mapSchemaProperties(node, (schema) => transform(schema)).map(({ name, property, output }) => {
 					const baseType = output ?? keywordTypeNodes.unknown;
 					const optional = !property.required || !!property.schema.optional || !!property.schema.nullish;
 					const type = buildPropertyType(property.schema, baseType, options.optionalType, optional);
-					const propMeta = ast.syncSchemaRef(property.schema);
+					const propMeta = syncSchemaRef(property.schema);
 					return appendJSDocToNode({
 						node: createPropertySignature({
 							questionToken: optional ? addsQuestionToken : false,
@@ -1478,7 +1491,7 @@ const printerTs = ast.createPrinter((options) => {
 			const { name, syntaxType = "type", description, keysToOmit } = this.options;
 			const transformed = this.transform(node);
 			if (!transformed) return null;
-			const meta = ast.syncSchemaRef(node);
+			const meta = syncSchemaRef(node);
 			if (!name) {
 				const withNullable = meta.nullable ? createUnionDeclaration({ nodes: [transformed, keywordTypeNodes.null] }) : transformed;
 				const result = (meta.nullish || meta.optional) && addsUndefined ? createUnionDeclaration({ nodes: [withNullable, keywordTypeNodes.undefined] }) : withNullable;
@@ -1609,7 +1622,6 @@ const typeGenerator = defineGenerator({
 	operation(node, ctx) {
 		const { enum: enumOptions, optionalType, arrayType, syntaxType, group, output, printer } = ctx.options;
 		const { config, resolver, root } = ctx;
-		const params = caseParams(node.parameters, "camelcase");
 		const meta = { file: resolver.file({
 			name: node.operationId,
 			extname: ".ts",
@@ -1688,10 +1700,7 @@ const typeGenerator = defineGenerator({
 				name: baseName
 			})] });
 		}
-		const { path: pathParams, query: queryParams, header: headerParams } = getOperationParameters({
-			...node,
-			parameters: params
-		}, { paramsCasing: "original" });
+		const { path: pathParams, query: queryParams, header: headerParams } = getOperationParameters(node);
 		const paramGroupTypes = [
 			pathParams.length > 0 && renderSchemaType({
 				schema: buildParams({ params: pathParams }),
@@ -1738,10 +1747,7 @@ const typeGenerator = defineGenerator({
 			});
 		});
 		const optionsType = renderSchemaType({
-			schema: buildOptions({
-				...node,
-				parameters: params
-			}, { resolver }),
+			schema: buildOptionsSchema(node, resolver),
 			name: resolver.response.options(node)
 		});
 		const responsesType = renderSchemaType({
@@ -2191,17 +2197,14 @@ function resolveGroupType({ node, params, group, resolver }) {
 * name resolution and `extraParams` for plugin-specific trailing parameters such as an `options` object.
 */
 function createOperationParams(node, options) {
-	const { paramsType, pathParamsType, paramsCasing, resolver, pathParamsDefault, extraParams = [], paramNames, typeWrapper } = options;
+	const { paramsType, pathParamsType, resolver, pathParamsDefault, extraParams = [], paramNames, typeWrapper } = options;
 	const dataName = paramNames?.data ?? "data";
 	const paramsName = paramNames?.params ?? "params";
 	const headersName = paramNames?.headers ?? "headers";
 	const pathName = paramNames?.path ?? "pathParams";
 	const wrapType = (type) => typeWrapper ? typeWrapper(type) : type;
 	const wrapTypeExpression = (type) => typeof type === "string" ? wrapType(type) : type;
-	const casedParams = caseParams(node.parameters, paramsCasing);
-	const pathParams = casedParams.filter((p) => p.in === "path");
-	const queryParams = casedParams.filter((p) => p.in === "query");
-	const headerParams = casedParams.filter((p) => p.in === "header");
+	const { path: pathParams, query: queryParams, header: headerParams } = getOperationParameters(node);
 	const toProperty = (param) => ({
 		name: param.name,
 		type: wrapTypeExpression(resolveParamType({