@kubb/adapter-oas 5.0.0-beta.30 → 5.0.0-beta.32

package/dist/index.d.ts

@@ -1,5 +1,4 @@
-import { t as __name } from "./chunk--u3MIqq1.js";
-import * as _$_kubb_core0 from "@kubb/core";
+import { t as __name } from "./chunk-C0LytTxp.js";
 import { AdapterFactoryOptions, ast } from "@kubb/core";
 import { DiscriminatorObject as DiscriminatorObject$2, MediaTypeObject as MediaTypeObject$2, OASDocument, ResponseObject as ResponseObject$2, SchemaObject as SchemaObject$2 } from "oas/types";
 import { Operation as Operation$1 } from "oas/operation";
@@ -476,6 +475,18 @@ type AdapterOasOptions = {
    * @default 'strict'
    */
   discriminator?: 'strict' | 'inherit';
+  /**
+   * Collapse structurally identical schemas and enums into a single shared definition.
+   *
+   * Duplicated inline shapes (especially enums repeated across many properties) are hoisted
+   * into one named schema; every other occurrence — and any structurally identical top-level
+   * component — becomes a `ref` to it. Equality is shape-only: documentation such as
+   * `description` and `example` is ignored. Enabled by default; set to `false` to keep every
+   * occurrence inline and produce byte-for-byte identical output to earlier versions.
+   *
+   * @default true
+   */
+  dedupe?: boolean;
 } & Partial<ast.ParserOptions>;
 /**
  * Adapter options after defaults have been applied and schema name collisions resolved.
@@ -486,6 +497,7 @@ type AdapterOasResolvedOptions = {
   serverIndex: AdapterOasOptions['serverIndex'];
   serverVariables: AdapterOasOptions['serverVariables'];
   discriminator: NonNullable<AdapterOasOptions['discriminator']>;
+  dedupe: NonNullable<AdapterOasOptions['dedupe']>;
   dateType: NonNullable<AdapterOasOptions['dateType']>;
   integerType: NonNullable<AdapterOasOptions['integerType']>;
   unknownType: NonNullable<AdapterOasOptions['unknownType']>;
@@ -540,7 +552,7 @@ declare const adapterOasName = "oas";
  * })
  * ```
  */
-declare const adapterOas: (options?: AdapterOasOptions | undefined) => _$_kubb_core0.Adapter<AdapterOas>;
+declare const adapterOas: (options?: AdapterOasOptions | undefined) => import("@kubb/core").Adapter<AdapterOas>;
 //#endregion
 //#region src/factory.d.ts
 type ValidateDocumentOptions = {

package/dist/index.js

@@ -1,4 +1,4 @@
-import "./chunk--u3MIqq1.js";
+import "./chunk-C0LytTxp.js";
 import path from "node:path";
 import { ast, createAdapter } from "@kubb/core";
 import BaseOas from "oas";
@@ -1484,6 +1484,15 @@ function createSchemaParser(ctx, dialect = oasDialect) {
 		}, rawOptions);
 		const nullInEnum = schema.enum.includes(null);
 		const filteredValues = nullInEnum ? schema.enum.filter((v) => v !== null) : schema.enum;
+		if (nullInEnum && filteredValues.length === 0) return ast.createSchema({
+			type: "null",
+			primitive: "null",
+			name,
+			title: schema.title,
+			description: schema.description,
+			deprecated: schema.deprecated,
+			format: schema.format
+		});
 		const enumNullable = nullable || nullInEnum || void 0;
 		const enumDefault = schema.default === null && enumNullable ? void 0 : schema.default;
 		const enumPrimitive = getPrimitiveType(type);
