@kubb/adapter-oas 5.0.0-alpha.16 → 5.0.0-alpha.17

package/dist/index.cjs

@@ -2,10 +2,6 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 //#region \0rolldown/runtime.js
 var __create = Object.create;
 var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", {
-	value,
-	configurable: true
-});
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
@@ -914,91 +910,6 @@ function resolveCollisions(schemasWithMeta) {
 	};
 }
 //#endregion
-//#region src/discriminator.ts
-function resolveDiscriminatorValue(mapping, ref) {
-	if (!mapping || !ref) return void 0;
-	return Object.entries(mapping).find(([, value]) => value === ref)?.[0];
-}
-function createDiscriminantNode(propertyName, value) {
-	return (0, _kubb_ast.createSchema)({
-		type: "object",
-		primitive: "object",
-		properties: [(0, _kubb_ast.createProperty)({
-			name: propertyName,
-			schema: (0, _kubb_ast.createSchema)({
-				type: "enum",
-				primitive: "string",
-				enumValues: [value]
-			}),
-			required: true
-		})]
-	});
-}
-//#endregion
-//#region src/naming.ts
-function resolveChildName(parentName, propName) {
-	return parentName ? pascalCase([parentName, propName].join(" ")) : void 0;
-}
-function resolveEnumPropName(parentName, propName, enumSuffix) {
-	return pascalCase([
-		parentName,
-		propName,
-		enumSuffix
-	].filter(Boolean).join(" "));
-}
-function applyEnumName(propNode, parentName, propName, enumSuffix) {
-	const enumNode = (0, _kubb_ast.narrowSchema)(propNode, "enum");
-	if (enumNode?.primitive === "boolean") return {
-		...propNode,
-		name: void 0
-	};
-	if (enumNode) return {
-		...propNode,
-		name: resolveEnumPropName(parentName, propName, enumSuffix)
-	};
-	return propNode;
-}
-//#endregion
-//#region src/refResolver.ts
-/**
-* Collects import entries for all `ref` schema nodes in `node`.
-*/
-function getImports({ node, nameMapping, resolve }) {
-	return (0, _kubb_ast.collect)(node, { schema(schemaNode) {
-		if (schemaNode.type !== "ref" || !schemaNode.ref) return;
-		const rawName = (0, _kubb_ast.extractRefName)(schemaNode.ref);
-		const result = resolve(nameMapping.get(rawName) ?? rawName);
-		if (!result) return;
-		return {
-			name: [result.name],
-			path: result.path
-		};
-	} });
-}
-/**
-* Walks a schema tree and resolves `ref`/`enum` names through callbacks.
-*/
-function resolveRefs({ node, nameMapping, resolveName, resolveEnumName }) {
-	return (0, _kubb_ast.transform)(node, { schema(schemaNode) {
-		const schemaRef = (0, _kubb_ast.narrowSchema)(schemaNode, _kubb_ast.schemaTypes.ref);
-		if (schemaRef && (schemaRef.ref || schemaRef.name)) {
-			const rawRef = schemaRef.ref ?? schemaRef.name;
-			const resolved = resolveName(nameMapping.get(rawRef) ?? rawRef);
-			if (resolved) return {
-				...schemaNode,
-				name: resolved
-			};
-		}
-		if (schemaNode.type === "enum" && schemaNode.name) {
-			const resolved = (resolveEnumName ?? resolveName)(schemaNode.name);
-			if (resolved) return {
-				...schemaNode,
-				name: resolved
-			};
-		}
-	} });
-}
-//#endregion
 //#region src/parser.ts
 /**
 * Looks up the Kubb `SchemaType` for a given OAS `format` string.
@@ -1188,7 +1099,7 @@ function createOasParser(oas, { contentType } = {}) {
 			const inOneOf = parentUnion.some((oneOfItem) => isReference(oneOfItem) && oneOfItem.$ref === childRef);
 			const inMapping = Object.values(deref.discriminator.mapping ?? {}).some((v) => v === childRef);
 			if (inOneOf || inMapping) {
-				const discriminatorValue = resolveDiscriminatorValue(deref.discriminator.mapping, childRef);
+				const discriminatorValue = (0, _kubb_ast.findDiscriminator)(deref.discriminator.mapping, childRef);
 				if (discriminatorValue) filteredDiscriminantValues.push({
 					propertyName: deref.discriminator.propertyName,
 					value: discriminatorValue
@@ -1220,10 +1131,13 @@ function createOasParser(oas, { contentType } = {}) {
 			const { allOf: _allOf, ...schemaWithoutAllOf } = schema;
 			allOfMembers.push(convertSchema({ schema: schemaWithoutAllOf }, rawOptions));
 		}
-		for (const { propertyName, value } of filteredDiscriminantValues) allOfMembers.push(createDiscriminantNode(propertyName, value));
+		for (const { propertyName, value } of filteredDiscriminantValues) allOfMembers.push((0, _kubb_ast.createDiscriminantNode)({
+			propertyName,
+			value
+		}));
 		return (0, _kubb_ast.createSchema)({
 			type: "intersection",
-			members: [...(0, _kubb_ast.mergeAdjacentAnonymousObjects)(allOfMembers.slice(0, syntheticStart)), ...(0, _kubb_ast.mergeAdjacentAnonymousObjects)(allOfMembers.slice(syntheticStart))],
+			members: [...(0, _kubb_ast.mergeAdjacentObjects)(allOfMembers.slice(0, syntheticStart)), ...(0, _kubb_ast.mergeAdjacentObjects)(allOfMembers.slice(syntheticStart))],
 			...renderSchemaBase(schema, name, nullable, defaultValue)
 		});
 	}
@@ -1236,6 +1150,15 @@ function createOasParser(oas, { contentType } = {}) {
 	* adding common fields next to a discriminated union.
 	*/
 	function convertUnion({ schema, name, nullable, defaultValue, rawOptions }) {
+		function pickDiscriminatorPropertyNode(node, propertyName) {
+			const discriminatorProperty = (0, _kubb_ast.narrowSchema)(node, "object")?.properties?.find((property) => property.name === propertyName);
+			if (!discriminatorProperty) return;
+			return (0, _kubb_ast.createSchema)({
+				type: "object",
+				primitive: "object",
+				properties: [discriminatorProperty]
+			});
+		}
 		const unionMembers = [...schema.oneOf ?? [], ...schema.anyOf ?? []];
 		const unionBase = {
 			...renderSchemaBase(schema, name, nullable, defaultValue),
@@ -1249,32 +1172,40 @@ function createOasParser(oas, { contentType } = {}) {
 				name
 			}, rawOptions);
 		})() : void 0;
