@kubb/adapter-oas 5.0.0-alpha.11 → 5.0.0-alpha.13

package/dist/index.js

@@ -157,9 +157,12 @@ function toCamelOrPascal(text, pascal) {
 * 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.
 */
 function applyToFileParts(text, transformPart) {
-	const parts = text.split(".");
+	const parts = text.split(/\.(?=[a-zA-Z])/);
 	return parts.map((part, i) => transformPart(part, i === parts.length - 1)).join("/");
 }
 /**
@@ -1250,6 +1253,7 @@ function createOasParser(oas, { contentType, collisionDetection } = {}) {
 				pattern: schema.pattern ?? ("pattern" in memberNode ? memberNode.pattern : void 0)
 			});
 		}
+		const filteredDiscriminantValues = [];
 		const allOfMembers = schema.allOf.filter((item) => {
 			if (!isReference(item) || !name) return true;
 			const deref = oas.get(item.$ref);
@@ -1259,7 +1263,15 @@ function createOasParser(oas, { contentType, collisionDetection } = {}) {
 			const childRef = `#/components/schemas/${name}`;
 			const inOneOf = parentUnion.some((oneOfItem) => isReference(oneOfItem) && oneOfItem.$ref === childRef);
 			const inMapping = Object.values(deref.discriminator.mapping ?? {}).some((v) => v === childRef);
-			return !inOneOf && !inMapping;
+			if (inOneOf || inMapping) {
+				const discriminatorValue = Object.entries(deref.discriminator.mapping ?? {}).find(([, v]) => v === childRef)?.[0];
+				if (discriminatorValue) filteredDiscriminantValues.push({
+					propertyName: deref.discriminator.propertyName,
+					value: discriminatorValue
+				});
+				return false;
+			}
+			return true;
 		}).map((s) => convertSchema({ schema: s }, options));
 		const syntheticStart = allOfMembers.length;
 		if (Array.isArray(schema.required) && schema.required.length) {
@@ -1284,9 +1296,22 @@ function createOasParser(oas, { contentType, collisionDetection } = {}) {
 			const { allOf: _allOf, ...schemaWithoutAllOf } = schema;
 			allOfMembers.push(convertSchema({ schema: schemaWithoutAllOf }, options));
 		}
+		for (const { propertyName, value } of filteredDiscriminantValues) allOfMembers.push(createSchema({
+			type: "object",
+			primitive: "object",
+			properties: [createProperty({
+				name: propertyName,
+				schema: createSchema({
+					type: "enum",
+					primitive: "string",
+					enumValues: [value]
+				}),
+				required: true
+			})]
+		}));
 		return createSchema({
 			type: "intersection",
-			members: [...allOfMembers.slice(0, syntheticStart), ...mergeAdjacentAnonymousObjects(allOfMembers.slice(syntheticStart))],
+			members: [...mergeAdjacentAnonymousObjects(allOfMembers.slice(0, syntheticStart)), ...mergeAdjacentAnonymousObjects(allOfMembers.slice(syntheticStart))],
 			...renderSchemaBase(schema, name, nullable, defaultValue)
 		});
 	}
@@ -1330,6 +1355,33 @@ function createOasParser(oas, { contentType, collisionDetection } = {}) {
 				})
 			});
 		}
+		const discriminator = isDiscriminator(schema) ? schema.discriminator : void 0;
+		if (discriminator?.mapping) return createSchema({
+			type: "union",
+			...unionBase,
+			members: unionMembers.map((s) => {
+				const ref = isReference(s) ? s.$ref : void 0;
+				const discriminatorValue = ref ? Object.entries(discriminator.mapping).find(([, v]) => v === ref)?.[0] : void 0;
+				const memberNode = convertSchema({ schema: s }, options);
+				if (!discriminatorValue) return memberNode;
+				return createSchema({
+					type: "intersection",
+					members: [memberNode, createSchema({
+						type: "object",
+						primitive: "object",
+						properties: [createProperty({
+							name: discriminator.propertyName,
+							schema: createSchema({
+								type: "enum",
+								primitive: "string",
+								enumValues: [discriminatorValue]
+							}),
+							required: true
+						})]
+					})]
+				});
+			})
+		});
 		return createSchema({
 			type: "union",
 			...unionBase,
@@ -1349,8 +1401,7 @@ function createOasParser(oas, { contentType, collisionDetection } = {}) {
 			name,
 			title: schema.title,
 			description: schema.description,
-			deprecated: schema.deprecated,
-			nullable
+			deprecated: schema.deprecated
 		});
 		return createSchema({
 			type: "enum",
@@ -1552,14 +1603,23 @@ function createOasParser(oas, { contentType, collisionDetection } = {}) {
 			const required = Array.isArray(schema.required) ? schema.required.includes(propName) : !!schema.required;
 			const resolvedPropSchema = propSchema;
 			const propNullable = isNullable(resolvedPropSchema);
+			let schemaNode = applyEnumName(convertSchema({
+				schema: resolvedPropSchema,
+				name: resolveChildName(name, propName)
+			}, options), name, propName, mergedOptions.enumSuffix);
+			const tupleNode = narrowSchema(schemaNode, "tuple");
+			if (tupleNode?.items) {
+				const namedItems = tupleNode.items.map((item) => applyEnumName(item, name, propName, mergedOptions.enumSuffix));
+				if (namedItems.some((item, i) => item !== tupleNode.items[i])) schemaNode = {
+					...tupleNode,
+					items: namedItems
+				};
+			}
 			return createProperty({
 				name: propName,
 				schema: {
-					...applyEnumName(convertSchema({
-						schema: resolvedPropSchema,
-						name: resolveChildName(name, propName)
-					}, options), name, propName, mergedOptions.enumSuffix),
-					nullable: propNullable || void 0,
+					...schemaNode,
+					nullable: schemaNode.type === "null" ? void 0 : propNullable || void 0,
 					optional: !required && !propNullable ? true : void 0,
 					nullish: !required && propNullable ? true : void 0
 				},
@@ -1596,15 +1656,17 @@ function createOasParser(oas, { contentType, collisionDetection } = {}) {
 	/**
 	* Converts an OAS 3.1 `prefixItems` tuple into a `TupleSchemaNode`.
 	*
-	* Each `prefixItems` element maps to a positional tuple slot. An optional `items` schema
-	* after the prefix items is mapped to the rest parameter of the tuple.
+	* Each `prefixItems` element maps to a positional tuple slot. When an explicit `items` schema
+	* is present alongside `prefixItems`, it becomes the rest element. When `items` is absent,
+	* a rest element of type `any` is emitted to match JSON Schema semantics (absent `items`
+	* means additional items are allowed).
 	*/
 	function convertTuple({ schema, name, nullable, defaultValue, options }) {
 		return createSchema({
 			type: "tuple",
 			primitive: "array",
 			items: (schema.prefixItems ?? []).map((item) => convertSchema({ schema: item }, options)),
-			rest: schema.items ? convertSchema({ schema: schema.items }, options) : void 0,
+			rest: schema.items ? convertSchema({ schema: schema.items }, options) : createSchema({ type: "any" }),
 			min: schema.minItems,
 			max: schema.maxItems,
 			...renderSchemaBase(schema, name, nullable, defaultValue)
@@ -1771,11 +1833,11 @@ function createOasParser(oas, { contentType, collisionDetection } = {}) {
 	}
 	/**
 	* Converts a single dereferenced OAS parameter object into a `ParameterNode`.
-	* When the parameter has no `schema` or its schema is a `$ref`, falls back to `unknownType`.
+	* When the parameter has no `schema`, falls back to `unknownType`; `$ref` schemas are resolved through `convertSchema` to produce a proper named type reference.
 	*/
 	function parseParameter(options, param) {
 		const required = param["required"] ?? false;
-		const schema = param["schema"] && !isReference(param["schema"]) ? convertSchema({ schema: param["schema"] }, options) : createSchema({ type: resolveTypeOption(options.unknownType) });
+		const schema = param["schema"] ? convertSchema({ schema: param["schema"] }, options) : createSchema({ type: resolveTypeOption(options.unknownType) });
 		return createParameter({
 			name: param["name"],
 			in: param["in"],
@@ -1794,18 +1856,28 @@ function createOasParser(oas, { contentType, collisionDetection } = {}) {
 	function parseOperation(options, oas, operation) {
 		const parameters = oas.getParameters(operation).map((param) => parseParameter(options, param));
 		const requestBodySchema = oas.getRequestSchema(operation);
-		const requestBody = requestBodySchema ? convertSchema({ schema: requestBodySchema }, options) : void 0;
+		const requestBodySchemaNode = requestBodySchema ? convertSchema({ schema: requestBodySchema }, options) : void 0;
+		const requestBodyDescription = operation.schema.requestBody && !isReference(operation.schema.requestBody) ? operation.schema.requestBody.description : void 0;
+		const requestBodyKeysToOmit = requestBodySchema?.properties ? Object.entries(requestBodySchema.properties).filter(([, prop]) => !isReference(prop) && prop.readOnly).map(([key]) => key) : void 0;
+		const requestBody = requestBodySchemaNode ? {
+			description: requestBodyDescription,
+			schema: requestBodySchemaNode,
+			keysToOmit: requestBodyKeysToOmit?.length ? requestBodyKeysToOmit : void 0
+		} : void 0;
 		const responses = operation.getResponseStatusCodes().map((statusCode) => {
 			const responseObj = operation.getResponseByStatusCode(statusCode);
 			const responseSchema = oas.getResponseSchema(operation, statusCode);
 			const schema = responseSchema && Object.keys(responseSchema).length > 0 ? convertSchema({ schema: responseSchema }, options) : createSchema({ type: resolveTypeOption(options.emptySchemaType) });
 			const description = typeof responseObj === "object" && responseObj !== null && !Array.isArray(responseObj) ? responseObj.description : void 0;
 			const rawContent = typeof responseObj === "object" && responseObj !== null && !Array.isArray(responseObj) ? responseObj.content : void 0;
+			const mediaType = rawContent ? toMediaType(Object.keys(rawContent)[0] ?? "") : toMediaType(operation.contentType ?? "");
+			const keysToOmit = responseSchema?.properties ? Object.entries(responseSchema.properties).filter(([, prop]) => !isReference(prop) && prop.writeOnly).map(([key]) => key) : void 0;
 			return createResponse({
 				statusCode,
 				description,
 				schema,
-				mediaType: rawContent ? toMediaType(Object.keys(rawContent)[0] ?? "") : toMediaType(operation.contentType ?? "")
+				mediaType,
+				keysToOmit: keysToOmit?.length ? keysToOmit : void 0
 			});
 		});
 		return createOperation({
@@ -1939,16 +2011,17 @@ const adapterOas = createAdapter((options) => {
 				contentType,
 				collisionDetection
 			});
+			const root = parser.parse({
+				dateType,
+				integerType,
+				unknownType,
+				emptySchemaType,
+				enumSuffix
+			});
 			nameMapping.clear();
 			for (const [key, value] of parser.nameMapping) nameMapping.set(key, value);
 			return createRoot({
-				...parser.parse({
-					dateType,
-					integerType,
-					unknownType,
-					emptySchemaType,
-					enumSuffix
-				}),
+				...root,
 				meta: {
 					title: oas.api.info?.title,
 					description: oas.api.info?.description,