@kubb/oas 4.18.4 → 4.19.0

package/dist/index.cjs

@@ -52,6 +52,7 @@ let oas = require("oas");
 oas = __toESM(oas);
 let node_path = require("node:path");
 node_path = __toESM(node_path);
+let _kubb_core_transformers = require("@kubb/core/transformers");
 let _kubb_core_utils = require("@kubb/core/utils");
 let oas_types = require("oas/types");
 let oas_normalize = require("oas-normalize");
@@ -4370,26 +4371,25 @@ function isParameterObject(obj) {
 	return obj && "in" in obj;
 }
 /**
-* Determines if a schema is nullable, considering both the standard `nullable` property and the legacy `x-nullable` extension.
-*
-* @param schema - The schema object to check.
-* @returns `true` if the schema is marked as nullable; otherwise, `false`.
+* Determines if a schema is nullable, considering:
+* - OpenAPI 3.0 `nullable` / `x-nullable`
+* - OpenAPI 3.1 JSON Schema `type: ['null', ...]` or `type: 'null'`
 */
 function isNullable(schema) {
-	return schema?.nullable ?? schema?.["x-nullable"] ?? false;
+	if ((schema?.nullable ?? schema?.["x-nullable"]) === true) return true;
+	const schemaType = schema?.type;
+	if (schemaType === "null") return true;
+	if (Array.isArray(schemaType)) return schemaType.includes("null");
+	return false;
 }
 /**
 * Determines if the given object is an OpenAPI ReferenceObject.
-*
-* @returns True if {@link obj} is a ReferenceObject; otherwise, false.
 */
 function isReference(obj) {
 	return !!obj && (0, oas_types.isRef)(obj);
 }
 /**
 * Determines if the given object is a SchemaObject with a discriminator property of type DiscriminatorObject.
-*
-* @returns True if {@link obj} is a SchemaObject containing a non-string {@link discriminator} property.
 */
 function isDiscriminator(obj) {
 	return !!obj && obj?.["discriminator"] && typeof obj.discriminator !== "string";
@@ -4398,9 +4398,6 @@ function isDiscriminator(obj) {
 * Determines whether a schema is required.
 *
 * Returns true if the schema has a non-empty {@link SchemaObject.required} array or a truthy {@link SchemaObject.required} property.
-*
-* @param schema - The schema object to check.
-* @returns True if the schema is required; otherwise, false.
 */
 function isRequired(schema) {
 	if (!schema) return false;
@@ -4496,6 +4493,149 @@ function parseFromConfig(config, oasClass = Oas) {
 	if (new _kubb_core_utils.URLPath(config.input.path).isURL) return parse(config.input.path, { oasClass });
 	return parse(node_path.default.resolve(config.root, config.input.path), { oasClass });
 }
+/**
+* Flatten allOf schemas by merging keyword-only fragments.
+* Only flattens schemas where allOf items don't contain structural keys or $refs.
+*/
+function flattenSchema(schema) {
+	if (!schema?.allOf || schema.allOf.length === 0) return schema || null;
+	if (schema.allOf.some((item) => (0, oas_types.isRef)(item))) return schema;
+	const isPlainFragment = (item) => !Object.keys(item).some((key) => STRUCTURAL_KEYS.has(key));
+	if (!schema.allOf.every((item) => isPlainFragment(item))) 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;
+	return merged;
+}
+/**
+* Validate an OpenAPI document using oas-normalize.
+*/
+async function validate(document) {
+	return new oas_normalize.default(document, {
+		enablePaths: true,
+		colorizeErrors: true
+	}).validate({ parser: { validate: { errors: { colorize: true } } } });
+}
+/**
+* Collect all schema $ref dependencies recursively.
+*/
+function collectRefs(schema, refs = /* @__PURE__ */ new Set()) {
+	if (Array.isArray(schema)) {
+		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);
+	return refs;
+}
+/**
+* Sort schemas topologically so referenced schemas appear first.
+*/
+function sortSchemas(schemas) {
+	const deps = /* @__PURE__ */ new Map();
+	for (const [name, schema] of Object.entries(schemas)) deps.set(name, Array.from(collectRefs(schema)));
+	const sorted = [];
+	const visited = /* @__PURE__ */ new Set();
+	function visit(name, stack = /* @__PURE__ */ new Set()) {
+		if (visited.has(name)) return;
+		if (stack.has(name)) return;
+		stack.add(name);
+		const children = deps.get(name) || [];
+		for (const child of children) if (deps.has(child)) visit(child, stack);
+		stack.delete(name);
+		visited.add(name);
+		sorted.push(name);
+	}
+	for (const name of Object.keys(schemas)) visit(name);
+	const sortedSchemas = {};
+	for (const name of sorted) sortedSchemas[name] = schemas[name];
+	return sortedSchemas;
+}
+/**
+* Extract schema from content object (used by responses and requestBodies).
+* Returns null if the schema is just a $ref (not a unique type definition).
+*/
+function extractSchemaFromContent(content, preferredContentType) {
+	if (!content) return null;
+	const firstContentType = Object.keys(content)[0] || "application/json";
+	const schema = content[preferredContentType || firstContentType]?.schema;
+	if (schema && "$ref" in schema) return null;
+	return schema || null;
+}
+/**
+* Get semantic suffix for a schema source.
+*/
+function getSemanticSuffix(source) {
+	switch (source) {
+		case "schemas": return "Schema";
+		case "responses": return "Response";
+		case "requestBodies": return "Request";
+	}
+}
+/**
+* Legacy resolution strategy - no collision detection, just use original names.
+* This preserves backward compatibility when collisionDetection is false.
+* @deprecated
+*/
+function legacyResolve(schemasWithMeta) {
+	const schemas = {};
+	const nameMapping = /* @__PURE__ */ new Map();
+	for (const item of schemasWithMeta) {
+		schemas[item.originalName] = item.schema;
+		const refPath = `#/components/${item.source}/${item.originalName}`;
+		nameMapping.set(refPath, item.originalName);
+	}
+	return {
+		schemas,
+		nameMapping
+	};
+}
+/**
+* Resolve name collisions by applying suffixes based on collision type.
+*
+* Strategy:
+* - Same-component collisions (e.g., "Variant" + "variant" both in schemas): numeric suffixes (Variant, Variant2)
+* - Cross-component collisions (e.g., "Pet" in schemas + "Pet" in requestBodies): semantic suffixes (PetSchema, PetRequest)
+*/
+function resolveCollisions(schemasWithMeta) {
+	const schemas = {};
+	const nameMapping = /* @__PURE__ */ new Map();
+	const normalizedNames = /* @__PURE__ */ new Map();
+	for (const item of schemasWithMeta) {
+		const normalized = (0, _kubb_core_transformers.pascalCase)(item.originalName);
+		if (!normalizedNames.has(normalized)) normalizedNames.set(normalized, []);
+		normalizedNames.get(normalized).push(item);
+	}
+	for (const [, items] of normalizedNames) {
+		if (items.length === 1) {
+			const item = items[0];
+			schemas[item.originalName] = item.schema;
+			const refPath = `#/components/${item.source}/${item.originalName}`;
+			nameMapping.set(refPath, item.originalName);
+			continue;
+		}
+		if (new Set(items.map((item) => item.source)).size === 1) items.forEach((item, index) => {
+			const suffix = index === 0 ? "" : (index + 1).toString();
+			const uniqueName = item.originalName + suffix;
+			schemas[uniqueName] = item.schema;
+			const refPath = `#/components/${item.source}/${item.originalName}`;
+			nameMapping.set(refPath, uniqueName);
+		});
+		else items.forEach((item) => {
+			const suffix = getSemanticSuffix(item.source);
+			const uniqueName = item.originalName + suffix;
+			schemas[uniqueName] = item.schema;
+			const refPath = `#/components/${item.source}/${item.originalName}`;
+			nameMapping.set(refPath, uniqueName);
+		});
+	}
+	return {
+		schemas,
+		nameMapping
+	};
+}
 
 //#endregion
 //#region src/Oas.ts
@@ -4664,17 +4804,17 @@ var Oas = class extends oas.default {
 				if (!(contentType in responseBody.content)) return false;
 				return responseBody.content[contentType];
 			}
-			let availablecontentType;
+			let availableContentType;
 			const contentTypes = Object.keys(responseBody.content);
 			contentTypes.forEach((mt) => {
-				if (!availablecontentType && oas_utils.matchesMimeType.json(mt)) availablecontentType = mt;
+				if (!availableContentType && oas_utils.matchesMimeType.json(mt)) availableContentType = mt;
 			});
-			if (!availablecontentType) contentTypes.forEach((mt) => {
-				if (!availablecontentType) availablecontentType = mt;
+			if (!availableContentType) contentTypes.forEach((mt) => {
+				if (!availableContentType) availableContentType = mt;
 			});
-			if (availablecontentType) return [
-				availablecontentType,
-				responseBody.content[availablecontentType],
+			if (availableContentType) return [
+				availableContentType,
+				responseBody.content[availableContentType],
 				...responseBody.description ? [responseBody.description] : []
 			];
 			return false;
@@ -4746,21 +4886,61 @@ var Oas = class extends oas.default {
 			properties: {}
 		});
 	}
-	async valdiate() {
-		return new (await (import("oas-normalize").then((m) => m.default)))(this.api, {
-			enablePaths: true,
-			colorizeErrors: true
-		}).validate({ parser: { validate: { errors: { colorize: true } } } });
+	async validate() {
+		return validate(this.api);
 	}
 	flattenSchema(schema) {
-		if (!schema?.allOf || schema.allOf.length === 0) return schema || null;
-		if (schema.allOf.some((item) => isReference(item))) return schema;
-		const isPlainFragment = (item) => !Object.keys(item).some((key) => STRUCTURAL_KEYS.has(key));
-		if (!schema.allOf.every((item) => isPlainFragment(item))) 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;
-		return merged;
+		return flattenSchema(schema);
+	}
+	/**
+	* Get schemas from OpenAPI components (schemas, responses, requestBodies).
+	* Returns schemas in dependency order along with name mapping for collision resolution.
+	*/
+	getSchemas(options = {}) {
+		const contentType = options.contentType ?? this.#options.contentType;
+		const includes = options.includes ?? [
+			"schemas",
+			"requestBodies",
+			"responses"
+		];
+		const shouldResolveCollisions = options.collisionDetection ?? this.#options.collisionDetection ?? false;
+		const components = this.getDefinition().components;
+		const schemasWithMeta = [];
+		if (includes.includes("schemas")) {
+			const componentSchemas = components?.schemas || {};
+			for (const [name, schema] of Object.entries(componentSchemas)) schemasWithMeta.push({
+				schema,
+				source: "schemas",
+				originalName: name
+			});
+		}
+		if (includes.includes("responses")) {
+			const responses = components?.responses || {};
+			for (const [name, response] of Object.entries(responses)) {
+				const schema = extractSchemaFromContent(response.content, contentType);
+				if (schema) schemasWithMeta.push({
+					schema,
+					source: "responses",
+					originalName: name
+				});
+			}
+		}
+		if (includes.includes("requestBodies")) {
+			const requestBodies = components?.requestBodies || {};
+			for (const [name, request] of Object.entries(requestBodies)) {
+				const schema = extractSchemaFromContent(request.content, contentType);
+				if (schema) schemasWithMeta.push({
+					schema,
+					source: "requestBodies",
+					originalName: name
+				});
+			}
+		}
+		const { schemas, nameMapping } = shouldResolveCollisions ? resolveCollisions(schemasWithMeta) : legacyResolve(schemasWithMeta);
+		return {
+			schemas: sortSchemas(schemas),
+			nameMapping
+		};
 	}
 };
 
@@ -4804,4 +4984,5 @@ Object.defineProperty(exports, 'matchesMimeType', {
 exports.merge = merge;
 exports.parse = parse;
 exports.parseFromConfig = parseFromConfig;
+exports.validate = validate;
 //# sourceMappingURL=index.cjs.map