-		if (sharedPropertiesNode || discriminator?.mapping) return (0, _kubb_ast.createSchema)({
-			type: "union",
-			...unionBase,
-			members: unionMembers.map((s) => {
+		if (sharedPropertiesNode || discriminator?.mapping) {
+			const members = unionMembers.map((s) => {
 				const ref = isReference(s) ? s.$ref : void 0;
-				const discriminatorValue = resolveDiscriminatorValue(discriminator?.mapping, ref);
+				const discriminatorValue = (0, _kubb_ast.findDiscriminator)(discriminator?.mapping, ref);
 				const memberNode = convertSchema({ schema: s }, rawOptions);
-				if (sharedPropertiesNode) return (0, _kubb_ast.createSchema)({
+				if (!discriminatorValue || !discriminator) return memberNode;
+				return (0, _kubb_ast.createSchema)({
 					type: "intersection",
-					members: [memberNode, discriminatorValue && discriminator ? (0, _kubb_ast.applyDiscriminatorEnum)({
+					members: [memberNode, (sharedPropertiesNode ? pickDiscriminatorPropertyNode((0, _kubb_ast.setDiscriminatorEnum)({
 						node: sharedPropertiesNode,
 						propertyName: discriminator.propertyName,
 						values: [discriminatorValue]
-					}) : sharedPropertiesNode]
-				});
-				if (!discriminatorValue || !discriminator) return memberNode;
-				return (0, _kubb_ast.createSchema)({
-					type: "intersection",
-					members: [memberNode, createDiscriminantNode(discriminator.propertyName, discriminatorValue)]
+					}), discriminator.propertyName) : void 0) ?? (0, _kubb_ast.createDiscriminantNode)({
+						propertyName: discriminator.propertyName,
+						value: discriminatorValue
+					})]
 				});
-			})
-		});
+			});
+			const unionNode = (0, _kubb_ast.createSchema)({
+				type: "union",
+				...unionBase,
+				members
+			});
+			if (!sharedPropertiesNode) return unionNode;
+			return (0, _kubb_ast.createSchema)({
+				type: "intersection",
+				...renderSchemaBase(schema, name, nullable, defaultValue),
+				members: [unionNode, sharedPropertiesNode]
+			});
+		}
 		return (0, _kubb_ast.createSchema)({
 			type: "union",
 			...unionBase,
-			members: (0, _kubb_ast.simplifyUnionMembers)(unionMembers.map((s) => convertSchema({ schema: s }, rawOptions)))
+			members: (0, _kubb_ast.simplifyUnion)(unionMembers.map((s) => convertSchema({ schema: s }, rawOptions)))
 		});
 	}
 	/**
@@ -1386,15 +1317,15 @@ function createOasParser(oas, { contentType } = {}) {
 		};
 		const extensionKey = enumExtensionKeys.find((key) => key in schema);
 		if (extensionKey || enumPrimitive === "number" || enumPrimitive === "integer" || enumPrimitive === "boolean") {
-			const enumType = enumPrimitive === "number" || enumPrimitive === "integer" ? "number" : enumPrimitive === "boolean" ? "boolean" : "string";
+			const enumPrimitiveType = enumPrimitive === "number" || enumPrimitive === "integer" ? "number" : enumPrimitive === "boolean" ? "boolean" : "string";
 			const sourceValues = extensionKey ? [...new Set(schema[extensionKey])] : [...new Set(filteredValues)];
 			return (0, _kubb_ast.createSchema)({
 				...enumBase,
-				enumType,
+				primitive: enumPrimitiveType,
 				namedEnumValues: sourceValues.map((label, index) => ({
 					name: String(label),
 					value: extensionKey ? filteredValues[index] ?? label : label,
-					format: enumType
+					primitive: enumPrimitiveType
 				}))
 			});
 		}
@@ -1420,13 +1351,13 @@ function createOasParser(oas, { contentType } = {}) {
 			const required = Array.isArray(schema.required) ? schema.required.includes(propName) : !!schema.required;
 			const resolvedPropSchema = propSchema;
 			const propNullable = isNullable(resolvedPropSchema);
-			let schemaNode = applyEnumName(convertSchema({
+			let schemaNode = (0, _kubb_ast.setEnumName)(convertSchema({
 				schema: resolvedPropSchema,
-				name: resolveChildName(name, propName)
+				name: (0, _kubb_ast.childName)(name, propName)
 			}, rawOptions), name, propName, options.enumSuffix);
 			const tupleNode = (0, _kubb_ast.narrowSchema)(schemaNode, "tuple");
 			if (tupleNode?.items) {
-				const namedItems = tupleNode.items.map((item) => applyEnumName(item, name, propName, options.enumSuffix));
+				const namedItems = tupleNode.items.map((item) => (0, _kubb_ast.setEnumName)(item, name, propName, options.enumSuffix));
 				if (namedItems.some((item, i) => item !== tupleNode.items[i])) schemaNode = {
 					...tupleNode,
 					items: namedItems
@@ -1459,11 +1390,11 @@ function createOasParser(oas, { contentType } = {}) {
 		});
 		if (isDiscriminator(schema) && schema.discriminator.mapping) {
 			const discPropName = schema.discriminator.propertyName;
-			return (0, _kubb_ast.applyDiscriminatorEnum)({
+			return (0, _kubb_ast.setDiscriminatorEnum)({
 				node: objectNode,
 				propertyName: discPropName,
 				values: Object.keys(schema.discriminator.mapping),
-				enumName: name ? resolveEnumPropName(name, discPropName, options.enumSuffix) : void 0
+				enumName: name ? (0, _kubb_ast.enumPropName)(name, discPropName, options.enumSuffix) : void 0
 			});
 		}
 		return objectNode;
@@ -1495,7 +1426,7 @@ function createOasParser(oas, { contentType } = {}) {
 	*/
 	function convertArray({ schema, name, nullable, defaultValue, rawOptions, options }) {
 		const rawItems = schema.items;
-		const itemName = rawItems?.enum?.length && name ? resolveEnumPropName(void 0, name, options.enumSuffix) : void 0;
+		const itemName = rawItems?.enum?.length && name ? (0, _kubb_ast.enumPropName)(void 0, name, options.enumSuffix) : void 0;
 		return (0, _kubb_ast.createSchema)({
 			type: "array",
 			primitive: "array",
@@ -1726,15 +1657,16 @@ function createOasParser(oas, { contentType } = {}) {
 			operations: Object.entries(paths).flatMap(([_path, methods]) => Object.entries(methods).map(([, operation]) => operation ? parseOperation(mergedOptions, oas, operation) : null).filter((op) => op !== null))
 		});
 	}
+	const resolveRefs = (node, resolveName, resolveEnumName) => (0, _kubb_ast.resolveNames)({
+		node,
+		nameMapping,
+		resolveName,
+		resolveEnumName
+	});
 	return {
 		parse,
 		convertSchema,
-		resolveRefs: /* @__PURE__ */ __name((node, resolveName, resolveEnumName) => resolveRefs({
-			node,
-			nameMapping,
-			resolveName,
-			resolveEnumName
-		}), "resolveRefs"),
+		resolveRefs,
 		nameMapping
 	};
 }
@@ -1779,10 +1711,17 @@ const adapterOas = (0, _kubb_core.createAdapter)((options) => {
 			nameMapping
 		},
 		getImports(node, resolve) {
-			return getImports({
+			return (0, _kubb_ast.collectImports)({
 				node,
 				nameMapping,
-				resolve
+				resolve: (schemaName) => {
+					const result = resolve(schemaName);
+					if (!result) return;
+					return {
+						name: [result.name],
+						path: result.path
+					};
+				}
 			});
 		},
 		async parse(source) {