@@ -1989,9 +1998,8 @@ function createSchemaParser(ctx, dialect = oasDialect) {
 * 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`.
 *
-* 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.
+* The streaming path calls this on a small pre-parsed subset of schemas (only the
+* discriminator parents) rather than on all schemas at once.
 */
 function buildDiscriminatorChildMap(schemas) {
 	const childMap = /* @__PURE__ */ new Map();
@@ -2065,6 +2073,36 @@ function patchDiscriminatorNode(node, entry) {
 //#endregion
 //#region src/stream.ts
 /**
+* Builds the deduplication plan from the already-parsed top-level schema nodes plus a
+* single extra parse pass over operations (so duplicates in request/response bodies are seen).
+*
+* Only enums and objects are candidates, and object shapes that reference a circular schema are
+* rejected to avoid hoisting recursive structures. Inline shapes reuse their context-derived
+* name (collision-resolved against existing component names); shapes without a name stay inline.
+*/
+function createDedupePlan({ schemaNodes, operationNodes, schemaNames, circularNames }) {
+	const circularSchemas = new Set(circularNames);
+	const usedNames = new Set(schemaNames);
+	return ast.buildDedupePlan([...schemaNodes, ...operationNodes], {
+		isCandidate: (node) => {
+			if (node.type === "enum") return true;
+			if (node.type !== "object") return false;
+			if (node.name && circularSchemas.has(node.name)) return false;
+			return !ast.containsCircularRef(node, { circularSchemas });
+		},
+		nameFor: (node) => {
+			const base = node.name;
+			if (!base) return null;
+			let name = base;
+			let counter = 2;
+			while (usedNames.has(name)) name = `${base}${counter++}`;
+			usedNames.add(name);
+			return name;
+		},
+		refFor: (name) => `${SCHEMA_REF_PREFIX}${name}`
+	});
+}
+/**
 * Reads the server URL from the document's `servers` array at `serverIndex`,
 * interpolating any `serverVariables` into the URL template.
 *
@@ -2105,7 +2143,7 @@ function resolveBaseUrl({ document, serverIndex, serverVariables }) {
 * })
 * ```
 */
-function preScan({ schemas, parseSchema, parserOptions, discriminator }) {
+function preScan({ schemas, parseSchema, parseOperation, baseOas, parserOptions, discriminator, dedupe }) {
 	const allNodes = [];
 	const refAliasMap = /* @__PURE__ */ new Map();
 	const enumNames = [];
@@ -2120,11 +2158,30 @@ function preScan({ schemas, parseSchema, parserOptions, discriminator }) {
 		if (ast.narrowSchema(node, ast.schemaTypes.enum) && node.name) enumNames.push(node.name);
 		if (discriminator === "inherit" && (schema.oneOf ?? schema.anyOf) && schema.discriminator?.propertyName) discriminatorParentNodes.push(node);
 	}
+	const circularNames = [...ast.findCircularSchemas(allNodes)];
+	const discriminatorChildMap = discriminatorParentNodes.length > 0 ? buildDiscriminatorChildMap(discriminatorParentNodes) : null;
+	let dedupePlan = null;
+	if (dedupe) {
+		const operationNodes = [];
+		for (const methods of Object.values(baseOas.getPaths())) for (const operation of Object.values(methods)) {
+			if (!operation) continue;
+			const operationNode = parseOperation(parserOptions, operation);
+			if (operationNode) operationNodes.push(operationNode);
+		}
+		dedupePlan = createDedupePlan({
+			schemaNodes: allNodes,
+			operationNodes,
+			schemaNames: Object.keys(schemas),
+			circularNames
+		});
+		for (const definition of dedupePlan.hoisted) if (definition.type === "enum" && definition.name) enumNames.push(definition.name);
+	}
 	return {
 		refAliasMap,
 		enumNames,
-		circularNames: [...ast.findCircularSchemas(allNodes)],
-		discriminatorChildMap: discriminatorParentNodes.length > 0 ? buildDiscriminatorChildMap(discriminatorParentNodes) : null
+		circularNames,
+		discriminatorChildMap,
+		dedupePlan
 	};
 }
 /**
@@ -2145,26 +2202,39 @@ function preScan({ schemas, parseSchema, parserOptions, discriminator }) {
 * }
 * ```
 */
-function createInputStream({ schemas, parseSchema, parseOperation, baseOas, parserOptions, refAliasMap, discriminatorChildMap, meta }) {
+function createInputStream({ schemas, parseSchema, parseOperation, baseOas, parserOptions, refAliasMap, discriminatorChildMap, dedupePlan, meta }) {
+	const rewriteTopLevelSchema = (node) => {
+		if (!dedupePlan) return node;
+		const canonical = dedupePlan.canonicalBySignature.get(ast.schemaSignature(node));
+		if (canonical && canonical.name !== node.name) return ast.createSchema({
+			type: "ref",
+			name: node.name ?? null,
+			ref: canonical.ref,
+			description: node.description,
+			deprecated: node.deprecated
+		});
+		return ast.applyDedupe(node, dedupePlan.canonicalBySignature, true);
+	};
 	const schemasIterable = { [Symbol.asyncIterator]() {
 		return (async function* () {
+			if (dedupePlan) for (const definition of dedupePlan.hoisted) yield definition;
 			for (const [name, schema] of Object.entries(schemas)) {
 				const alias = refAliasMap.get(name);
 				if (alias?.name && schemas[alias.name]) {
-					yield {
+					yield rewriteTopLevelSchema({
 						...parseSchema({
 							schema: schemas[alias.name],
 							name: alias.name
 						}, parserOptions),
 						name
-					};
+					});
 					continue;
 				}
 				const parsed = parseSchema({
 					schema,
 					name
 				}, parserOptions);
-				yield discriminatorChildMap?.get(name) ? patchDiscriminatorNode(parsed, discriminatorChildMap.get(name)) : parsed;
+				yield rewriteTopLevelSchema(discriminatorChildMap?.get(name) ? patchDiscriminatorNode(parsed, discriminatorChildMap.get(name)) : parsed);
 			}
 		})();
 	} };
@@ -2173,7 +2243,7 @@ function createInputStream({ schemas, parseSchema, parseOperation, baseOas, pars
 			for (const methods of Object.values(baseOas.getPaths())) for (const operation of Object.values(methods)) {
 				if (!operation) continue;
 				const node = parseOperation(parserOptions, operation);
-				if (node) yield node;
+				if (node) yield dedupePlan ? ast.applyDedupe(node, dedupePlan.canonicalBySignature) : node;
 			}
 		})();
 	} };
@@ -2213,7 +2283,7 @@ 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 { validate = true, contentType, serverIndex, serverVariables, discriminator = "strict", dedupe = true, 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,
@@ -2240,25 +2310,30 @@ const adapterOas = createAdapter((options) => {
 		document,
 		contentType
 	}));
-	const ensurePreScan = once((schemas, parseSchema) => preScan({
+	const ensurePreScan = once((schemas, parseSchema, parseOperation, baseOas) => preScan({
 		schemas,
 		parseSchema,
+		parseOperation,
+		baseOas,
 		parserOptions,
-		discriminator
+		discriminator,
+		dedupe
 	}));
 	async function createStream(source) {
 		const document = await ensureDocument(source);
 		const schemas = await ensureSchemas(document);
 		const { parseSchema, parseOperation } = ensureSchemaParser(document);
-		const { refAliasMap, enumNames, circularNames, discriminatorChildMap } = ensurePreScan(schemas, parseSchema);
+		const baseOas = ensureBaseOas(document);
+		const { refAliasMap, enumNames, circularNames, discriminatorChildMap, dedupePlan } = ensurePreScan(schemas, parseSchema, parseOperation, baseOas);
 		return createInputStream({
 			schemas,
 			parseSchema,
 			parseOperation,
-			baseOas: ensureBaseOas(document),
+			baseOas,
 			parserOptions,
 			refAliasMap,
 			discriminatorChildMap,
+			dedupePlan,
 			meta: {
 				title: document.info?.title,
 				description: document.info?.description,
@@ -2282,6 +2357,7 @@ const adapterOas = createAdapter((options) => {
 				serverIndex,
 				serverVariables,
 				discriminator,
+				dedupe,
 				dateType,
 				integerType,
 				unknownType,