@kubb/adapter-oas 5.0.0-beta.15 → 5.0.0-beta.16

package/dist/index.js

@@ -1,10 +1,10 @@
 import "./chunk--u3MIqq1.js";
 import { ast, createAdapter } from "@kubb/core";
+import BaseOas from "oas";
 import path from "node:path";
 import { bundle, loadConfig } from "@redocly/openapi-core";
 import OASNormalize from "oas-normalize";
 import swagger2openapi from "swagger2openapi";
-import BaseOas from "oas";
 import { isRef } from "oas/types";
 import { matchesMimeType } from "oas/utils";
 //#region src/constants.ts
@@ -129,23 +129,16 @@ const typeOptionMap = new Map([
 //#endregion
 //#region src/discriminator.ts
 /**
-* Injects discriminator enum values into child schemas so they know which value identifies them.
-*
-* Finds every union schema in `input.schemas` that has a `discriminatorPropertyName`, collects the
-* enum value each union member is mapped to, then adds (or replaces) that property on the matching
-* child object schema.
+* Builds a map of child schema names → discriminator patch data by scanning the given
+* top-level AST schema nodes for union schemas that carry a `discriminatorPropertyName`.
 *
-* Returns a new `InputNode` — the original is never mutated.
-*
-* @example
-* ```ts
-* const { root } = parseOas(document, options)
-* const next = applyDiscriminatorInheritance(root)
-* ```
+* Extracted from `applyDiscriminatorInheritance` so the streaming path can call it on a
+* small pre-parsed subset of schemas (only the discriminator parents) rather than on all
+* schemas at once.
 */
-function applyDiscriminatorInheritance(root) {
+function buildDiscriminatorChildMap(schemas) {
 	const childMap = /* @__PURE__ */ new Map();
-	for (const schema of root.schemas) {
+	for (const schema of schemas) {
 		let unionNode = ast.narrowSchema(schema, "union");
 		if (!unionNode) {
 			const intersectionMembers = ast.narrowSchema(schema, "intersection")?.members;
@@ -182,29 +175,56 @@ function applyDiscriminatorInheritance(root) {
 			});
 		}
 	}
+	return childMap;
+}
+/**
+* Patches a single top-level `SchemaNode` with its discriminator entry (adds or replaces
+* the discriminant property). Used by the streaming path to apply patches inline per yield
+* without buffering all schemas.
+*/
+function patchDiscriminatorNode(node, entry) {
+	const objectNode = ast.narrowSchema(node, "object");
+	if (!objectNode) return node;
+	const { propertyName, enumValues } = entry;
+	const enumSchema = ast.createSchema({
+		type: "enum",
+		enumValues
+	});
+	const newProp = ast.createProperty({
+		name: propertyName,
+		required: true,
+		schema: enumSchema
+	});
+	const existingIdx = objectNode.properties.findIndex((p) => p.name === propertyName);
+	const newProperties = existingIdx >= 0 ? objectNode.properties.map((p, i) => i === existingIdx ? newProp : p) : [...objectNode.properties, newProp];
+	return {
+		...objectNode,
+		properties: newProperties
+	};
+}
+/**
+* Injects discriminator enum values into child schemas so they know which value identifies them.
+*
+* Finds every union schema in `input.schemas` that has a `discriminatorPropertyName`, collects the
+* enum value each union member is mapped to, then adds (or replaces) that property on the matching
+* child object schema.
+*
+* Returns a new `InputNode` — the original is never mutated.
+*
+* @example
+* ```ts
+* const { root } = parseOas(document, options)
+* const next = applyDiscriminatorInheritance(root)
+* ```
+*/
+function applyDiscriminatorInheritance(root) {
+	const childMap = buildDiscriminatorChildMap(root.schemas);
 	if (childMap.size === 0) return root;
 	return ast.transform(root, { schema(node, { parent }) {
 		if (parent?.kind !== "Input" || !node.name) return;
 		const entry = childMap.get(node.name);
 		if (!entry) return;
-		const objectNode = ast.narrowSchema(node, "object");
-		if (!objectNode) return;
-		const { propertyName, enumValues } = entry;
-		const enumSchema = ast.createSchema({
-			type: "enum",
-			enumValues
-		});
-		const newProp = ast.createProperty({
-			name: propertyName,
-			required: true,
-			schema: enumSchema
-		});
-		const existingIdx = objectNode.properties.findIndex((p) => p.name === propertyName);
-		const newProperties = existingIdx >= 0 ? objectNode.properties.map((p, i) => i === existingIdx ? newProp : p) : [...objectNode.properties, newProp];
-		return {
-			...objectNode,
-			properties: newProperties
-		};
+		return patchDiscriminatorNode(node, entry);
 	} });
 }
 //#endregion
@@ -1174,7 +1194,7 @@ function normalizeArrayEnum(schema) {
 * Each converter branch (`convertRef`, `convertAllOf`, etc.) mutually recursively calls `parseSchema`,
 * made possible by hoisting of function declarations.
 *
-* @note Not exported; called internally by `parseOas()` and `parseSchema()`.
+* @internal
 */
 function createSchemaParser(ctx) {
 	const document = ctx.document;
@@ -1917,8 +1937,36 @@ const adapterOasName = "oas";
 */
 const adapterOas = createAdapter((options) => {
 	const { validate = true, contentType, serverIndex, serverVariables, discriminator = "strict", dateType = DEFAULT_PARSER_OPTIONS.dateType, integerType = DEFAULT_PARSER_OPTIONS.integerType, unknownType = DEFAULT_PARSER_OPTIONS.unknownType, enumSuffix = DEFAULT_PARSER_OPTIONS.enumSuffix, emptySchemaType = unknownType || DEFAULT_PARSER_OPTIONS.emptySchemaType } = options;
+	const parserOptions = {
+		...DEFAULT_PARSER_OPTIONS,
+		dateType,
+		integerType,
+		unknownType,
+		emptySchemaType,
+		enumSuffix
+	};
 	let nameMapping = /* @__PURE__ */ new Map();
-	let parsedDocument;
+	let parsedDocument = null;
+	let schemaObjects = null;
+	function resolveBaseURL(document) {
+		const server = serverIndex !== void 0 ? document.servers?.at(serverIndex) : void 0;
+		return server?.url ? resolveServerUrl(server, serverVariables) : void 0;
+	}
+	async function ensureDocument(source) {
+		if (parsedDocument) return parsedDocument;
+		const fresh = await parseFromConfig(source);
+		if (validate) await validateDocument(fresh);
+		parsedDocument = fresh;
+		return fresh;
+	}
+	async function ensureSchemas(document) {
+		if (!schemaObjects) {
+			const result = getSchemas(document, { contentType });
+			schemaObjects = result.schemas;
+			nameMapping = result.nameMapping;
+		}
+		return schemaObjects;
+	}
 	return {
 		name: "oas",
 		get options() {
@@ -1957,10 +2005,7 @@ const adapterOas = createAdapter((options) => {
 			});
 		},
 		async parse(source) {
-			const document = await parseFromConfig(source);
-			if (validate) await validateDocument(document);
-			const server = serverIndex !== void 0 ? document.servers?.at(serverIndex) : void 0;
-			const baseURL = server?.url ? resolveServerUrl(server, serverVariables) : void 0;
+			const document = await ensureDocument(source);
 			const { root: parsedRoot, nameMapping: parsedNameMapping } = parseOas(document, {
 				contentType,
 				dateType,
@@ -1971,16 +2016,79 @@ const adapterOas = createAdapter((options) => {
 			});
 			const node = discriminator === "inherit" ? applyDiscriminatorInheritance(parsedRoot) : parsedRoot;
 			nameMapping = parsedNameMapping;
-			parsedDocument = document;
 			return ast.createInput({
 				...node,
 				meta: {
 					title: document.info?.title,
 					description: document.info?.description,
 					version: document.info?.version,
-					baseURL
+					baseURL: resolveBaseURL(document)
 				}
 			});
+		},
+		async count(source) {
+			const document = await ensureDocument(source);
+			const schemas = await ensureSchemas(document);
+			const baseOas = new BaseOas(document);
+			const operationCount = Object.values(baseOas.getPaths()).flatMap(Object.values).filter(Boolean).length;
+			return {
+				schemas: Object.keys(schemas).length,
+				operations: operationCount
+			};
+		},
+		async stream(source) {
+			const document = await ensureDocument(source);
+			const schemas = await ensureSchemas(document);
+			let discriminatorChildMap = null;
+			if (discriminator === "inherit") {
+				const { parseSchema: _preParser } = createSchemaParser({
+					document,
+					contentType
+				});
+				const parentNodes = [];
+				for (const [name, schema] of Object.entries(schemas)) if ((schema.oneOf ?? schema.anyOf) && schema.discriminator?.propertyName) parentNodes.push(_preParser({
+					schema,
+					name
+				}, parserOptions));
+				if (parentNodes.length > 0) discriminatorChildMap = buildDiscriminatorChildMap(parentNodes);
+			}
+			const schemasIterable = { [Symbol.asyncIterator]() {
+				return (async function* () {
+					const { parseSchema: _parseSchema } = createSchemaParser({
+						document,
+						contentType
+					});
+					for (const [name, schema] of Object.entries(schemas)) {
+						let node = _parseSchema({
+							schema,
+							name
+						}, parserOptions);
+						const entry = discriminatorChildMap?.get(name);
+						if (entry) node = patchDiscriminatorNode(node, entry);
+						yield node;
+					}
+				})();
+			} };
+			const operationsIterable = { [Symbol.asyncIterator]() {
+				return (async function* () {
+					const { parseOperation: _parseOperation } = createSchemaParser({
+						document,
+						contentType
+					});
+					const paths = new BaseOas(document).getPaths();
+					for (const methods of Object.values(paths)) for (const operation of Object.values(methods)) {
+						if (!operation) continue;
+						const node = _parseOperation(parserOptions, operation);
+						if (node) yield node;
+					}
+				})();
+			} };
+			return ast.createStreamInput(schemasIterable, operationsIterable, {
+				title: document.info?.title,
+				description: document.info?.description,
+				version: document.info?.version,
+				baseURL: resolveBaseURL(document)
+			});
 		}
 	};
 });