@kubb/oas 4.33.2 → 4.33.3

package/dist/index.d.ts

@@ -1,8 +1,8 @@
 import { i as __name } from "./chunk-OuPHjz6n.js";
 import BaseOas from "oas";
-import * as _readme_openapi_parser0 from "@readme/openapi-parser";
 import * as OasTypes from "oas/types";
 import { DiscriminatorObject as DiscriminatorObject$1, HttpMethods as HttpMethods$1, MediaTypeObject as MediaTypeObject$1, OASDocument, ParameterObject, ResponseObject as ResponseObject$1, SchemaObject as SchemaObject$1 } from "oas/types";
+import * as oas_normalize_lib_types0 from "oas-normalize/lib/types";
 import { Operation as Operation$1 } from "oas/operation";
 import { OpenAPIV3, OpenAPIV3 as OpenAPIV3$1, OpenAPIV3_1, OpenAPIV3_1 as OpenAPIV3_1$1 } from "openapi-types";
 import { Config } from "@kubb/core";
@@ -61,7 +61,7 @@ declare class Oas extends BaseOas {
   getResponseSchema(operation: Operation, statusCode: string | number): SchemaObject;
   getRequestSchema(operation: Operation): SchemaObject | undefined;
   getParametersSchema(operation: Operation, inKey: 'path' | 'query' | 'header'): SchemaObject | null;
-  validate(): Promise<_readme_openapi_parser0.ValidationResult>;
+  validate(): Promise<oas_normalize_lib_types0.ValidationResult>;
   flattenSchema(schema: SchemaObject | null): SchemaObject | null;
   /**
    * Get schemas from OpenAPI components (schemas, responses, requestBodies).
@@ -136,6 +136,7 @@ declare function isOptional(schema?: SchemaObject$1): boolean;
 declare function getDefaultValue(schema?: SchemaObject$1): string | undefined;
 declare function parse(pathOrApi: string | Document, {
   oasClass,
+  canBundle,
   enablePaths
 }?: {
   oasClass?: typeof Oas;
@@ -151,7 +152,7 @@ declare function parseFromConfig(config: Config, oasClass?: typeof Oas): Promise
 /**
  * Validate an OpenAPI document using oas-normalize.
  */
-declare function validate(document: Document): Promise<_readme_openapi_parser0.ValidationResult>;
+declare function validate(document: Document): Promise<oas_normalize_lib_types0.ValidationResult>;
 //#endregion
 export { DiscriminatorObject, Document, HttpMethod, HttpMethods, KUBB_INLINE_REF_PREFIX, MediaTypeObject, Oas, type OasTypes, type OpenAPIV3, type OpenAPIV3_1, Operation, ReferenceObject, ResponseObject, SchemaObject, contentType, getDefaultValue, isAllOptional, isDiscriminator, isNullable, isOpenApiV3_1Document, isOptional, isParameterObject, isReference, isRequired, merge, parse, parseFromConfig, resolveServerUrl, validate };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -2,9 +2,8 @@ import { a as __require, n as __esmMin, o as __toCommonJS, r as __exportAll, s a
 import jsonpointer from "jsonpointer";
 import BaseOas from "oas";
 import { matchesMimeType } from "oas/utils";
-import fs from "node:fs";
 import path from "node:path";
-import { bundle } from "@readme/openapi-parser";
+import { bundle, loadConfig } from "@redocly/openapi-core";
 import { isRef } from "oas/types";
 import OASNormalize from "oas-normalize";
 import { isPlainObject, mergeDeep } from "remeda";
@@ -4503,96 +4502,16 @@ function getDefaultValue(schema) {
 	}
 	if (schema.type === "object" || schema.properties) return "{}";
 }
-/**
-* Recursively collect all external local-file $ref prefixes (e.g. "api-definitions.yml")
-* from an object tree. URL refs (http/https) are ignored.
-*/
-function collectExternalFilePaths(obj, files) {
-	if (!obj || typeof obj !== "object") return;
-	if (Array.isArray(obj)) {
-		for (const item of obj) collectExternalFilePaths(item, files);
-		return;
-	}
-	for (const [key, value] of Object.entries(obj)) if (key === "$ref" && typeof value === "string") {
-		const hashIdx = value.indexOf("#");
-		const filePart = hashIdx > 0 ? value.slice(0, hashIdx) : hashIdx === -1 ? value : "";
-		if (filePart && !filePart.startsWith("http://") && !filePart.startsWith("https://")) files.add(filePart);
-	} else collectExternalFilePaths(value, files);
-}
-/**
-* Replace all $refs that start with `externalFile#` with the corresponding
-* internal ref (i.e. just the fragment part, `#/...`).
-*/
-function replaceExternalRefsInPlace(obj, externalFile) {
-	if (!obj || typeof obj !== "object") return;
-	if (Array.isArray(obj)) {
-		for (const item of obj) replaceExternalRefsInPlace(item, externalFile);
-		return;
-	}
-	const record = obj;
-	for (const key of Object.keys(record)) {
-		const value = record[key];
-		if (key === "$ref" && typeof value === "string" && value.startsWith(`${externalFile}#`)) record[key] = value.slice(externalFile.length);
-		else if (value && typeof value === "object") replaceExternalRefsInPlace(value, externalFile);
-	}
-}
-/**
-* Before bundling, scan the main spec file for external local-file references and merge
-* their `components` sections into the main document. This ensures that schemas defined
-* in external files (e.g. `api-definitions.yml#/components/schemas/Parcel`) end up in
-* `#/components/schemas/Parcel` of the bundled output, rather than being inlined as
-* anonymous path-based refs.
-*
-* Returns the merged document, or `null` if no external file components were found.
-*/
-function mergeExternalFileComponents(mainFilePath) {
-	let mainContent;
-	try {
-		mainContent = fs.readFileSync(mainFilePath, "utf-8");
-	} catch {
-		return null;
-	}
-	const mainDoc = import_yaml.parse(mainContent);
-	if (!mainDoc || typeof mainDoc !== "object") return null;
-	const mainDir = path.dirname(mainFilePath);
-	const externalFiles = /* @__PURE__ */ new Set();
-	collectExternalFilePaths(mainDoc, externalFiles);
-	if (externalFiles.size === 0) return null;
-	let hasMergedComponents = false;
-	for (const externalFile of externalFiles) {
-		const externalFilePath = path.resolve(mainDir, externalFile);
-		let externalContent;
-		try {
-			externalContent = fs.readFileSync(externalFilePath, "utf-8");
-		} catch {
-			continue;
-		}
-		const externalDoc = import_yaml.parse(externalContent);
-		if (!externalDoc?.components || typeof externalDoc.components !== "object") continue;
-		const mainComponents = mainDoc.components ?? {};
-		mainDoc.components = mainComponents;
-		for (const [componentType, components] of Object.entries(externalDoc.components)) {
-			if (!components || typeof components !== "object") continue;
-			mainComponents[componentType] = {
-				...components,
-				...mainComponents[componentType] ?? {}
-			};
-			hasMergedComponents = true;
-		}
-	}
-	if (!hasMergedComponents) return null;
-	for (const externalFile of externalFiles) replaceExternalRefsInPlace(mainDoc, externalFile);
-	return mainDoc;
-}
-async function parse(pathOrApi, { oasClass = Oas, enablePaths = true } = {}) {
-	if (typeof pathOrApi === "string" && !pathOrApi.match(/\n/) && !pathOrApi.match(/^\s*\{/) && enablePaths) try {
-		return parse(await bundle(mergeExternalFileComponents(pathOrApi) ?? pathOrApi), {
-			oasClass,
-			enablePaths
-		});
-	} catch (e) {
-		console.warn(`[kubb] Failed to bundle external $refs in "${pathOrApi}": ${e.message}. Falling back to plain load.`);
-	}
+async function parse(pathOrApi, { oasClass = Oas, canBundle = true, enablePaths = true } = {}) {
+	if (typeof pathOrApi === "string" && canBundle) return parse((await bundle({
+		ref: pathOrApi,
+		config: await loadConfig(),
+		base: pathOrApi
+	})).bundle.parsed, {
+		oasClass,
+		canBundle,
+		enablePaths
+	});
 	const document = await new OASNormalize(pathOrApi, {
 		enablePaths,
 		colorizeErrors: true
@@ -4606,7 +4525,8 @@ async function parse(pathOrApi, { oasClass = Oas, enablePaths = true } = {}) {
 async function merge(pathOrApi, { oasClass = Oas } = {}) {
 	const instances = await Promise.all(pathOrApi.map((p) => parse(p, {
 		oasClass,
-		enablePaths: false
+		enablePaths: false,
+		canBundle: false
 	})));
 	if (instances.length === 0) throw new Error("No OAS instances provided for merging.");
 	return parse(instances.reduce((acc, current) => {
@@ -4991,9 +4911,14 @@ var Oas = class extends BaseOas {
 	}
 	getParametersSchema(operation, inKey) {
 		const { contentType = operation.getContentType() } = this.#options;
-		const params = operation.getParameters().map((schema) => {
-			return this.dereferenceWithRef(schema);
-		}).filter((v) => v.in === inKey);
+		const resolveParams = (params) => params.map((p) => this.dereferenceWithRef(p)).filter((p) => !!p && typeof p === "object" && "in" in p && "name" in p);
+		const operationParams = resolveParams(operation.schema?.parameters || []);
+		const pathItem = this.api?.paths?.[operation.path];
+		const pathLevelParams = resolveParams(pathItem && !isReference(pathItem) && pathItem.parameters ? pathItem.parameters : []);
+		const paramMap = /* @__PURE__ */ new Map();
+		for (const p of pathLevelParams) if (p.name && p.in) paramMap.set(`${p.in}:${p.name}`, p);
+		for (const p of operationParams) if (p.name && p.in) paramMap.set(`${p.in}:${p.name}`, p);
+		const params = Array.from(paramMap.values()).filter((v) => v.in === inKey);
 		if (!params.length) return null;
 		return params.reduce((schema, pathParameters) => {
 			const property = pathParameters.content?.[contentType]?.schema ?? pathParameters.schema;