@kubb/adapter-oas 5.12.6 → 5.12.8

package/dist/index.cjs

@@ -36,7 +36,7 @@ var compatibility = {
 };
 //#endregion
 //#region package.json
-var version = "5.12.6";
+var version = "5.12.8";
 //#endregion
 //#region src/constants.ts
 /**
@@ -121,24 +121,35 @@ const numericFormats = /* @__PURE__ */ new Set([
 /**
 * Static map from OAS `format` strings to Kubb `SchemaType` values.
 *
-* Only formats whose AST type differs from the OAS `type` field appear here.
+* Lists formats whose AST type differs from the OAS `type` field, plus string formats that
+* `KUBB_UNSUPPORTED_FORMAT` should not flag.
 * Formats that depend on runtime options (`int64`, `date-time`, `date`, `time`) are handled
-* separately in the parser. `ipv4` and `ipv6` map to their own dedicated schema types. `hostname`
-* and `idn-hostname` map to `'url'` as the closest generic string-format type.
+* separately in the parser. `ipv4` and `ipv6` map to their own dedicated schema types.
+* `uri-reference`, `iri`, `iri-reference`, `hostname` and `idn-hostname` map to `'string'`: a relative
+* reference, a Unicode IRI or a bare host name is not a URL, so a `'url'` validator would reject valid
+* values. `base64url`, `jwt`, `ulid`, `iban` and `duration` map to `'string'` because plugins check
+* them by `format`.
 */
 const formatMap = {
 	uuid: "uuid",
 	email: "email",
 	"idn-email": "email",
 	uri: "url",
-	"uri-reference": "url",
+	"uri-reference": "string",
+	iri: "string",
+	"iri-reference": "string",
 	url: "url",
 	ipv4: "ipv4",
 	ipv6: "ipv6",
-	hostname: "url",
-	"idn-hostname": "url",
+	hostname: "string",
+	"idn-hostname": "string",
 	binary: "blob",
 	byte: "blob",
+	base64url: "string",
+	jwt: "string",
+	ulid: "string",
+	iban: "string",
+	duration: "string",
 	int32: "integer",
 	float: "number",
 	double: "number"
@@ -730,23 +741,73 @@ function extractSchemaFromContent(content, preferredContentType) {
 /**
 * Walks a schema tree and collects the names of all `#/components/schemas/<name>` `$ref`s.
 */
-function* collectRefs(schema) {
+function* collectRefs(schema, renames) {
 	if (Array.isArray(schema)) {
-		for (const item of schema) yield* collectRefs(item);
+		for (const item of schema) yield* collectRefs(item, renames);
 		return;
 	}
 	if (schema && typeof schema === "object") for (const key in schema) {
 		const value = schema[key];
 		if (!(key === "$ref" && typeof value === "string")) {
-			yield* collectRefs(value);
+			yield* collectRefs(value, renames);
 			continue;
 		}
 		if (value.startsWith("#/components/schemas/")) {
-			const name = value.slice(21);
+			const name = renames.get(value) ?? value.slice(21);
 			if (name) yield name;
 		}
 	}
 }
+const schemaChildKeywords = [
+	"additionalProperties",
+	"allOf",
+	"anyOf",
+	"contains",
+	"contentSchema",
+	"else",
+	"if",
+	"items",
+	"not",
+	"oneOf",
+	"patternProperties",
+	"prefixItems",
+	"properties",
+	"propertyNames",
+	"then"
+];
+/** Collects definitions only from schema locations, never from examples/defaults or arbitrary data. */
+function* collectNestedDefinitions(schema, pointer, name) {
+	if (!schema || typeof schema !== "object" || Array.isArray(schema)) return;
+	const value = schema;
+	for (const keyword of ["$defs", "definitions"]) {
+		const definitions = value[keyword];
+		if (!definitions || typeof definitions !== "object" || Array.isArray(definitions)) continue;
+		for (const [key, definition] of Object.entries(definitions)) {
+			if (!definition || typeof definition !== "object" || Array.isArray(definition)) continue;
+			const definitionPointer = `${pointer}/${keyword}/${escapePointerToken(key)}`;
+			const nestedName = `${name}_${key}`;
+			yield {
+				schema: definition,
+				pointer: definitionPointer,
+				originalName: nestedName
+			};
+			yield* collectNestedDefinitions(definition, definitionPointer, nestedName);
+		}
+	}
+	for (const keyword of schemaChildKeywords) {
+		const child = value[keyword];
+		if (!child || typeof child !== "object") continue;
+		if (Array.isArray(child)) {
+			for (const [index, item] of child.entries()) yield* collectNestedDefinitions(item, `${pointer}/${keyword}/${index}`, name);
+			continue;
+		}
+		if (keyword === "properties" || keyword === "patternProperties") {
+			for (const [key, item] of Object.entries(child)) yield* collectNestedDefinitions(item, `${pointer}/${keyword}/${escapePointerToken(key)}`, name);
+			continue;
+		}
+		yield* collectNestedDefinitions(child, `${pointer}/${keyword}`, name);
+	}
+}
 /**
 * Returns a copy of `schemas` topologically sorted by `$ref` dependency.
 *
@@ -759,9 +820,9 @@ function* collectRefs(schema) {
 * // Pet appears before Order when Order.$ref points at Pet
 * ```
 */
-function sortSchemas(schemas) {
+function sortSchemas(schemas, renames) {
 	const deps = /* @__PURE__ */ new Map();
-	for (const [name, schema] of Object.entries(schemas)) deps.set(name, [...new Set(collectRefs(schema))]);
+	for (const [name, schema] of Object.entries(schemas)) deps.set(name, [...new Set(collectRefs(schema, renames))]);
 	const sorted = [];
 	const visited = /* @__PURE__ */ new Set();
 	function visit(name, stack) {
@@ -804,16 +865,25 @@ function getSchemas(document, { contentType }, refs) {
 		const resolved = refs.resolve(schema.$ref);
 		return resolved && !isReference(resolved) ? resolved : schema;
 	}
-	const candidates = [...Object.entries(components?.schemas ?? {}).map(([name, schema]) => ({
-		schema: resolveSchemaRef(schema),
-		source: "schemas",
-		originalName: name
-	})), ...["responses", "requestBodies"].flatMap((source) => Object.entries(components?.[source] ?? {}).flatMap(([name, item]) => {
+	const candidates = [...Object.entries(components?.schemas ?? {}).flatMap(([name, schema]) => {
+		const pointer = `#/components/schemas/${escapePointerToken(name)}`;
+		return [{
+			schema: resolveSchemaRef(schema),
+			source: "schemas",
+			originalName: name,
+			pointer
+		}, ...[...collectNestedDefinitions(schema, pointer, name)].map((nested) => ({
+			...nested,
+			source: "schemas",
+			nested: true
+		}))];
+	}), ...["responses", "requestBodies"].flatMap((source) => Object.entries(components?.[source] ?? {}).flatMap(([name, item]) => {
 		const schema = extractSchemaFromContent(item.content, contentType);
 		return schema ? [{
 			schema: resolveSchemaRef(schema),
 			source,
-			originalName: name
+			originalName: name,
+			pointer: `#/components/${source}/${escapePointerToken(name)}`
 		}] : [];
 	}))];
 	const normalizedNames = /* @__PURE__ */ new Map();
@@ -832,11 +902,11 @@ function getSchemas(document, { contentType }, refs) {
 			const suffix = isSingle ? "" : hasMultipleSources ? semanticSuffixes[item.source] : index ? String(index + 1) : "";
 			const uniqueName = item.originalName + suffix;
 			schemas[uniqueName] = item.schema;
-			if (suffix) renames.set(`#/components/${item.source}/${item.originalName}`, uniqueName);
+			if (suffix || item.nested) renames.set(item.pointer, uniqueName);
 		});
 	}
 	return {
-		schemas: sortSchemas(schemas),
+		schemas: sortSchemas(schemas, renames),
 		renames
 	};
 }
@@ -997,8 +1067,10 @@ function collectPropertyKeysByFlag(schema, flag) {
 }
 function parseParameter({ param, parentName, options, parseSchema }) {
 	const schemaName = parentName && param.name ? pascalCase(`${parentName} ${param.name}`) : void 0;
-	const schema = param.schema ? parseSchema({
-		schema: param.schema,
+	const contentType = param.schema ? void 0 : Object.keys(param.content ?? {})[0];
+	const rawSchema = param.schema ?? (contentType ? param.content?.[contentType]?.schema : void 0);
+	const schema = rawSchema ? parseSchema({
+		schema: rawSchema,
 		name: schemaName
 	}) : _kubb_kit.ast.factory.createSchema({ type: options.unknownType });
 	const style = param.style;
@@ -1014,7 +1086,8 @@ function parseParameter({ param, parentName, options, parseSchema }) {
 		required: param.required ?? false,
 		...style !== void 0 ? { style } : {},
 		...explode !== void 0 ? { explode } : {},
-		...allowReserved !== void 0 ? { allowReserved } : {}
+		...allowReserved !== void 0 ? { allowReserved } : {},
+		...contentType !== void 0 ? { contentType } : {}
 	});
 }
 /**
@@ -1768,6 +1841,10 @@ function convertFormat(context) {
 		});
 	}
 	const specialType = formatMap[schema.format];
+	if (specialType === "string") {
+		if (type === "integer" || type === "number") return convertNumeric(context, type);
+		return convertString(context);
+	}
 	const isNumeric = specialType === "number" || specialType === "integer";
 	return createNode(context, {
 		primitive: isNumeric ? specialType : "string",