@kubb/adapter-oas 5.0.0-alpha.12 → 5.0.0-alpha.14

package/dist/index.js

@@ -886,12 +886,13 @@ function extractSchemaFromContent(content, preferredContentType) {
 * Returns the PascalCase suffix appended to a component name when resolving
 * cross-source name collisions (schemas vs. responses vs. requestBodies).
 */
+const semanticSuffixes = {
+	schemas: "Schema",
+	responses: "Response",
+	requestBodies: "Request"
+};
 function getSemanticSuffix(source) {
-	switch (source) {
-		case "schemas": return "Schema";
-		case "responses": return "Response";
-		case "requestBodies": return "Request";
-	}
+	return semanticSuffixes[source];
 }
 /**
 * Builds `GetSchemasResult` without any collision detection.
@@ -1253,6 +1254,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);
@@ -1262,7 +1264,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) {
@@ -1287,9 +1297,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)
 		});
 	}
@@ -1333,6 +1356,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,
@@ -1352,8 +1402,7 @@ function createOasParser(oas, { contentType, collisionDetection } = {}) {
 			name,
 			title: schema.title,
 			description: schema.description,
-			deprecated: schema.deprecated,
-			nullable
+			deprecated: schema.deprecated
 		});
 		return createSchema({
 			type: "enum",
@@ -1555,16 +1604,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,
-					optional: !required && !propNullable ? true : void 0,
-					nullish: !required && propNullable ? true : void 0
+					...schemaNode,
+					nullable: schemaNode.type === "null" ? void 0 : propNullable || void 0
 				},
 				required
 			});
@@ -1599,15 +1655,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)
@@ -1774,18 +1832,17 @@ 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"],
 			schema: {
 				...schema,
-				description: param["description"] ?? schema.description,
-				optional: !required || !!schema.optional ? true : void 0
+				description: param["description"] ?? schema.description
 			},
 			required
 		});
@@ -1798,8 +1855,10 @@ function createOasParser(oas, { contentType, collisionDetection } = {}) {
 		const parameters = oas.getParameters(operation).map((param) => parseParameter(options, param));
 		const requestBodySchema = oas.getRequestSchema(operation);
 		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;
@@ -1950,16 +2009,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,