@kubb/adapter-oas 5.0.0-alpha.42 → 5.0.0-alpha.44

package/dist/index.js

@@ -2,12 +2,9 @@ import "./chunk--u3MIqq1.js";
 import { ast, createAdapter } from "@kubb/core";
 import path from "node:path";
 import { bundle, loadConfig } from "@redocly/openapi-core";
-import yaml from "@stoplight/yaml";
 import OASNormalize from "oas-normalize";
-import { isPlainObject, mergeDeep } from "remeda";
 import swagger2openapi from "swagger2openapi";
 import BaseOas from "oas";
-import jsonpointer from "jsonpointer";
 import { isRef } from "oas/types";
 import { matchesMimeType } from "oas/utils";
 //#region src/constants.ts
@@ -30,6 +27,17 @@ const DEFAULT_PARSER_OPTIONS = {
 	enumSuffix: "enum"
 };
 /**
+* JSON-Pointer prefix for schemas declared under `components.schemas` in an OpenAPI document.
+*
+* Used when building or parsing `$ref` strings.
+*
+* @example
+* ```ts
+* `${SCHEMA_REF_PREFIX}Pet` // '#/components/schemas/Pet'
+* ```
+*/
+const SCHEMA_REF_PREFIX = "#/components/schemas/";
+/**
 * OpenAPI version string written into the stub document created during multi-spec merges.
 */
 const MERGE_OPENAPI_VERSION = "3.0.0";
@@ -258,6 +266,40 @@ function pascalCase(text, { isFile, prefix = "", suffix = "" } = {}) {
 	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, true);
 }
 //#endregion
