@kubb/adapter-oas 5.0.0-beta.60 → 5.0.0-beta.61

package/dist/index.js

@@ -5,7 +5,8 @@ import { access, readFile } from "node:fs/promises";
 import { compileErrors, validate } from "@readme/openapi-parser";
 import { parse } from "yaml";
 import { bundle } from "api-ref-bundler";
-import { childName, containsCircularRef, enumPropName, extractRefName, findCircularSchemas } from "@kubb/ast/utils";
+import { macroDiscriminatorEnum, macroEnumName, macroSimplifyUnion } from "@kubb/ast/macros";
+import { childName, containsCircularRef, enumPropName, extractRefName, findCircularSchemas, mergeAdjacentObjectsLazy } from "@kubb/ast/utils";
 import { collect, narrowSchema } from "@kubb/ast";
 //#region src/constants.ts
 /**
@@ -1560,6 +1561,23 @@ function normalizeArrayEnum(schema) {
 	};
 }
 /**
+* Names the inline enums on a property's schema, and on each item when the property is a tuple, from
+* the parent and property name. Wraps `macroEnumName` at the property construction site.
+*/
+function nameEnums(node, options) {
+	const macro = macroEnumName(options);
+	const named = ast.applyMacros(node, [macro], { depth: "shallow" });
+	const tupleNode = ast.narrowSchema(named, "tuple");
+	if (tupleNode?.items) {
+		const namedItems = tupleNode.items.map((item) => ast.applyMacros(item, [macro], { depth: "shallow" }));
+		if (namedItems.some((item, i) => item !== tupleNode.items[i])) return {
+			...tupleNode,
+			items: namedItems
+		};
+	}
+	return named;
+}
+/**
 * Factory function that creates schema and operation converters for a given OpenAPI context.
 *
 * Returns closures that share mutable state (`resolvingRefs` set for cycle detection).
@@ -1700,7 +1718,7 @@ function createSchemaParser(ctx, dialect = oasDialect) {
 		}));
 		return ast.factory.createSchema({
 			type: "intersection",
-			members: [...ast.mergeAdjacentObjectsLazy(allOfMembers.slice(0, syntheticStart)), ...ast.mergeAdjacentObjectsLazy(allOfMembers.slice(syntheticStart))],
+			members: [...mergeAdjacentObjectsLazy(allOfMembers.slice(0, syntheticStart)), ...mergeAdjacentObjectsLazy(allOfMembers.slice(syntheticStart))],
 			...buildSchemaNode(schema, name, nullable, defaultValue)
 		});
 	}
@@ -1741,11 +1759,10 @@ function createSchemaParser(ctx, dialect = oasDialect) {
 					name
 				}, rawOptions);
 				if (!discriminatorValue || !discriminator) return memberNode;
-				const narrowedDiscriminatorNode = sharedPropertiesNode ? pickDiscriminatorPropertyNode(ast.setDiscriminatorEnum({
-					node: sharedPropertiesNode,
+				const narrowedDiscriminatorNode = sharedPropertiesNode ? pickDiscriminatorPropertyNode(ast.applyMacros(sharedPropertiesNode, [macroDiscriminatorEnum({
 					propertyName: discriminator.propertyName,
 					values: [discriminatorValue]
-				}), discriminator.propertyName) : void 0;
+				})], { depth: "shallow" }), discriminator.propertyName) : void 0;
 				return ast.factory.createSchema({
 					type: "intersection",
 					members: [memberNode, narrowedDiscriminatorNode ?? createDiscriminantNode({
@@ -1766,14 +1783,15 @@ function createSchemaParser(ctx, dialect = oasDialect) {
 				members: [unionNode, sharedPropertiesNode]
 			});
 		}
-		return ast.factory.createSchema({
+		const unionNode = ast.factory.createSchema({
 			type: "union",
 			...unionBase,
-			members: ast.simplifyUnion(unionMembers.map((s) => parseSchema({
+			members: unionMembers.map((s) => parseSchema({
 				schema: s,
 				name
-			}, rawOptions)))
+			}, rawOptions))
 		});
+		return ast.applyMacros(unionNode, [macroSimplifyUnion], { depth: "shallow" });
 	}
 	/**
 	* Converts an OAS 3.1 `const` schema into a null scalar or a single-value `EnumSchemaNode`.
@@ -1936,22 +1954,14 @@ function createSchemaParser(ctx, dialect = oasDialect) {
 			const required = Array.isArray(schema.required) ? schema.required.includes(propName) : !!schema.required;
 			const resolvedPropSchema = propSchema;
 			const propNullable = dialect.isNullable(resolvedPropSchema);
-			const propNode = parseSchema({
+			const schemaNode = nameEnums(parseSchema({
 				schema: resolvedPropSchema,
 				name: childName(name, propName)
-			}, rawOptions);
-			const schemaNode = (() => {
-				const node = ast.setEnumName(propNode, name, propName, options.enumSuffix);
-				const tupleNode = ast.narrowSchema(node, "tuple");
-				if (tupleNode?.items) {
-					const namedItems = tupleNode.items.map((item) => ast.setEnumName(item, name, propName, options.enumSuffix));
-					if (namedItems.some((item, i) => item !== tupleNode.items[i])) return {
-						...tupleNode,
-						items: namedItems
-					};
-				}
-				return node;
-			})();
+			}, rawOptions), {
+				parentName: name,
+				propName,
+				enumSuffix: options.enumSuffix
+			});
 			return ast.factory.createProperty({
 				name: propName,
 				schema: {
@@ -1984,12 +1994,11 @@ function createSchemaParser(ctx, dialect = oasDialect) {
 			const discPropName = schema.discriminator.propertyName;
 			const values = Object.keys(schema.discriminator.mapping);
 			const enumName = name ? enumPropName(name, discPropName, options.enumSuffix) : void 0;
-			return ast.setDiscriminatorEnum({
-				node: objectNode,
+			return ast.applyMacros(objectNode, [macroDiscriminatorEnum({
 				propertyName: discPropName,
 				values,
 				enumName
-			});
+			})], { depth: "shallow" });
 		}
 		return objectNode;
 	}