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

package/dist/index.d.ts

@@ -3,6 +3,7 @@ import * as _kubb_core0 from "@kubb/core";
 import { AdapterFactoryOptions } from "@kubb/core";
 import { DiscriminatorObject, OASDocument, ParameterObject, SchemaObject } from "oas/types";
 import BaseOas from "oas";
+import { ParserOptions } from "@kubb/ast/types";
 import * as oas_normalize_lib_types0 from "oas-normalize/lib/types";
 import { Operation } from "oas/operation";
 import { OpenAPIV3 } from "openapi-types";
@@ -94,31 +95,6 @@ declare class Oas extends BaseOas {
 }
 //#endregion
 //#region src/types.d.ts
-/**
- * Controls how various OAS constructs are mapped to Kubb AST nodes.
- */
-type ParserOptions = {
-  /**
-   * How `format: 'date-time'` schemas are represented. `false` falls through to a plain string.
-   */
-  dateType: false | 'string' | 'stringOffset' | 'stringLocal' | 'date';
-  /**
-   * Whether `type: 'integer'` and `format: 'int64'` produce `number` or `bigint` nodes.
-   */
-  integerType?: 'number' | 'bigint';
-  /**
-   * AST type used when no schema type can be inferred.
-   */
-  unknownType: 'any' | 'unknown' | 'void';
-  /**
-   * AST type used for completely empty schemas (`{}`).
-   */
-  emptySchemaType: 'any' | 'unknown' | 'void';
-  /**
-   * Suffix appended to derived enum names when building property schema names.
-   */
-  enumSuffix: 'enum' | (string & {});
-};
 type OasAdapterOptions = {
   /**
    * Validate the OpenAPI spec before parsing.

package/dist/index.js

@@ -1,6 +1,6 @@
-import { t as __name } from "./chunk--u3MIqq1.js";
+import "./chunk--u3MIqq1.js";
 import path from "node:path";
-import { applyDiscriminatorEnum, collect, createOperation, createParameter, createProperty, createResponse, createRoot, createSchema, extractRefName, mediaTypes, mergeAdjacentAnonymousObjects, narrowSchema, schemaTypes, simplifyUnionMembers, transform } from "@kubb/ast";
+import { childName, collectImports, createDiscriminantNode, createOperation, createParameter, createProperty, createResponse, createRoot, createSchema, enumPropName, extractRefName, findDiscriminator, mediaTypes, mergeAdjacentObjects, narrowSchema, resolveNames, schemaTypes, setDiscriminatorEnum, setEnumName, simplifyUnion } from "@kubb/ast";
 import { createAdapter } from "@kubb/core";
 import { bundle, loadConfig } from "@redocly/openapi-core";
 import yaml from "@stoplight/yaml";
@@ -882,91 +882,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 createSchema({
-		type: "object",
-		primitive: "object",
-		properties: [createProperty({
-			name: propertyName,
-			schema: 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 = 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 collect(node, { schema(schemaNode) {
-		if (schemaNode.type !== "ref" || !schemaNode.ref) return;
-		const rawName = 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 transform(node, { schema(schemaNode) {
-		const schemaRef = narrowSchema(schemaNode, 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.
@@ -1156,7 +1071,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 = findDiscriminator(deref.discriminator.mapping, childRef);
 				if (discriminatorValue) filteredDiscriminantValues.push({
 					propertyName: deref.discriminator.propertyName,
 					value: discriminatorValue
@@ -1188,10 +1103,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(createDiscriminantNode({
+			propertyName,
+			value
+		}));
 		return createSchema({
 			type: "intersection",
-			members: [...mergeAdjacentAnonymousObjects(allOfMembers.slice(0, syntheticStart)), ...mergeAdjacentAnonymousObjects(allOfMembers.slice(syntheticStart))],
+			members: [...mergeAdjacentObjects(allOfMembers.slice(0, syntheticStart)), ...mergeAdjacentObjects(allOfMembers.slice(syntheticStart))],
 			...renderSchemaBase(schema, name, nullable, defaultValue)
 		});
 	}
@@ -1204,6 +1122,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 = narrowSchema(node, "object")?.properties?.find((property) => property.name === propertyName);
+			if (!discriminatorProperty) return;
+			return createSchema({
+				type: "object",
+				primitive: "object",
+				properties: [discriminatorProperty]
+			});
+		}
 		const unionMembers = [...schema.oneOf ?? [], ...schema.anyOf ?? []];
 		const unionBase = {
 			...renderSchemaBase(schema, name, nullable, defaultValue),
@@ -1217,32 +1144,40 @@ function createOasParser(oas, { contentType } = {}) {
 				name
 			}, rawOptions);
 		})() : void 0;
-		if (sharedPropertiesNode || discriminator?.mapping) return 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 = findDiscriminator(discriminator?.mapping, ref);
 				const memberNode = convertSchema({ schema: s }, rawOptions);
-				if (sharedPropertiesNode) return createSchema({
+				if (!discriminatorValue || !discriminator) return memberNode;
+				return createSchema({
 					type: "intersection",
-					members: [memberNode, discriminatorValue && discriminator ? applyDiscriminatorEnum({
+					members: [memberNode, (sharedPropertiesNode ? pickDiscriminatorPropertyNode(setDiscriminatorEnum({
 						node: sharedPropertiesNode,
 						propertyName: discriminator.propertyName,
 						values: [discriminatorValue]
-					}) : sharedPropertiesNode]
-				});
-				if (!discriminatorValue || !discriminator) return memberNode;
-				return createSchema({
-					type: "intersection",
-					members: [memberNode, createDiscriminantNode(discriminator.propertyName, discriminatorValue)]
+					}), discriminator.propertyName) : void 0) ?? createDiscriminantNode({
+						propertyName: discriminator.propertyName,
+						value: discriminatorValue
+					})]
 				});
-			})
-		});
+			});
+			const unionNode = createSchema({
+				type: "union",
+				...unionBase,
+				members
+			});
+			if (!sharedPropertiesNode) return unionNode;
+			return createSchema({
+				type: "intersection",
+				...renderSchemaBase(schema, name, nullable, defaultValue),
+				members: [unionNode, sharedPropertiesNode]
+			});
+		}
 		return createSchema({
 			type: "union",
 			...unionBase,
-			members: simplifyUnionMembers(unionMembers.map((s) => convertSchema({ schema: s }, rawOptions)))
+			members: simplifyUnion(unionMembers.map((s) => convertSchema({ schema: s }, rawOptions)))
 		});
 	}
 	/**
@@ -1354,15 +1289,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 createSchema({
 				...enumBase,
-				enumType,
+				primitive: enumPrimitiveType,
 				namedEnumValues: sourceValues.map((label, index) => ({
 					name: String(label),
 					value: extensionKey ? filteredValues[index] ?? label : label,
-					format: enumType
+					primitive: enumPrimitiveType
 				}))
 			});
 		}
@@ -1388,13 +1323,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 = setEnumName(convertSchema({
 				schema: resolvedPropSchema,
-				name: resolveChildName(name, propName)
+				name: childName(name, propName)
 			}, rawOptions), name, propName, options.enumSuffix);
 			const tupleNode = narrowSchema(schemaNode, "tuple");
 			if (tupleNode?.items) {
-				const namedItems = tupleNode.items.map((item) => applyEnumName(item, name, propName, options.enumSuffix));
+				const namedItems = tupleNode.items.map((item) => setEnumName(item, name, propName, options.enumSuffix));
 				if (namedItems.some((item, i) => item !== tupleNode.items[i])) schemaNode = {
 					...tupleNode,
 					items: namedItems
@@ -1427,11 +1362,11 @@ function createOasParser(oas, { contentType } = {}) {
 		});
 		if (isDiscriminator(schema) && schema.discriminator.mapping) {
 			const discPropName = schema.discriminator.propertyName;
-			return applyDiscriminatorEnum({
+			return setDiscriminatorEnum({
 				node: objectNode,
 				propertyName: discPropName,
 				values: Object.keys(schema.discriminator.mapping),
-				enumName: name ? resolveEnumPropName(name, discPropName, options.enumSuffix) : void 0
+				enumName: name ? enumPropName(name, discPropName, options.enumSuffix) : void 0
 			});
 		}
 		return objectNode;
@@ -1463,7 +1398,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 ? enumPropName(void 0, name, options.enumSuffix) : void 0;
 		return createSchema({
 			type: "array",
 			primitive: "array",
@@ -1694,15 +1629,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) => resolveNames({
+		node,
+		nameMapping,
+		resolveName,
+		resolveEnumName
+	});
 	return {
 		parse,
 		convertSchema,
-		resolveRefs: /* @__PURE__ */ __name((node, resolveName, resolveEnumName) => resolveRefs({
-			node,
-			nameMapping,
-			resolveName,
-			resolveEnumName
-		}), "resolveRefs"),
+		resolveRefs,
 		nameMapping
 	};
 }
@@ -1747,10 +1683,17 @@ const adapterOas = createAdapter((options) => {
 			nameMapping
 		},
 		getImports(node, resolve) {
-			return getImports({
+			return collectImports({
 				node,
 				nameMapping,
-				resolve
+				resolve: (schemaName) => {
+					const result = resolve(schemaName);
+					if (!result) return;
+					return {
+						name: [result.name],
+						path: result.path
+					};
+				}
 			});
 		},
 		async parse(source) {