+//#region ../../internals/utils/src/object.ts
+/**
+* Returns `true` when `value` is a plain (non-null, non-array) object.
+*
+* @example
+* ```ts
+* isPlainObject({})          // true
+* isPlainObject([])          // false
+* isPlainObject(null)        // false
+* ```
+*/
+function isPlainObject(value) {
+	return typeof value === "object" && value !== null && Object.getPrototypeOf(value) === Object.prototype;
+}
+/**
+* Recursively merges `source` into `target`, combining nested plain objects.
+* Arrays and non-object values from `source` override the corresponding values in `target`.
+*
+* @example
+* ```ts
+* mergeDeep({ a: { x: 1 } }, { a: { y: 2 } })
+* // { a: { x: 1, y: 2 } }
+* ```
+*/
+function mergeDeep(target, source) {
+	const result = { ...target };
+	for (const key of Object.keys(source)) {
+		const sv = source[key];
+		const tv = result[key];
+		result[key] = sv !== null && typeof sv === "object" && !Array.isArray(sv) && tv !== null && typeof tv === "object" && !Array.isArray(tv) ? mergeDeep(tv, sv) : sv;
+	}
+	return result;
+}
+//#endregion
 //#region ../../internals/utils/src/reserved.ts
 /**
 * Returns `true` when `name` is a syntactically valid JavaScript variable name.
@@ -520,7 +562,7 @@ async function parseDocument(pathOrApi, { canBundle = true, enablePaths = true }
 /**
 * Deep-merges multiple OpenAPI documents into a single `Document`.
 *
-* Each document is parsed independently then recursively merged with `remeda`'s `mergeDeep`.
+* Each document is parsed independently then recursively merged via `mergeDeep` from `@internals/utils`.
 * Throws when the input array is empty.
 *
 * @example
@@ -563,11 +605,7 @@ async function mergeDocuments(pathOrApi) {
 function parseFromConfig(source) {
 	if (source.type === "data") {
 		if (typeof source.data === "object") return parseDocument(structuredClone(source.data));
-		try {
-			return parseDocument(yaml.parse(source.data));
-		} catch {
-			return parseDocument(source.data);
-		}
+		return parseDocument(source.data, { canBundle: false });
 	}
 	if (source.type === "paths") return mergeDocuments(source.paths);
 	if (new URLPath(source.path).isURL) return parseDocument(source.path);
@@ -610,7 +648,7 @@ function resolveRef(document, $ref) {
 	if ($ref === "") return null;
 	if ($ref.startsWith("#")) $ref = globalThis.decodeURIComponent($ref.substring(1));
 	else return null;
-	const current = jsonpointer.get(document, $ref);
+	const current = $ref.split("/").filter(Boolean).reduce((obj, key) => obj?.[key], document);
 	if (!current) throw new Error(`Could not find a definition for ${origRef}.`);
 	return current;
 }
@@ -721,12 +759,11 @@ function getResponseBody(responseBody, contentType) {
 	}
 	let availableContentType;
 	const contentTypes = Object.keys(body.content);
-	contentTypes.forEach((mt) => {
-		if (!availableContentType && matchesMimeType.json(mt)) availableContentType = mt;
-	});
-	if (!availableContentType) contentTypes.forEach((mt) => {
-		if (!availableContentType) availableContentType = mt;
-	});
+	for (const mt of contentTypes) if (matchesMimeType.json(mt)) {
+		availableContentType = mt;
+		break;
+	}
+	if (!availableContentType) availableContentType = contentTypes[0];
 	if (availableContentType) return [
 		availableContentType,
 		body.content[availableContentType],
@@ -746,11 +783,13 @@ function getResponseBody(responseBody, contentType) {
 * ```
 */
 function getResponseSchema(document, operation, statusCode, options = {}) {
-	if (operation.schema.responses) Object.keys(operation.schema.responses).forEach((key) => {
-		const schema = operation.schema.responses[key];
-		const $ref = isReference(schema) ? schema.$ref : void 0;
-		if (schema && $ref) operation.schema.responses[key] = resolveRef(document, $ref);
-	});
+	if (operation.schema.responses) {
+		const responses = operation.schema.responses;
+		for (const key in responses) {
+			const schema = responses[key];
+			if (schema && isReference(schema)) responses[key] = resolveRef(document, schema.$ref);
+		}
+	}
 	const responseBody = getResponseBody(operation.getResponseByStatusCode(statusCode), options.contentType);
 	if (responseBody === false) return {};
 	const schema = Array.isArray(responseBody) ? responseBody[1].schema : responseBody.schema;
@@ -789,14 +828,24 @@ function getRequestSchema(document, operation, options = {}) {
 * // returned unchanged — contains a $ref
 * ```
 */
+/**
+* Returns `true` when `fragment` carries any JSON Schema keyword that makes it
+* structurally significant on its own (see `structuralKeys`).
+*
+* A fragment with a structural keyword can't be safely merged into a parent schema.
+*/
+function hasStructuralKeywords(fragment) {
+	for (const key in fragment) if (structuralKeys.has(key)) return true;
+	return false;
+}
 function flattenSchema(schema) {
 	if (!schema?.allOf || schema.allOf.length === 0) return schema ?? null;
-	if (schema.allOf.some((item) => isRef(item))) return schema;
-	const isPlainFragment = (item) => !Object.keys(item).some((key) => structuralKeys.has(key));
-	if (!schema.allOf.every((item) => isPlainFragment(item))) return schema;
+	const allOfFragments = schema.allOf;
+	if (allOfFragments.some((item) => isRef(item))) return schema;
+	if (allOfFragments.some(hasStructuralKeywords)) return schema;
 	const merged = { ...schema };
 	delete merged.allOf;
-	for (const fragment of schema.allOf) for (const [key, value] of Object.entries(fragment)) if (merged[key] === void 0) merged[key] = value;
+	for (const fragment of allOfFragments) for (const [key, value] of Object.entries(fragment)) if (merged[key] === void 0) merged[key] = value;
 	return merged;
 }
 /**
@@ -826,10 +875,15 @@ function collectRefs(schema, refs = /* @__PURE__ */ new Set()) {
 		for (const item of schema) collectRefs(item, refs);
 		return refs;
 	}
-	if (schema && typeof schema === "object") for (const [key, value] of Object.entries(schema)) if (key === "$ref" && typeof value === "string") {
-		const match = value.match(/^#\/components\/schemas\/(.+)$/);
-		if (match) refs.add(match[1]);
-	} else collectRefs(value, refs);
+	if (schema && typeof schema === "object") for (const key in schema) {
+		const value = schema[key];
+		if (key === "$ref" && typeof value === "string") {
+			if (value.startsWith("#/components/schemas/")) {
+				const name = value.slice(21);
+				if (name) refs.add(name);
+			}
+		} else collectRefs(value, refs);
+	}
 	return refs;
 }
 /**
@@ -913,13 +967,23 @@ function getSchemas(document, { contentType }) {
 	}
 	const schemas = {};
 	const nameMapping = /* @__PURE__ */ new Map();
-	const multipleSources = (items) => new Set(items.map((i) => i.source)).size > 1;
-	for (const [, items] of normalizedNames) items.forEach((item, index) => {
-		const suffix = items.length === 1 ? "" : multipleSources(items) ? getSemanticSuffix(item.source) : index === 0 ? "" : String(index + 1);
-		const uniqueName = item.originalName + suffix;
-		schemas[uniqueName] = item.schema;
-		nameMapping.set(`#/components/${item.source}/${item.originalName}`, uniqueName);
-	});
+	for (const [, items] of normalizedNames) {
+		const isSingle = items.length === 1;
+		let hasMultipleSources = false;
+		if (!isSingle) {
+			const firstSource = items[0].source;
+			for (let i = 1; i < items.length; i++) if (items[i].source !== firstSource) {
+				hasMultipleSources = true;
+				break;
+			}
+		}
+		items.forEach((item, index) => {
+			const suffix = isSingle ? "" : hasMultipleSources ? getSemanticSuffix(item.source) : index === 0 ? "" : String(index + 1);
+			const uniqueName = item.originalName + suffix;
+			schemas[uniqueName] = item.schema;
+			nameMapping.set(`#/components/${item.source}/${item.originalName}`, uniqueName);
+		});
+	}
 	return {
 		schemas: sortSchemas(schemas),
 		nameMapping
@@ -1066,7 +1130,7 @@ function createSchemaParser(ctx) {
 			if (!deref || !isDiscriminator(deref)) return true;
 			const parentUnion = deref.oneOf ?? deref.anyOf;
 			if (!parentUnion) return true;
-			const childRef = `#/components/schemas/${name}`;
+			const childRef = `${SCHEMA_REF_PREFIX}${name}`;
 			const inOneOf = parentUnion.some((oneOfItem) => isReference(oneOfItem) && oneOfItem.$ref === childRef);
 			const inMapping = Object.values(deref.discriminator.mapping ?? {}).some((v) => v === childRef);
 			if (inOneOf || inMapping) {
@@ -1295,15 +1359,21 @@ function createSchemaParser(ctx) {
 		const extensionKey = enumExtensionKeys.find((key) => key in schema);
 		if (extensionKey || enumPrimitive === "number" || enumPrimitive === "integer" || enumPrimitive === "boolean") {
 			const enumPrimitiveType = enumPrimitive === "number" || enumPrimitive === "integer" ? "number" : enumPrimitive === "boolean" ? "boolean" : "string";
-			const sourceValues = extensionKey ? [...new Set(schema[extensionKey])] : [...new Set(filteredValues)];
+			const rawEnumNames = extensionKey ? schema[extensionKey] : void 0;
+			const uniqueValues = [...new Set(filteredValues)];
+			const seenNames = /* @__PURE__ */ new Set();
 			return ast.createSchema({
 				...enumBase,
 				primitive: enumPrimitiveType,
-				namedEnumValues: sourceValues.map((label, index) => ({
-					name: String(label),
-					value: extensionKey ? filteredValues[index] ?? label : label,
+				namedEnumValues: uniqueValues.map((value, index) => ({
+					name: String(rawEnumNames?.[index] ?? value),
+					value,
 					primitive: enumPrimitiveType
-				}))
+				})).filter((entry) => {
+					if (seenNames.has(entry.name)) return false;
+					seenNames.add(entry.name);
+					return true;
+				})
 			});
 		}
 		return ast.createSchema({
@@ -1555,41 +1625,70 @@ function createSchemaParser(ctx) {
 		});
 	}
 	/**
+	* Reads the inline `requestBody` metadata (description / required / contentType) that OAS exposes
+	* outside the schema itself. Returns an empty object when the request body is missing or a `$ref`.
+	*/
+	function getRequestBodyMeta(operation) {
+		const body = operation.schema.requestBody;
+		if (!body || isReference(body)) return { required: false };
+		const inline = body;
+		return {
+			description: inline.description,
+			required: inline.required === true,
+			contentType: inline.content ? Object.keys(inline.content)[0] : void 0
+		};
+	}
+	/**
+	* Reads the inline response object (not a `$ref`) and returns its description plus its `content` map.
+	*/
+	function getResponseMeta(responseObj) {
+		if (typeof responseObj !== "object" || responseObj === null || Array.isArray(responseObj)) return {};
+		const inline = responseObj;
+		return {
+			description: inline.description,
+			content: inline.content
+		};
+	}
+	/**
+	* Collects property names whose schema has a truthy boolean flag (`readOnly` or `writeOnly`).
+	* `$ref` entries are skipped since their flags live on the dereferenced target.
+	*/
+	function collectPropertyKeysByFlag(schema, flag) {
+		if (!schema?.properties) return void 0;
+		const keys = [];
+		for (const key in schema.properties) {
+			const prop = schema.properties[key];
+			if (prop && !isReference(prop) && prop[flag]) keys.push(key);
+		}
+		return keys.length ? keys : void 0;
+	}
+	/**
 	* Converts an OAS `Operation` into an `OperationNode`.
 	*/
 	function parseOperation(options, operation) {
 		const parameters = getParameters(document, operation).map((param) => parseParameter(options, param));
 		const requestBodySchema = getRequestSchema(document, operation, { contentType: ctx.contentType });
 		const requestBodySchemaNode = requestBodySchema ? parseSchema({ 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 requestBodyRequired = operation.schema.requestBody && !isReference(operation.schema.requestBody) ? operation.schema.requestBody.required === true : false;
-		const requestBodyContentType = (() => {
-			if (!operation.schema.requestBody || isReference(operation.schema.requestBody)) return;
-			const content = operation.schema.requestBody.content;
-			return content ? Object.keys(content)[0] : void 0;
-		})();
+		const requestBodyMeta = getRequestBodyMeta(operation);
 		const requestBody = requestBodySchemaNode ? {
-			description: requestBodyDescription,
-			schema: ast.syncOptionality(requestBodySchemaNode, requestBodyRequired),
-			keysToOmit: requestBodyKeysToOmit?.length ? requestBodyKeysToOmit : void 0,
-			required: requestBodyRequired || void 0,
-			contentType: requestBodyContentType
+			description: requestBodyMeta.description,
+			schema: ast.syncOptionality(requestBodySchemaNode, requestBodyMeta.required),
+			keysToOmit: collectPropertyKeysByFlag(requestBodySchema, "readOnly"),
+			required: requestBodyMeta.required || void 0,
+			contentType: requestBodyMeta.contentType
 		} : void 0;
 		const responses = operation.getResponseStatusCodes().map((statusCode) => {
 			const responseObj = operation.getResponseByStatusCode(statusCode);
 			const responseSchema = getResponseSchema(document, operation, statusCode, { contentType: ctx.contentType });
 			const schema = responseSchema && Object.keys(responseSchema).length > 0 ? parseSchema({ schema: responseSchema }, options) : ast.createSchema({ type: typeOptionMap.get(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 ? getMediaType(Object.keys(rawContent)[0] ?? "") : getMediaType(operation.contentType ?? "");
-			const keysToOmit = responseSchema?.properties ? Object.entries(responseSchema.properties).filter(([, prop]) => !isReference(prop) && prop.writeOnly).map(([key]) => key) : void 0;
+			const { description, content } = getResponseMeta(responseObj);
+			const mediaType = content ? getMediaType(Object.keys(content)[0] ?? "") : getMediaType(operation.contentType ?? "");
 			return ast.createResponse({
 				statusCode,
 				description,
 				schema,
 				mediaType,
-				keysToOmit: keysToOmit?.length ? keysToOmit : void 0
+				keysToOmit: collectPropertyKeysByFlag(responseSchema, "writeOnly")
 			});
 		});
 		const urlPath = new URLPath(operation.path);